New Feature added (#33)

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

Backend/__main__.py

@@ -10,6 +10,8 @@ from Backend.fastapi import server
 from Backend.helper.pyro import restart_notification, setup_bot_commands
 from Backend.pyrofork.bot import Helper, StreamBot
 from Backend.pyrofork.clients import initialize_clients
+from Backend.helper.link_checker import DeadLinkChecker
+from Backend.fastapi.main import app
 
 loop = get_event_loop()
 
@@ -43,6 +45,10 @@ async def start_services():
         loop.create_task(server.serve())
         loop.create_task(ping())
         
+        # Start the background Dead Link Checker
+        link_checker_task = DeadLinkChecker(db, app, check_interval_hours=24)
+        loop.create_task(link_checker_task.start())
+        
         LOGGER.info("Telegram-Stremio Started Successfully!")
         await idle()
     except Exception:

Backend/fastapi/main.py

@@ -5,17 +5,21 @@ from fastapi.staticfiles import StaticFiles
 from starlette.middleware.sessions import SessionMiddleware
 from Backend import __version__
 from Backend.fastapi.security.credentials import require_auth
-from Backend.fastapi.routes.stream_routes import router as stream_router
+from Backend.fastapi.routes.stream_routes import router as stream_router, decay_client_failures
 from Backend.fastapi.routes.stremio_routes import router as stremio_router
 from Backend.fastapi.routes.template_routes import (
     login_page, login_post, logout, set_theme, dashboard_page,
-    media_management_page, edit_media_page, public_status_page, stremio_guide_page
+    media_management_page, edit_media_page, public_status_page, stremio_guide_page,
+    admin_dashboard_page
 )
 from Backend.fastapi.routes.api_routes import (
     list_media_api, delete_media_api, update_media_api,
     delete_movie_quality_api, delete_tv_quality_api,
     delete_tv_episode_api, delete_tv_season_api,
-    create_token_api, revoke_token_api, update_token_limits_api
+    create_token_api, revoke_token_api, update_token_limits_api,
+    speed_test_api, speed_test_stream_api,
+    get_admin_stats_api, clear_cache_api, get_dead_links_api,
+    get_stream_analytics_api
 )
 
 app = FastAPI(
@@ -39,6 +43,11 @@ try:
 except Exception:
     pass
 
+@app.on_event("startup")
+async def _startup():
+    import asyncio
+    asyncio.create_task(decay_client_failures())
+
 # --- Include existing API routers ---
 app.include_router(stream_router)
 app.include_router(stremio_router)
@@ -73,6 +82,10 @@ async def stremio_guide(request: Request):
 async def root(request: Request, _: bool = Depends(require_auth)):
     return await dashboard_page(request, _)
 
+@app.get("/admin/dashboard", response_class=HTMLResponse)
+async def admin_dashboard(request: Request, _: bool = Depends(require_auth)):
+    return await admin_dashboard_page(request, _)
+
 @app.get("/media/manage", response_class=HTMLResponse)
 async def media_management(request: Request, media_type: str = "movie", _: bool = Depends(require_auth)):
     return await media_management_page(request, media_type, _)
@@ -147,6 +160,42 @@ async def get_system_stats(_: bool = Depends(require_auth)):
     from Backend.fastapi.routes.api_routes import get_system_stats_api
     return await get_system_stats_api()
 
+@app.get("/api/admin/system-stats")
+async def admin_system_stats(_: bool = Depends(require_auth)):
+    return await get_admin_stats_api()
+
+@app.post("/api/admin/clear-cache")
+async def clear_cache(_: bool = Depends(require_auth)):
+    return await clear_cache_api()
+
+@app.get("/api/admin/dead-links")
+async def get_dead_links(_: bool = Depends(require_auth)):
+    return await get_dead_links_api()
+
+@app.get("/api/admin/stream-analytics")
+async def get_stream_analytics(_: bool = Depends(require_auth)):
+    return await get_stream_analytics_api()
+
+@app.get("/api/system/speedtest")
+async def speed_test(
+    quality_id: str = Query(...),
+    tmdb_id: int = Query(...),
+    db_index: int = Query(...),
+    media_type: str = Query(...),
+    _: bool = Depends(require_auth)
+):
+    return await speed_test_api(quality_id, tmdb_id, db_index, media_type)
+
+@app.get("/api/system/speedtest/stream")
+async def speed_test_stream(
+    quality_id: str = Query(...),
+    tmdb_id: int = Query(...),
+    db_index: int = Query(...),
+    media_type: str = Query(...),
+    _: bool = Depends(require_auth)
+):
+    return await speed_test_stream_api(quality_id, tmdb_id, db_index, media_type)
+
 @app.exception_handler(401)
 async def auth_exception_handler(request: Request, exc):
     return RedirectResponse(url="/login", status_code=302)

Backend/fastapi/routes/api_routes.py

@@ -1,7 +1,11 @@
+import asyncio
+import json
 from fastapi import Request, Query, HTTPException
+from fastapi.responses import StreamingResponse
 from Backend import db, StartTime, __version__
 from Backend.helper.pyro import get_readable_time
 from Backend.pyrofork.bot import multi_clients, StreamBot
+from Backend.helper.custom_dl import run_speed_test, _speed_test_single_client
 from time import time
 
 
@@ -257,4 +261,211 @@ async def revoke_token_api(token: str):
         else:
             raise HTTPException(status_code=404, detail="Token not found")
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# --- Speed Test API ---
+
+async def speed_test_api(
+    quality_id: str = Query(..., description="Encoded quality ID from DB"),
+    tmdb_id: int = Query(...),
+    db_index: int = Query(...),
+    media_type: str = Query(..., regex="^(movie|tv)$"),
+):
+    """
+    Decode quality_id using the same decode_string logic as the stream handler,
+    then run a parallel download speed test across all connected bot clients.
+    """
+    from Backend.helper.encrypt import decode_string
+
+    try:
+        decoded = await decode_string(quality_id)
+        msg_id  = decoded.get("msg_id")
+        raw_cid = decoded.get("chat_id")
+
+        if not msg_id or not raw_cid:
+            raise HTTPException(
+                status_code=422,
+                detail=f"Decoded quality data is missing msg_id or chat_id. Decoded: {decoded}"
+            )
+
+        # Stream handler adds -100 prefix for channel IDs
+        chat_id = int(f"-100{raw_cid}")
+
+        results = await run_speed_test(int(chat_id), int(msg_id))
+        return {"results": results, "total_clients_tested": len(results)}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# --- Speed Test SSE Streaming API ---
+
+async def speed_test_stream_api(
+    quality_id: str,
+    tmdb_id: int,
+    db_index: int,
+    media_type: str,
+):
+    """
+    SSE version of the speed test. Streams each per-client result as a
+    'data:' event the moment that client finishes, so the UI can update live.
+    """
+    from Backend.helper.encrypt import decode_string
+
+    async def event_generator():
+        # Decode quality_id → chat_id + message_id
+        try:
+            decoded = await decode_string(quality_id)
+            msg_id  = decoded.get("msg_id")
+            raw_cid = decoded.get("chat_id")
+            if not msg_id or not raw_cid:
+                payload = json.dumps({"type": "error", "message": f"Cannot decode quality_id. Got: {decoded}"})
+                yield f"data: {payload}\n\n"
+                return
+            chat_id = int(f"-100{raw_cid}")
+        except Exception as exc:
+            payload = json.dumps({"type": "error", "message": str(exc)})
+            yield f"data: {payload}\n\n"
+            return
+
+        total = len(multi_clients)
+        if total == 0:
+            payload = json.dumps({"type": "error", "message": "No bot clients connected"})
+            yield f"data: {payload}\n\n"
+            return
+            
+        # Try to resolve the FileId to get the target DC
+        target_dc = "?"
+        try:
+            from Backend.helper.custom_dl import ByteStreamer
+            primary_client = multi_clients.get(0) or next(iter(multi_clients.values()))
+            streamer = ByteStreamer(primary_client)
+            file_id = await streamer.get_file_properties(chat_id, int(msg_id))
+            target_dc = file_id.dc_id
+        except Exception:
+            pass
+
+        # Send initial "start" event so the frontend can set up the table
+        yield f"data: {json.dumps({'type': 'start', 'total': total, 'target_dc': target_dc})}\n\n"
+
+        # Run all clients in parallel; feed results into a queue as they finish
+        queue: asyncio.Queue = asyncio.Queue()
+
+        async def run_one(client, idx):
+            async def on_progress(prog_data):
+                await queue.put({"type": "progress", "data": prog_data})
+                
+            result = await _speed_test_single_client(
+                client, idx, chat_id, int(msg_id), progress_callback=on_progress
+            )
+            await queue.put({"type": "result", "data": result})
+
+        tasks = [
+            asyncio.create_task(run_one(client, idx))
+            for idx, client in multi_clients.items()
+        ]
+
+        completed = 0
+        while completed < total:
+            msg = await queue.get()
+            
+            if msg["type"] == "progress":
+                payload = json.dumps(msg)
+                yield f"data: {payload}\n\n"
+            
+            elif msg["type"] == "result":
+                completed += 1
+                payload = json.dumps({
+                    "type": "result",
+                    "data": msg["data"],
+                    "completed": completed,
+                    "total": total,
+                })
+                yield f"data: {payload}\n\n"
+
+        # Wait for any remaining tasks (should already be done)
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+        # Final done event
+        yield f"data: {json.dumps({'type': 'done', 'total': total})}\n\n"
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",   # prevent nginx from buffering SSE
+        },
+    )
+
+# ---------------------------------------------------------------------------
+# Admin API Routes
+# ---------------------------------------------------------------------------
+
+async def get_admin_stats_api() -> dict:
+    from Backend.pyrofork.bot import work_loads, multi_clients, client_failures, client_avg_mbps
+    from Backend.fastapi.routes.stream_routes import _streamer_by_client
+    
+    # Sum cache entries across all active ByteStreamer instances
+    cache_size = sum(len(s._file_id_cache) for s in _streamer_by_client.values())
+    
+    # Calculate bot workloads and health
+    bot_stats = []
+    for client_index in multi_clients:
+        load = work_loads.get(client_index, 0)
+        failures = client_failures.get(client_index, 0)
+        mbps = client_avg_mbps.get(client_index, 0.0)
+        
+        status = "healthy"
+        if failures > 5:
+            status = "degraded"
+        if failures > 15:
+            status = "failing"
+            
+        bot_stats.append({
+            "client_index": client_index,
+            "display_name": f"Bot {client_index + 1}",
+            "current_load": load,
+            "failures": failures,
+            "avg_mbps": round(mbps, 2),
+            "status": status
+        })
+        
+    return {
+        "cache_size": cache_size,
+        "total_bots": len(multi_clients),
+        "bot_workloads": bot_stats
+    }
+
+async def clear_cache_api() -> dict:
+    from Backend.fastapi.routes.stream_routes import _streamer_by_client
+    from Backend.logger import LOGGER
+    
+    # Clear cache across all active ByteStreamer instances
+    total_cleared = sum(len(s._file_id_cache) for s in _streamer_by_client.values())
+    for streamer in _streamer_by_client.values():
+        streamer._file_id_cache.clear()
+    LOGGER.info(f"Admin cleared the FileId cache ({total_cleared} items purged across {len(_streamer_by_client)} clients).")
+    
+    return {"status": "success", "message": f"{total_cleared} cached items cleared."}
+
+async def get_dead_links_api() -> dict:
+    from Backend import db
+    try:
+        dead_links = await db.get_all_dead_links()
+        return {"status": "success", "data": dead_links}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+async def get_stream_analytics_api() -> dict:
+    from Backend import db
+    try:
+        data = await db.get_stream_analytics(limit=200)
+        return {"status": "success", "data": data}
+    except Exception as e:
+        from Backend.logger import LOGGER
+        LOGGER.error(f"Stream analytics API error: {e}")
+        return {"status": "error", "message": str(e)}

Backend/fastapi/routes/stream_routes.py

@@ -12,8 +12,8 @@ from collections import deque
 from Backend import db
 from Backend.helper.encrypt import decode_string
 from Backend.helper.exceptions import InvalidHash
-from Backend.helper.custom_dl import ByteStreamer, ACTIVE_STREAMS, RECENT_STREAMS
-from Backend.pyrofork.bot import StreamBot, work_loads, multi_clients, client_dc_map
+from Backend.helper.custom_dl import ByteStreamer, ACTIVE_STREAMS, RECENT_STREAMS, get_adaptive_chunk_size
+from Backend.pyrofork.bot import StreamBot, work_loads, multi_clients, client_dc_map, client_failures, client_avg_mbps
 from Backend.config import Telegram
 from Backend.logger import LOGGER
 from Backend.fastapi.security.tokens import verify_token
@@ -65,33 +65,55 @@ def parse_range_header(range_header: str, file_size: int):
 
 
 def select_best_client(target_dc: int) -> int:
-    matching_dc_clients = []
-    for client_idx, client_dc in client_dc_map.items():
-        if client_dc == target_dc and client_idx in multi_clients:
-            matching_dc_clients.append((client_idx, work_loads.get(client_idx, 0)))
-
-
-    # # -------------Don't use part of code at now ----------------------------
-    # if matching_dc_clients:
-    #     selected = min(matching_dc_clients, key=lambda x: x[1])[0]
-    #     LOGGER.info(
-    #         f"Selected client {selected} (DC {target_dc} match) with workload {work_loads[selected]}"
-    #     )
+    """Pick the best available client.
+
+    Score = work_loads + 3 × client_failures
+    Failures are weighted 3× so a bot that has been timing out / erroring
+    is deprioritised even if its current workload is low.
+    DC-aware selection is kept but currently commented out (uncomment to
+    prefer same-DC bots).
+    """
+    def _score(idx: int) -> int:
+        return work_loads.get(idx, 0) + 3 * client_failures.get(idx, 0)
+
+    # --- DC-aware selection (uncomment to enable) ---------------------------
+    # matching = [
+    #     idx for idx, dc in client_dc_map.items()
+    #     if dc == target_dc and idx in multi_clients
+    # ]
+    # if matching:
+    #     selected = min(matching, key=_score)
+    #     LOGGER.debug("DC-match client %s (DC %s) score=%s", selected, target_dc, _score(selected))
     #     return selected
-    # # -------------------------------------------------------------------------
+    # ------------------------------------------------------------------------
 
     if multi_clients:
-        selected = min(work_loads, key=work_loads.get)
-        selected_dc = client_dc_map.get(selected, "unknown")
+        selected = min(multi_clients.keys(), key=_score)
         LOGGER.debug(
-            f"No DC {target_dc} client available. "
-            f"Using client {selected} (DC {selected_dc}) with workload {work_loads[selected]}"
+            "Selected client %s (DC %s) score=%s",
+            selected, client_dc_map.get(selected, "?"), _score(selected),
         )
         return selected
 
     return 0
 
 
+async def decay_client_failures() -> None:
+    """Every 5 minutes reduce each client's failure count by 1 (floor 0).
+
+    This lets bots self-recover after a temporary DC issue without manual
+    intervention.  The coroutine is started once as a background task on
+    first import.
+    """
+    while True:
+        await asyncio.sleep(300)  # 5 minutes
+        for k in list(client_failures):
+            if client_failures.get(k, 0) > 0:
+                client_failures[k] = max(0, client_failures[k] - 1)
+                LOGGER.debug("Failure decay: client %s failures → %s", k, client_failures[k])
+
+
+
 async def track_usage_from_stats(stream_id: str, token: str, token_data: dict):
     await asyncio.sleep(2)
     
@@ -186,6 +208,7 @@ async def stream_handler(
         secure_hash=secure_hash,
         token=token,
         token_data=token_data,
+        stream_id_hash=id,
     )
 
 async def media_streamer(
@@ -195,10 +218,12 @@ async def media_streamer(
     secure_hash: str,
     token: str,
     token_data: dict = None,
+    stream_id_hash: str = None,
 ):
-    temp_client = multi_clients[min(work_loads, key=work_loads.get)]
+    temp_client = multi_clients[min(multi_clients.keys(), key=lambda i: work_loads.get(i, 0) + 3 * client_failures.get(i, 0))]
     if temp_client not in _streamer_by_client:
-        _streamer_by_client[temp_client] = ByteStreamer(temp_client)
+        idx = next((i for i, c in multi_clients.items() if c is temp_client), -1)
+        _streamer_by_client[temp_client] = ByteStreamer(temp_client, idx)
     temp_streamer = _streamer_by_client[temp_client]
 
     file_id = await temp_streamer.get_file_properties(chat_id=chat_id, message_id=msg_id)
@@ -214,7 +239,7 @@ async def media_streamer(
     tg_client = multi_clients[index]
 
     if tg_client not in _streamer_by_client:
-        _streamer_by_client[tg_client] = ByteStreamer(tg_client)
+        _streamer_by_client[tg_client] = ByteStreamer(tg_client, index)
     streamer: ByteStreamer = _streamer_by_client[tg_client]
 
     file_size = file_id.file_size
@@ -222,16 +247,33 @@ async def media_streamer(
     start, end = parse_range_header(range_header, file_size)
     req_length = end - start + 1
 
-    chunk_size = streamer.CHUNK_SIZE
+    # Adaptive chunk size based on this client's recent measured throughput
+    chunk_size = get_adaptive_chunk_size(index)
     offset = start - (start % chunk_size)
     first_part_cut = start - offset
     last_part_cut = (end % chunk_size) + 1
     part_count = math.ceil(end / chunk_size) - math.floor(offset / chunk_size)
 
+    from urllib.parse import unquote
+    
     stream_id = secrets.token_hex(8)
+    
+    # Extract original title from the URL path name, fallback to raw name
+    decoded_name = unquote(request.path_params.get("name", ""))
+    
+    # Look up the real title from the database using the Stremio stream_id_hash
+    db_title = None
+    if stream_id_hash:
+        db_title = await db.get_title_by_stream_id(stream_id_hash)
+        LOGGER.info(f"Stream lookup for hash '{stream_id_hash}' returned title: {db_title}")
+        
+    final_title = db_title if db_title else decoded_name
+    
     meta = {
         "request_path": str(request.url.path),
         "client_host": request.client.host if request.client else None,
+        "title": final_title,
+        "user_name": token_data.get("name", "Unknown") if token_data else "Unknown"
     }
 
     prefetch_count = Telegram.PARALLEL
@@ -260,9 +302,33 @@ async def media_streamer(
     if "." not in file_name and "/" in mime_type:
         file_name = f"{file_name}.{mime_type.split('/')[1]}"
 
+    # HEAD: return headers only (no body), include Content-Length so the
+    # client knows the file size without opening a stream.
+    from fastapi.responses import Response as PlainResponse
+    if request.method == "HEAD":
+        head_headers = {
+            "Content-Type": mime_type,
+            "Content-Length": str(req_length),
+            "Content-Disposition": f'inline; filename="{file_name}"',
+            "Accept-Ranges": "bytes",
+            "Cache-Control": "public, max-age=3600, immutable",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Expose-Headers": "Content-Length, Content-Range, Accept-Ranges",
+            "X-Stream-Id": stream_id,
+        }
+        if range_header:
+            head_headers["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+        return PlainResponse(status_code=206 if range_header else 200, headers=head_headers)
+
+    # GET: do NOT set Content-Length on the StreamingResponse.
+    # If a Telegram chunk fetch times out mid-stream the generator exits early,
+    # delivering fewer bytes than the declared length.  h11 enforces
+    # Content-Length strictly and raises LocalProtocolError in that case.
+    # Without Content-Length, uvicorn uses chunked transfer encoding which
+    # handles early termination gracefully.  Stremio / media players
+    # are fine with chunked 206 responses.
     headers = {
         "Content-Type": mime_type,
-        "Content-Length": str(req_length),
         "Content-Disposition": f'inline; filename="{file_name}"',
         "Accept-Ranges": "bytes",
         "Cache-Control": "public, max-age=3600, immutable",
@@ -290,7 +356,8 @@ async def get_stream_stats():
 
     for sid, info in list(ACTIVE_STREAMS.items()):
         status = info.get("status")
-        last_ts = info.get("last_ts", info.get("start_ts", now))
+        # Check end_ts first, which is set when a stream organically finishes
+        last_ts = info.get("end_ts") or info.get("last_ts") or info.get("start_ts", now)
         if status in ("cancelled", "error", "finished"):
             if now - last_ts > PRUNE_SECONDS:
                 try:
@@ -305,6 +372,7 @@ async def get_stream_stats():
                 "stream_id": sid,
                 "msg_id": info.get("msg_id"),
                 "chat_id": info.get("chat_id"),
+                "title": info.get("meta", {}).get("title"),
                 "client_index": info.get("client_index"),
                 "dc_id": info.get("dc_id"),
                 "status": info.get("status"),
@@ -323,6 +391,7 @@ async def get_stream_stats():
                 "stream_id": info.get("stream_id"),
                 "msg_id": info.get("msg_id"),
                 "chat_id": info.get("chat_id"),
+                "title": info.get("meta", {}).get("title"),
                 "client_index": info.get("client_index"),
                 "dc_id": info.get("dc_id"),
                 "status": info.get("status"),

Backend/fastapi/routes/stremio_routes.py

@@ -361,4 +361,17 @@ async def get_streams(
         key=lambda s: get_resolution_priority(s.get("name", "")),
         reverse=True
     )
+
+    # Deduplicate stream names — Stremio collapses streams with identical names,
+    # so when two files share the same caption we append (1), (2) ... to each duplicate.
+    name_count: dict = {}
+    for s in streams:
+        name_count[s["name"]] = name_count.get(s["name"], 0) + 1
+
+    seen: dict = {}
+    for s in streams:
+        if name_count[s["name"]] > 1:
+            seen[s["name"]] = seen.get(s["name"], 0) + 1
+            s["name"] = f"{s['name']} ({seen[s['name']]})"
+
     return {"streams": streams}

Backend/fastapi/routes/template_routes.py

@@ -12,6 +12,19 @@ from Backend.helper.custom_dl import ACTIVE_STREAMS, RECENT_STREAMS
 
 templates = Jinja2Templates(directory="Backend/fastapi/templates")
 
+async def admin_dashboard_page(request: Request, _: bool = Depends(require_auth)):
+    theme_name = request.session.get("theme", "purple_gradient")
+    theme = get_theme(theme_name)
+    current_user = get_current_user(request)
+    
+    return templates.TemplateResponse("admin_dashboard.html", {
+        "request": request,
+        "theme": theme,
+        "themes": get_all_themes(),
+        "current_theme": theme_name,
+        "current_user": current_user
+    })
+
 async def login_page(request: Request):
     if is_authenticated(request):
         return RedirectResponse(url="/", status_code=302)
@@ -65,7 +78,8 @@ async def dashboard_page(request: Request, _: bool = Depends(require_auth)):
         PRUNE_SECONDS = 3
         for sid, info in list(ACTIVE_STREAMS.items()):
             status = info.get("status")
-            last_ts = info.get("last_ts", info.get("start_ts", now))
+            # Check end_ts first to see when it organically finished
+            last_ts = info.get("end_ts") or info.get("last_ts") or info.get("start_ts", now)
 
             if status in ("cancelled", "error", "finished") and (now - last_ts > PRUNE_SECONDS):
 

Backend/fastapi/templates/admin_dashboard.html

@@ -0,0 +1,342 @@
+{% extends "base.html" %}
+
+{% block title %}Admin Dashboard - Telegram Stremio{% endblock %}
+
+{% block content %}
+<div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+    <div class="mb-8 flex justify-between items-center">
+        <div>
+            <h1 class="text-3xl font-bold text-gray-900 dark:text-white">Admin Dashboard</h1>
+            <p class="mt-2 text-sm text-gray-600 dark:text-gray-400">Monitor system health and manage flagged dead
+                links.</p>
+        </div>
+    </div>
+
+    <!-- System Health Section -->
+    <div class="mb-10">
+        <div class="flex items-center justify-between mb-4">
+            <h2 class="text-xl font-semibold text-gray-800 dark:text-gray-200">System Health</h2>
+            <button onclick="clearCache()"
+                class="bg-red-600 hover:bg-red-700 text-white px-4 py-2 rounded-md text-sm font-medium transition-colors shadow-sm flex items-center justify-center">
+                <i class="fas fa-trash-alt mr-2"></i> Clear File Cache
+            </button>
+        </div>
+
+        <div class="grid grid-cols-1 md:grid-cols-3 gap-6" id="stats-container">
+            <!-- Cache Card -->
+            <div class="theme-card rounded-xl border p-6 shadow-sm">
+                <div class="flex items-center">
+                    <div class="flex-shrink-0 bg-blue-100 dark:bg-blue-900/30 p-3 rounded-lg">
+                        <i class="fas fa-memory text-xl text-blue-600 dark:text-blue-400"></i>
+                    </div>
+                    <div class="ml-4">
+                        <h3 class="text-sm font-medium text-gray-500 dark:text-gray-400">Cached File IDs</h3>
+                        <p class="text-2xl font-bold text-gray-900 dark:text-white" id="stat-cache-size">-</p>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Active Bots Card -->
+            <div class="theme-card rounded-xl border p-6 shadow-sm">
+                <div class="flex items-center">
+                    <div class="flex-shrink-0 bg-green-100 dark:bg-green-900/30 p-3 rounded-lg">
+                        <i class="fas fa-robot text-xl text-green-600 dark:text-green-400"></i>
+                    </div>
+                    <div class="ml-4">
+                        <h3 class="text-sm font-medium text-gray-500 dark:text-gray-400">Connected Bots</h3>
+                        <p class="text-2xl font-bold text-gray-900 dark:text-white" id="stat-bot-count">-</p>
+                    </div>
+                </div>
+            </div>
+
+        </div>
+
+        <!-- Bot Health & Load - Full Width -->
+        <div class="theme-card rounded-xl border shadow-sm mt-6">
+            <div class="flex items-center justify-between px-6 py-4 border-b">
+                <div class="flex items-center gap-3">
+                    <div class="bg-purple-100 dark:bg-purple-900/30 p-2 rounded-lg">
+                        <i class="fas fa-heartbeat text-purple-600 dark:text-purple-400"></i>
+                    </div>
+                    <h3 class="text-base font-semibold text-gray-800 dark:text-gray-200">Bot Health & Load</h3>
+                </div>
+            </div>
+            <div id="stat-workloads" class="divide-y divide-gray-100 dark:divide-gray-800">
+                <div class="px-6 py-4 text-sm text-gray-500">Loading...</div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Stream Analytics Section -->
+    <div class="mb-10">
+        <div class="flex items-center justify-between mb-4">
+            <h2 class="text-xl font-semibold text-gray-800 dark:text-gray-200">Recent Stream Analytics</h2>
+            <button onclick="clearAnalytics()"
+                class="bg-red-600 hover:bg-red-700 text-white px-4 py-2 rounded-md text-sm font-medium transition-colors shadow-sm flex items-center">
+                <i class="fas fa-trash-alt mr-2"></i> Clear Analytics
+            </button>
+        </div>
+        <div class="theme-card border rounded-xl overflow-hidden shadow-sm">
+            <div class="overflow-x-auto">
+                <table class="w-full text-sm text-left">
+                    <thead class="text-xs uppercase bg-gray-50 dark:bg-gray-800 dark:text-gray-300 border-b">
+                        <tr>
+                            <th class="px-6 py-4 font-semibold">Stream ID</th>
+                            <th class="px-6 py-4 font-semibold">Title</th>
+                            <th class="px-6 py-4 font-semibold text-center">Bot (DC)</th>
+                            <th class="px-6 py-4 font-semibold text-right">Data Transferred</th>
+                            <th class="px-6 py-4 font-semibold text-right">Avg / Peak Speed</th>
+                            <th class="px-6 py-4 font-semibold text-center">Duration</th>
+                            <th class="px-6 py-4 font-semibold text-center">Status</th>
+                            <th class="px-6 py-4 font-semibold text-right">Time</th>
+                        </tr>
+                    </thead>
+                    <tbody id="analytics-tbody" class="divide-y divide-gray-100 dark:divide-gray-800">
+                        <tr>
+                            <td colspan="8" class="px-6 py-8 text-center text-gray-500">
+                                <i class="fas fa-spinner fa-spin mr-2"></i> Loading analytics...
+                            </td>
+                        </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+
+    <!-- Dead Links Section -->
+    <div>
+        <h2 class="text-xl font-semibold text-gray-800 dark:text-gray-200 mb-4">Flagged Dead Links</h2>
+        <div class="theme-card border rounded-xl overflow-hidden shadow-sm">
+            <div class="overflow-x-auto">
+                <table class="w-full text-sm text-left">
+                    <thead class="text-xs uppercase bg-gray-50 dark:bg-gray-800 dark:text-gray-300 border-b">
+                        <tr>
+                            <th class="px-6 py-4 font-semibold">Title</th>
+                            <th class="px-6 py-4 font-semibold w-24">Type</th>
+                            <th class="px-6 py-4 font-semibold">Quality Details</th>
+                            <th class="px-6 py-4 font-semibold w-32 text-center">Date Added</th>
+                            <th class="px-6 py-4 font-semibold w-24 text-center">Action</th>
+                        </tr>
+                    </thead>
+                    <tbody id="dead-links-tbody" class="divide-y divide-gray-100 dark:divide-gray-800">
+                        <tr>
+                            <td colspan="5" class="px-6 py-8 text-center text-gray-500">
+                                <i class="fas fa-spinner fa-spin mr-2"></i> Loading dead links...
+                            </td>
+                        </tr>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+    async function fetchStats() {
+        try {
+            const res = await fetch('/api/admin/system-stats');
+            if (res.ok) {
+                const data = await res.json();
+                document.getElementById('stat-cache-size').textContent = data.cache_size;
+                document.getElementById('stat-bot-count').textContent = data.total_bots;
+
+                let wlHtml = '';
+                if (data.bot_workloads && data.bot_workloads.length > 0) {
+                    data.bot_workloads.forEach(b => {
+                        let statusColor = 'bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-400';
+                        if (b.status === 'degraded') statusColor = 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900/30 dark:text-yellow-400';
+                        if (b.status === 'failing') statusColor = 'bg-red-100 text-red-800 dark:bg-red-900/30 dark:text-red-400';
+
+                        wlHtml += `
+                            <div class="flex items-center justify-between px-6 py-4 hover:bg-gray-50 dark:hover:bg-gray-800/50 transition-colors">
+                                <div class="flex items-center gap-3">
+                                    <span class="font-semibold text-gray-900 dark:text-white">${b.display_name}</span>
+                                    <span class="text-[10px] px-2 py-0.5 rounded-full uppercase font-bold tracking-wider ${statusColor}">${b.status}</span>
+                                </div>
+                                <div class="flex items-center gap-6 text-sm">
+                                    <div class="text-center">
+                                        <div class="text-xs text-gray-500 mb-0.5">Active Streams</div>
+                                        <div class="font-bold text-gray-900 dark:text-white">${b.current_load}</div>
+                                    </div>
+                                    <div class="text-center">
+                                        <div class="text-xs text-gray-500 mb-0.5">Avg Speed</div>
+                                        <div class="font-bold text-gray-900 dark:text-white">${b.avg_mbps} <span class="font-normal text-xs text-gray-400">MB/s</span></div>
+                                    </div>
+                                    <div class="text-center">
+                                        <div class="text-xs text-gray-500 mb-0.5">Recent Failures</div>
+                                        <div class="font-bold ${b.failures > 0 ? 'text-red-500' : 'text-gray-400'}">${b.failures}</div>
+                                    </div>
+                                </div>
+                            </div>
+                        `;
+                    });
+                } else {
+                    wlHtml = '<div class="px-6 py-8 text-center text-gray-500">No bot data available</div>';
+                }
+                document.getElementById('stat-workloads').innerHTML = wlHtml;
+            }
+        } catch (err) {
+            console.error(err);
+        }
+    }
+
+    async function fetchAnalytics() {
+        try {
+            const res = await fetch('/api/admin/stream-analytics');
+            const tbody = document.getElementById('analytics-tbody');
+            if (res.ok) {
+                const data = await res.json();
+                const streams = data.data.recent;
+
+                if (!streams || streams.length === 0) {
+                    tbody.innerHTML = '<tr><td colspan="8" class="px-6 py-8 text-center text-gray-500">No recent streams recorded.</td></tr>';
+                    return;
+                }
+
+                let html = '';
+                streams.forEach(s => {
+                    const mbpsStr = `${s.avg_mbps.toFixed(1)} / <span class="text-gray-400">${s.peak_mbps.toFixed(1)}</span>`;
+                    const bytesStr = (s.total_bytes / (1024 * 1024)).toFixed(1) + ' MB';
+                    const timeStr = new Date(s.logged_at).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                    const durationStr = s.duration_sec ? `${s.duration_sec.toFixed(1)}s` : '—';
+                    const titleStr = s.title || s.meta?.title || '—';
+
+                    let statusColor = 'text-green-500';
+                    if (s.status === 'error') statusColor = 'text-red-500';
+                    if (s.status === 'cancelled') statusColor = 'text-yellow-500';
+
+                    html += `
+                        <tr class="hover:bg-gray-50 dark:hover:bg-gray-800/50 transition-colors">
+                            <td class="px-6 py-3 font-mono text-xs text-gray-500 truncate max-w-[120px]" title="${s.stream_id}">${s.stream_id}</td>
+                            <td class="px-6 py-3 text-sm font-medium text-gray-800 dark:text-gray-200 max-w-[160px] truncate" title="${titleStr}">${titleStr}</td>
+                            <td class="px-6 py-3 text-center">Bot ${s.client_index + 1} <span class="text-xs text-gray-400 ml-1">(DC${s.dc_id})</span></td>
+                            <td class="px-6 py-3 text-right font-medium">${bytesStr}</td>
+                            <td class="px-6 py-3 text-right font-medium text-gray-700 dark:text-gray-300">${mbpsStr} <span class="text-xs text-gray-500">MB/s</span></td>
+                            <td class="px-6 py-3 text-center text-gray-500">${durationStr}</td>
+                            <td class="px-6 py-3 text-center capitalize text-xs font-bold ${statusColor}">${s.status}</td>
+                            <td class="px-6 py-3 text-right text-gray-500 text-xs">${timeStr}</td>
+                        </tr>
+                    `;
+                });
+                tbody.innerHTML = html;
+            }
+        } catch (err) {
+            console.error(err);
+        }
+    }
+
+    async function fetchDeadLinks() {
+        try {
+            const res = await fetch('/api/admin/dead-links');
+            const tbody = document.getElementById('dead-links-tbody');
+            if (res.ok) {
+                const data = await res.json();
+                const links = data.data;
+
+                if (links.length === 0) {
+                    tbody.innerHTML = '<tr><td colspan="5" class="px-6 py-8 text-center text-gray-500">No dead links found. All files are healthy!</td></tr>';
+                    return;
+                }
+
+                let html = '';
+                links.forEach(l => {
+                    const typeBadge = l.type === 'movie'
+                        ? '<span class="px-2 py-1 rounded bg-blue-100 text-blue-800 text-xs font-medium">Movie</span>'
+                        : '<span class="px-2 py-1 rounded bg-purple-100 text-purple-800 text-xs font-medium">TV Series</span>';
+
+                    html += `
+                        <tr class="hover:bg-gray-50 dark:hover:bg-gray-800/50 transition-colors">
+                            <td class="px-6 py-4">
+                                <div class="font-medium text-gray-900 dark:text-gray-100">${l.title}</div>
+                                <div class="text-xs text-gray-500">${l.year || ''}</div>
+                            </td>
+                            <td class="px-6 py-4">${typeBadge}</td>
+                            <td class="px-6 py-4">
+                                <div class="text-sm font-medium text-red-600 dark:text-red-400">${l.quality}</div>
+                                <div class="text-xs text-gray-500">${l.size || 'Unknown size'}</div>
+                            </td>
+                            <td class="px-6 py-4 text-center text-gray-500 text-xs">${l.date_added ? new Date(l.date_added).toLocaleDateString() : '—'}</td>
+                            <td class="px-6 py-4 text-center">
+                                <button onclick="deleteDeadLink(${l.tmdb_id}, ${l.db_index}, '${l.type}', '${l.quality_id}', ${l.season || -1}, ${l.episode || -1})" 
+                                        class="text-red-600 hover:text-red-800 bg-red-50 hover:bg-red-100 rounded p-2 transition-colors" title="Delete from Database">
+                                    <i class="fas fa-trash"></i>
+                                </button>
+                            </td>
+                        </tr>
+                    `;
+                });
+                tbody.innerHTML = html;
+            }
+        } catch (err) {
+            console.error(err);
+        }
+    }
+
+    async function clearCache() {
+        if (!confirm("Are you sure you want to clear the Telegram FileId cache? This will force bots to re-fetch metadata on the next stream.")) return;
+
+        try {
+            const res = await fetch('/api/admin/clear-cache', { method: 'POST' });
+            if (res.ok) {
+                const data = await res.json();
+                alert(data.message);
+                fetchStats();
+            } else {
+                alert("Failed to clear cache.");
+            }
+        } catch (err) {
+            alert("Error clearing cache.");
+        }
+    }
+
+    async function clearAnalytics() {
+        if (!confirm("Are you sure you want to clear all stream analytics history? This cannot be undone.")) return;
+
+        try {
+            const res = await fetch('/api/admin/clear-analytics', { method: 'POST' });
+            if (res.ok) {
+                const data = await res.json();
+                alert(data.message || 'Analytics cleared successfully.');
+                fetchAnalytics();
+            } else {
+                const err = await res.json().catch(() => ({}));
+                alert(err.detail || 'Failed to clear analytics.');
+            }
+        } catch (err) {
+            alert('Error clearing analytics.');
+        }
+    }
+
+    async function deleteDeadLink(tmdb_id, db_index, type, quality_id, season, episode) {
+        if (!confirm("Are you sure you want to purge this dead link from the database? Users will no longer see this quality in Stremio.")) return;
+
+        try {
+            let endpoint = '';
+            if (type === 'movie') {
+                endpoint = `/api/media/delete-quality?tmdb_id=${tmdb_id}&db_index=${db_index}&id=${quality_id}`;
+            } else {
+                endpoint = `/api/media/delete-tv-quality?tmdb_id=${tmdb_id}&db_index=${db_index}&season=${season}&episode=${episode}&id=${quality_id}`;
+            }
+
+            const res = await fetch(endpoint, { method: 'DELETE' });
+            if (res.ok) {
+                fetchDeadLinks(); // Refresh table
+            } else {
+                alert("Failed to delete the dead link.");
+            }
+        } catch (err) {
+            alert("Error communicating with server.");
+        }
+    }
+
+    // Initial fetch on load
+    document.addEventListener('DOMContentLoaded', () => {
+        fetchStats();
+        fetchAnalytics();
+        fetchDeadLinks();
+        // Refresh dynamic stats
+        setInterval(fetchStats, 10000);
+        setInterval(fetchAnalytics, 15000);
+    });
+</script>
+{% endblock %}

Backend/fastapi/templates/base.html

@@ -1,12 +1,13 @@
 <!DOCTYPE html>
 <html lang="en">
+
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>{% block title %}Telegram Stremio{% endblock %}</title>
     <script src="https://cdn.tailwindcss.com"></script>
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" />
-    
+
     <script>
         tailwind.config = {
             theme: {
@@ -25,14 +26,76 @@
         }
     </script>
     <style>
-        body { background-color: {{ theme.colors.background }}; color: {{ theme.colors.text }}; }
-        .theme-card { background-color: {{ theme.colors.card }}; }
-        .theme-primary { background-color: {{ theme.colors.primary }}; }
-        .theme-secondary { background-color: {{ theme.colors.secondary }}; }
-        .theme-accent { background-color: {{ theme.colors.accent }}; }
-        .theme-text-secondary { color: {{ theme.colors.text_secondary }}; }
+        body {
+            background-color: {
+                    {
+                    theme.colors.background
+                }
+            }
+
+            ;
+
+            color: {
+                    {
+                    theme.colors.text
+                }
+            }
+
+            ;
+        }
+
+        .theme-card {
+            background-color: {
+                    {
+                    theme.colors.card
+                }
+            }
+
+            ;
+        }
+
+        .theme-primary {
+            background-color: {
+                    {
+                    theme.colors.primary
+                }
+            }
+
+            ;
+        }
+
+        .theme-secondary {
+            background-color: {
+                    {
+                    theme.colors.secondary
+                }
+            }
+
+            ;
+        }
+
+        .theme-accent {
+            background-color: {
+                    {
+                    theme.colors.accent
+                }
+            }
+
+            ;
+        }
+
+        .theme-text-secondary {
+            color: {
+                    {
+                    theme.colors.text_secondary
+                }
+            }
+
+            ;
+        }
     </style>
 </head>
+
 <body class="min-h-screen">
     <!-- Navigation -->
     <nav class="theme-card shadow-lg border-b">
@@ -42,33 +105,40 @@
                     <h1 class="text-2xl font-bold text-primary">Telegram Stremio</h1>
                     {% if current_user %}
                     <div class="hidden md:flex space-x-4">
-                        <a href="/" class="text-text hover:text-primary px-3 py-2 rounded-md transition-colors">Dashboard</a>
-                        <a href="/media/manage" class="text-text hover:text-primary px-3 py-2 rounded-md transition-colors">Media</a>
+                        <a href="/"
+                            class="text-text hover:text-primary px-3 py-2 rounded-md transition-colors">Dashboard</a>
+                        <a href="/media/manage"
+                            class="text-text hover:text-primary px-3 py-2 rounded-md transition-colors">Media</a>
+                        <a href="/admin/dashboard"
+                            class="text-text hover:text-primary px-3 py-2 rounded-md transition-colors">Admin</a>
                     </div>
                     {% endif %}
                 </div>
-                
+
                 <div class="flex items-center space-x-4">
                     <!-- Theme Selector -->
                     <div class="relative">
                         <form method="post" action="/set-theme" id="theme-form">
-                            <select name="theme" onchange="document.getElementById('theme-form').submit()" class="theme-card border border-gray-300 rounded-md px-3 py-2 text-sm">
+                            <select name="theme" onchange="document.getElementById('theme-form').submit()"
+                                class="theme-card border border-gray-300 rounded-md px-3 py-2 text-sm">
                                 {% for theme_key, theme_data in themes.items() %}
-                                <option value="{{ theme_key }}" {% if current_theme == theme_key %}selected{% endif %}>
+                                <option value="{{ theme_key }}" {% if current_theme==theme_key %}selected{% endif %}>
                                     {{ theme_data.name }}
                                 </option>
                                 {% endfor %}
                             </select>
                         </form>
                     </div>
-                    
+
                     {% if current_user %}
                     <div class="flex items-center space-x-4">
                         <span class="text-sm theme-text-secondary">{{ current_user }}</span>
-                        <a href="/logout" class="bg-red-600 text-white px-4 py-2 rounded-md hover:bg-red-700 transition-colors">Logout</a>
+                        <a href="/logout"
+                            class="bg-red-600 text-white px-4 py-2 rounded-md hover:bg-red-700 transition-colors">Logout</a>
                     </div>
                     {% else %}
-                    <a href="/login" class="theme-primary text-white px-4 py-2 rounded-md hover:opacity-90 transition-opacity">Login</a>
+                    <a href="/login"
+                        class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-md transition-colors">Login</a>
                     {% endif %}
                 </div>
             </div>
@@ -86,11 +156,14 @@
             <div class="flex justify-between items-center">
                 <p class="theme-text-secondary text-sm">© 2025 Telegram Stremio. All rights reserved.</p>
                 <div class="flex space-x-4">
-                    <a href="/status" class="theme-text-secondary hover:text-primary text-sm transition-colors">Status</a>
-                    <a href="/stremio" class="theme-text-secondary hover:text-primary text-sm transition-colors">Stremio Guide</a>
+                    <a href="/status"
+                        class="theme-text-secondary hover:text-primary text-sm transition-colors">Status</a>
+                    <a href="/stremio" class="theme-text-secondary hover:text-primary text-sm transition-colors">Stremio
+                        Guide</a>
                 </div>
             </div>
         </div>
     </footer>
 </body>
-</html>
+
+</html>

Backend/fastapi/templates/dashboard.html

@@ -12,7 +12,7 @@
                     <h1 class="text-3xl font-bold text-primary">Dashboard</h1>
                 </div>
                 <button onclick="refreshSystemStats()"
-                    class="flex items-center space-x-2 px-4 py-2 rounded-lg theme-primary text-white hover:opacity-90 transition-all shadow-md active:scale-95 group focus:outline-none"
+                    class="flex items-center space-x-2 px-4 py-2 rounded-lg bg-blue-600 hover:bg-blue-700 text-white transition-all shadow-md active:scale-95 group focus:outline-none"
                     title="Refresh System Stats">
                     <svg id="refresh-icon" xmlns="http://www.w3.org/2000/svg"
                         class="w-5 h-5 group-hover:rotate-180 transition-transform duration-500" fill="none"
@@ -71,14 +71,19 @@
                 </div>
 
                 <!-- Bot Workload Section -->
-                                <!-- Live Streaming Status Card -->
+                <!-- Live Streaming Status Card -->
                 <div class="streams-container">
                     <div class="theme-card rounded-xl p-8 shadow-xl">
                         <div class="flex items-center mb-6">
-                            <div class="w-12 h-12 theme-primary rounded-lg flex items-center justify-center mr-4 bg-opacity-20 text-primary">
-                                <svg xmlns="http://www.w3.org/2000/svg" class="w-6 h-6" fill="none" viewBox="0 0 24 24" stroke="white">
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z"></path>
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+                            <div
+                                class="w-12 h-12 theme-primary rounded-lg flex items-center justify-center mr-4 bg-opacity-20 text-primary">
+                                <svg xmlns="http://www.w3.org/2000/svg" class="w-6 h-6" fill="none" viewBox="0 0 24 24"
+                                    stroke="white">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                        d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z">
+                                    </path>
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                        d="M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
                                 </svg>
                             </div>
                             <div class="flex-1">
@@ -91,82 +96,127 @@
 
                         <div class="space-y-4">
                             {% if system_stats.active_streams and system_stats.active_streams|length > 0 %}
-                                {% for stream in system_stats.active_streams %}
-                                <div class="p-4 bg-gray-50 rounded-lg border-l-4 {% if stream.status == 'active' %}border-green-500{% elif stream.status == 'cancelled' %}border-yellow-500{% else %}border-red-500{% endif %}">
-                                    <div class="flex justify-between items-start mb-3">
-                                        <div class="flex items-center gap-2">
-                                            <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 text-primary" fill="currentColor" viewBox="0 0 24 24">
-                                                <path d="M8 5v14l11-7z"/>
-                                            </svg>
-                                            <span class="font-medium theme-text-secondary">Stream:</span>
-                                            <span class="font-semibold">{{ stream.stream_id[:8] }}...</span>
+                            {% for stream in system_stats.active_streams %}
+                            <div
+                                class="p-4 bg-gray-50 rounded-lg border-l-4 {% if stream.status == 'active' %}border-green-500{% elif stream.status == 'cancelled' %}border-yellow-500{% else %}border-red-500{% endif %}">
+                                <div class="flex justify-between items-start mb-3">
+                                    <div class="flex items-center gap-2 max-w-[70%]">
+                                        <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 text-primary shrink-0"
+                                            fill="currentColor" viewBox="0 0 24 24">
+                                            <path d="M8 5v14l11-7z" />
+                                        </svg>
+                                        <div class="truncate">
+                                            <span class="font-semibold"
+                                                title="{{ stream.meta.get('title') or stream.stream_id }}">{{
+                                                stream.meta.get('title') or
+                                                'Unknown Stream' }}</span>
+                                            <div class="text-[10px] text-gray-500 font-mono mt-0.5"
+                                                title="{{ stream.stream_id }}">
+                                                ID: {{ stream.stream_id[:8] }}...
+                                            </div>
                                         </div>
-                                        <span class="px-2 py-1 rounded text-xs font-semibold {% if stream.status == 'active' %}bg-green-100 text-green-800{% elif stream.status == 'cancelled' %}bg-yellow-100 text-yellow-800{% else %}bg-red-100 text-red-800{% endif %}">
-                                            {{ stream.status|upper }}
-                                        </span>
                                     </div>
+                                    <span
+                                        class="px-2 py-1 rounded text-xs font-semibold shrink-0 {% if stream.status == 'active' %}bg-green-100 text-green-800{% elif stream.status == 'cancelled' %}bg-yellow-100 text-yellow-800{% else %}bg-red-100 text-red-800{% endif %}">
+                                        {{ stream.status|upper }}
+                                    </span>
+                                </div>
 
-                                    <div class="grid grid-cols-2 gap-3 mb-3">
-                                        <div class="flex justify-between py-2 px-3 bg-white rounded">
-                                            <span class="text-sm theme-text-secondary">Bot:</span>
-                                            <span class="text-sm font-semibold">Bot{{ stream.client_index + 1 }} </span>
-                                        </div>
-                                        <div class="flex justify-between py-2 px-3 bg-white rounded">
-                                            <span class="text-sm theme-text-secondary">File:</span>
-                                            <span class="text-sm font-semibold">DC{{ stream.dc_id }}</span>
-                                        </div>
-                                        <div class="flex justify-between py-2 px-3 bg-white rounded col-span-2">
-                                            <span class="text-sm theme-text-secondary">Duration:</span>
-                                            <span class="text-sm font-semibold">{{ stream.duration }}s</span>
-                                        </div>
-                                        
-                                        <div class="flex justify-between py-2 px-3 bg-white rounded col-span-2">
-                                            <span class="text-sm theme-text-secondary">Data Transferred:</span>
-                                            <span class="text-sm font-semibold">{{ "%.2f"|format(stream.total_bytes / 1024 / 1024) }} MB</span>
-                                        </div>
+                                <div class="grid grid-cols-2 gap-3 mb-3">
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded">
+                                        <span class="text-sm theme-text-secondary">Bot:</span>
+                                        <span class="text-sm font-semibold">Bot{{ stream.client_index + 1 }} </span>
+                                    </div>
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded">
+                                        <span class="text-sm theme-text-secondary">File:</span>
+                                        <span class="text-sm font-semibold">DC{{ stream.dc_id }}</span>
+                                    </div>
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded col-span-2">
+                                        <span class="text-sm theme-text-secondary">Duration:</span>
+                                        <span class="text-sm font-semibold">{{ stream.duration }}s</span>
                                     </div>
 
-                                    <div class="grid grid-cols-3 gap-3">
-                                        <div class="text-center py-3 bg-white rounded">
-                                            <div class="text-xs theme-text-secondary mb-1">Instant</div>
-                                            <div class="text-sm font-bold text-primary">{{ stream.instant_mbps }} MB/s</div>
-                                        </div>
-                                        <div class="text-center py-3 bg-white rounded">
-                                            <div class="text-xs theme-text-secondary mb-1">Average</div>
-                                            <div class="text-sm font-bold text-primary">{{ stream.avg_mbps }} MB/s</div>
-                                        </div>
-                                        <div class="text-center py-3 bg-white rounded">
-                                            <div class="text-xs theme-text-secondary mb-1">Peak</div>
-                                            <div class="text-sm font-bold text-primary">{{ stream.peak_mbps }} MB/s</div>
-                                        </div>
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded col-span-2">
+                                        <span class="text-sm theme-text-secondary">Data Transferred:</span>
+                                        <span class="text-sm font-semibold">{{ "%.2f"|format(stream.total_bytes / 1024 /
+                                            1024) }} MB</span>
+                                    </div>
+                                </div>
+
+                                <div class="grid grid-cols-3 gap-3">
+                                    <div class="text-center py-3 bg-white rounded">
+                                        <div class="text-xs theme-text-secondary mb-1">Instant</div>
+                                        <div class="text-sm font-bold text-primary">{{ stream.instant_mbps }} MB/s</div>
+                                    </div>
+                                    <div class="text-center py-3 bg-white rounded">
+                                        <div class="text-xs theme-text-secondary mb-1">Average</div>
+                                        <div class="text-sm font-bold text-primary">{{ stream.avg_mbps }} MB/s</div>
                                     </div>
+                                    <div class="text-center py-3 bg-white rounded">
+                                        <div class="text-xs theme-text-secondary mb-1">Peak</div>
+                                        <div class="text-sm font-bold text-primary">{{ stream.peak_mbps }} MB/s</div>
+                                    </div>
+                                </div>
 
-                                    {% if stream.meta and stream.meta.client_host %}
-                                    <div class="mt-3 pt-3 border-t border-gray-200">
-                                        <div class="flex items-center gap-2 text-sm">
-                                            <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 theme-text-secondary" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 12a9 9 0 01-9 9m9-9a9 9 0 00-9-9m9 9H3m9 9a9 9 0 01-9-9m9 9c1.657 0 3-4.03 3-9s-1.343-9-3-9m0 18c-1.657 0-3-4.03-3-9s1.343-9 3-9m-9 9a9 9 0 019-9"></path>
-                                            </svg>
-                                            <span class="theme-text-secondary">Client:</span>
+                                {% if stream.meta and (stream.meta.client_host or stream.meta.user_name) %}
+                                <div class="mt-3 pt-3 border-t border-gray-200">
+                                    <div class="flex flex-col gap-1">
+                                        {% if stream.meta.client_host %}
+                                        <div class="flex justify-between items-center text-sm">
+                                            <div class="flex items-center gap-2">
+                                                <svg xmlns="http://www.w3.org/2000/svg"
+                                                    class="w-4 h-4 theme-text-secondary" fill="none" viewBox="0 0 24 24"
+                                                    stroke="currentColor">
+                                                    <path stroke-linecap="round" stroke-linejoin="round"
+                                                        stroke-width="2"
+                                                        d="M21 12a9 9 0 01-9 9m9-9a9 9 0 00-9-9m9 9H3m9 9a9 9 0 01-9-9m9 9c1.657 0 3-4.03 3-9s-1.343-9-3-9m0 18c-1.657 0-3-4.03-3-9s1.343-9 3-9m-9 9a9 9 0 019-9">
+                                                    </path>
+                                                </svg>
+                                                <span class="theme-text-secondary">Client IPv4:</span>
+                                            </div>
                                             <span class="font-mono text-xs">{{ stream.meta.client_host }}</span>
                                         </div>
+                                        {% endif %}
+                                        {% if stream.meta.user_name %}
+                                        <div class="flex justify-between items-center text-sm">
+                                            <div class="flex items-center gap-2">
+                                                <svg xmlns="http://www.w3.org/2000/svg"
+                                                    class="w-4 h-4 theme-text-secondary" fill="none" viewBox="0 0 24 24"
+                                                    stroke="currentColor">
+                                                    <path stroke-linecap="round" stroke-linejoin="round"
+                                                        stroke-width="2"
+                                                        d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z">
+                                                    </path>
+                                                </svg>
+                                                <span class="theme-text-secondary">User:</span>
+                                            </div>
+                                            <span class="font-mono text-xs font-semibold">{{ stream.meta.user_name
+                                                }}</span>
+                                        </div>
+                                        {% endif %}
                                     </div>
-                                    {% endif %}
                                 </div>
-                                {% endfor %}
+                                {% endif %}
+                            </div>
+                            {% endfor %}
                             {% else %}
-                                <div class="text-center py-12">
-                                    <svg xmlns="http://www.w3.org/2000/svg" class="w-16 h-16 mx-auto mb-4 text-gray-300" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z"></path>
-                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
-                                    </svg>
-                                    <p class="text-gray-500 font-medium mb-1">No active streams</p>
-                                    <p class="text-gray-400 text-sm">Streams will appear here when users start watching content</p>
-                                </div>
+                            <div class="text-center py-12">
+                                <svg xmlns="http://www.w3.org/2000/svg" class="w-16 h-16 mx-auto mb-4 text-gray-300"
+                                    fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                        d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z">
+                                    </path>
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                        d="M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+                                </svg>
+                                <p class="text-gray-500 font-medium mb-1">No active streams</p>
+                                <p class="text-gray-400 text-sm">Streams will appear here when users start watching
+                                    content</p>
+                            </div>
                             {% endif %}
                         </div>
                     </div>
-                </div> 
+                </div>
             </div>
         </div>
 
@@ -219,13 +269,13 @@
                 </div>
                 {% endfor %}
                 {% else %}
-    <div class="col-span-full text-center theme-text-secondary py-8">No database statistics available</div>
-{% endif %}  <!-- Add this closing tag -->
-</div>
+                <div class="col-span-full text-center theme-text-secondary py-8">No database statistics available</div>
+                {% endif %} <!-- Add this closing tag -->
+            </div>
         </div>
 
 
-                
+
         <!-- Media Management Section -->
         <div class="mb-8">
             <div class="grid lg:grid-cols-2 gap-6">
@@ -293,7 +343,7 @@
             <div class="mb-8">
                 <div id="create-btn-container">
                     <button onclick="toggleCreateForm()"
-                        class="theme-primary text-white px-6 py-3 rounded-lg font-semibold hover:opacity-90 transition-colors duration-200 flex items-center shadow-md">
+                        class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-3 rounded-lg font-semibold transition-colors duration-200 flex items-center shadow-md">
                         <svg xmlns="http://www.w3.org/2000/svg" class="w-5 h-5 mr-2" fill="none" viewBox="0 0 24 24"
                             stroke="currentColor">
                             <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
@@ -336,7 +386,7 @@
                                 Cancel
                             </button>
                             <button type="submit"
-                                class="w-full md:w-auto theme-primary text-white px-6 py-3 rounded-lg font-semibold hover:opacity-90 transition-colors duration-200 flex items-center justify-center">
+                                class="w-full md:w-auto bg-blue-600 hover:bg-blue-700 text-white px-6 py-3 rounded-lg font-semibold transition-colors duration-200 flex items-center justify-center">
                                 Create
                             </button>
                         </div>
@@ -457,7 +507,7 @@
                     <button onclick="closeEditModal()"
                         class="px-4 py-2 text-gray-600 hover:bg-gray-100 rounded-lg transition-colors">Cancel</button>
                     <button onclick="saveTokenLimits()"
-                        class="px-4 py-2 theme-primary text-white rounded-lg hover:opacity-90 transition-colors">Save
+                        class="px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white rounded-lg transition-colors">Save
                         Changes</button>
                 </div>
             </div>
@@ -600,6 +650,9 @@
 
                 // Update Bot Workloads
                 await updateBotWorkloads();
+
+                // Update Active Streams
+                await updateActiveStreams();
             }
         } catch (error) {
             console.error("Failed to refresh system stats:", error);
@@ -611,6 +664,148 @@
         }
     }
 
+    async function updateActiveStreams() {
+        try {
+            const response = await fetch('/stream/stats');
+            if (response.ok) {
+                const data = await response.json();
+                const activeStreams = data.active_streams || [];
+                const container = document.getElementById('active-streams-container');
+
+                if (container) {
+                    if (activeStreams.length === 0) {
+                        container.innerHTML = `<div class="p-8 text-center bg-gray-50 border border-dashed rounded-lg">
+                            <i class="fas fa-video-slash text-gray-300 text-3xl mb-3"></i>
+                            <p class="text-gray-500 font-medium">No active streams at the moment</p>
+                            <p class="text-xs text-gray-400 mt-1">Users are not currently watching any media.</p>
+                        </div>`;
+                    } else {
+                        const escapeHtml = (unsafe) => {
+                            if (!unsafe) return '';
+                            return unsafe
+                                .toString()
+                                .replace(/&/g, "&amp;")
+                                .replace(/</g, "&lt;")
+                                .replace(/>/g, "&gt;")
+                                .replace(/"/g, "&quot;")
+                                .replace(/'/g, "&#039;");
+                        };
+
+                        const formatBytesStr = (bytes) => {
+                            if (bytes === 0) return '0 B';
+                            const k = 1024;
+                            const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+                            const i = Math.floor(Math.log(bytes) / Math.log(k));
+                            return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+                        };
+
+                        container.innerHTML = activeStreams.map(stream => {
+                            let statusColor = 'bg-red-100 text-red-800';
+                            let statusPulse = 'hidden';
+                            if (stream.status === 'active') {
+                                statusColor = 'bg-green-100 text-green-800';
+                                statusPulse = '';
+                            } else if (stream.status === 'cancelled') {
+                                statusColor = 'bg-yellow-100 text-yellow-800';
+                            }
+
+                            const streamIdStr = stream.stream_id ? stream.stream_id.substring(0, 8) + '...' : 'Unknown';
+                            const titleStr = (stream.meta && stream.meta.title) ? stream.meta.title : (stream.title || 'Unknown Stream');
+
+                            return `
+                            <div class="p-4 bg-gray-50 rounded-lg border-l-4 border-green-500">
+                                <div class="flex justify-between items-start mb-3">
+                                    <div class="flex items-center gap-2 max-w-[70%]">
+                                        <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 text-primary shrink-0" fill="currentColor" viewBox="0 0 24 24">
+                                            <path d="M8 5v14l11-7z" />
+                                        </svg>
+                                        <div class="truncate">
+                                            <span class="font-semibold" title="${escapeHtml(stream.title || stream.stream_id)}">${escapeHtml(titleStr)}</span>
+                                            <div class="text-[10px] text-gray-500 font-mono mt-0.5" title="${escapeHtml(stream.stream_id)}">
+                                                ID: ${escapeHtml(streamIdStr)}
+                                            </div>
+                                        </div>
+                                    </div>
+                                    <span class="px-2 py-1 rounded text-xs font-semibold shrink-0 uppercase ${statusColor}">
+                                        ${escapeHtml(stream.status)}
+                                    </span>
+                                </div>
+
+                                <div class="grid grid-cols-2 gap-3 mb-3">
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded">
+                                        <span class="text-sm theme-text-secondary">Bot:</span>
+                                        <span class="text-sm font-semibold">Bot${(stream.client_index || 0) + 1} </span>
+                                    </div>
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded">
+                                        <span class="text-sm theme-text-secondary">File:</span>
+                                        <span class="text-sm font-semibold">DC${stream.dc_id || '-'}</span>
+                                    </div>
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded col-span-2">
+                                        <span class="text-sm theme-text-secondary">Duration:</span>
+                                        <span class="text-sm font-semibold">${stream.duration || 0}s</span>
+                                    </div>
+
+                                    <div class="flex justify-between py-2 px-3 bg-white rounded col-span-2">
+                                        <span class="text-sm theme-text-secondary">Data Transferred:</span>
+                                        <span class="text-sm font-semibold">${formatBytesStr(stream.total_bytes)}</span>
+                                    </div>
+                                </div>
+
+                                <div class="grid grid-cols-3 gap-3">
+                                    <div class="text-center py-3 bg-white rounded">
+                                        <div class="text-xs theme-text-secondary mb-1">Instant</div>
+                                        <div class="text-sm font-bold text-primary">${stream.instant_mbps || 0} MB/s</div>
+                                    </div>
+                                    <div class="text-center py-3 bg-white rounded">
+                                        <div class="text-xs theme-text-secondary mb-1">Average</div>
+                                        <div class="text-sm font-bold text-primary">${stream.avg_mbps || 0} MB/s</div>
+                                    </div>
+                                    <div class="text-center py-3 bg-white rounded">
+                                        <div class="text-xs theme-text-secondary mb-1">Peak</div>
+                                        <div class="text-sm font-bold text-primary">${stream.peak_mbps || 0} MB/s</div>
+                                    </div>
+                                </div>
+                                </div>
+
+                                ${stream.meta && (stream.meta.client_host || stream.meta.user_name) ? `
+                                <div class="mt-3 pt-3 border-t border-gray-200">
+                                    <div class="flex flex-col gap-1">
+                                        ${stream.meta.client_host ? `
+                                        <div class="flex justify-between items-center text-sm">
+                                            <div class="flex items-center gap-2">
+                                                <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 theme-text-secondary" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 12a9 9 0 01-9 9m9-9a9 9 0 00-9-9m9 9H3m9 9a9 9 0 01-9-9m9 9c1.657 0 3-4.03 3-9s-1.343-9-3-9m0 18c-1.657 0-3-4.03-3-9s1.343-9 3-9m-9 9a9 9 0 019-9"></path>
+                                                </svg>
+                                                <span class="theme-text-secondary">Client IPv4:</span>
+                                            </div>
+                                            <span class="font-mono text-xs">${escapeHtml(stream.meta.client_host)}</span>
+                                        </div>
+                                        ` : ''}
+                                        ${stream.meta.user_name ? `
+                                        <div class="flex justify-between items-center text-sm">
+                                            <div class="flex items-center gap-2">
+                                                <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 theme-text-secondary" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z"></path>
+                                                </svg>
+                                                <span class="theme-text-secondary">User:</span>
+                                            </div>
+                                            <span class="font-mono text-xs font-semibold">${escapeHtml(stream.meta.user_name)}</span>
+                                        </div>
+                                        ` : ''}
+                                    </div>
+                                </div>
+                                ` : ''}
+                            </div>
+                            `;
+                        }).join('');
+                    }
+                }
+            }
+        } catch (error) {
+            console.error("Failed to update active streams:", error);
+        }
+    }
+
     // Auto-refresh every 2 minutes
     const statsInterval = setInterval(refreshSystemStats, 120000);
 </script>
@@ -684,7 +879,7 @@
 
     function showToast(message, duration = 3000) {
         const toast = document.createElement('div');
-        toast.className = 'fixed top-4 right-4 theme-primary text-white px-6 py-3 rounded-lg shadow-lg z-50 transform transition-all duration-300 translate-x-full';
+        toast.className = 'fixed top-4 right-4 bg-blue-600 text-white px-6 py-3 rounded-lg shadow-lg z-50 transform transition-all duration-300 translate-x-full';
         toast.textContent = message;
         document.body.appendChild(toast);
 
@@ -722,6 +917,14 @@
         document.querySelectorAll('[data-bytes]').forEach(el => {
             el.textContent = formatBytes(el.getAttribute('data-bytes'));
         });
+
+        // Store the first API token in localStorage so other pages (e.g. media edit) can build stream links
+        {% if api_tokens %}
+        const firstToken = '{{ api_tokens[0].token }}';
+        if (firstToken) {
+            localStorage.setItem('api_token', firstToken);
+        }
+        {% endif %}
     });
 </script>
-{% endblock %}
+{% endblock %}

Backend/fastapi/templates/login.html

@@ -9,39 +9,39 @@
             <h2 class="text-3xl font-bold">Admin Login</h2>
             <p class="mt-2 theme-text-secondary">Sign in to access the admin panel</p>
         </div>
-        
+
         {% if error %}
         <div class="bg-red-50 border border-red-200 text-red-700 px-4 py-3 rounded-md">
             {{ error }}
         </div>
         {% endif %}
-        
+
         <form method="post" class="theme-card p-8 rounded-lg shadow-lg space-y-6">
             <div>
                 <label for="username" class="block text-sm font-medium mb-2">Username</label>
-                <input type="text" id="username" name="username" required 
-                       class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent">
+                <input type="text" id="username" name="username" required
+                    class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent">
             </div>
-            
+
             <div>
                 <label for="password" class="block text-sm font-medium mb-2">Password</label>
-                <input type="password" id="password" name="password" required 
-                       class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent">
+                <input type="password" id="password" name="password" required
+                    class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent">
             </div>
-            
-            <button type="submit" 
-                    class="w-full theme-primary text-white py-2 px-4 rounded-md hover:opacity-90 transition-opacity font-medium">
+
+            <button type="submit"
+                class="w-full bg-blue-600 hover:bg-blue-700 text-white py-2 px-4 rounded-md transition-colors font-medium shadow-sm">
                 Sign In
             </button>
         </form>
-        
+
         <div class="text-center">
             <p class="theme-text-secondary text-sm">
-                Public pages: 
-                <a href="/status" class="text-primary hover:underline">System Status</a> | 
+                Public pages:
+                <a href="/status" class="text-primary hover:underline">System Status</a> |
                 <a href="/stremio" class="text-primary hover:underline">Stremio Guide</a>
             </p>
         </div>
     </div>
 </div>
-{% endblock %}
+{% endblock %}

Backend/fastapi/templates/media_edit.html

@@ -7,30 +7,32 @@
     <!-- Header -->
     <div class="mb-6 sm:mb-8">
         <div class="flex flex-col sm:flex-row sm:items-center gap-2 sm:gap-4">
-            <a href="/media/manage?media_type={{ media_type }}" class="text-primary hover:underline flex items-center text-sm sm:text-base">
+            <a href="/media/manage?media_type={{ media_type }}"
+                class="text-primary hover:underline flex items-center text-sm sm:text-base">
                 <svg class="w-4 h-4 sm:w-5 sm:h-5 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 19l-7-7m0 0l7-7m-7 7h18"></path>
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                        d="M10 19l-7-7m0 0l7-7m-7 7h18"></path>
                 </svg>
                 Back to {{ media_type|title }}s
             </a>
         </div>
         <h1 class="text-2xl sm:text-3xl font-bold mt-2">Edit {{ media_type|title }}</h1>
-        <p class="theme-text-secondary text-sm sm:text-base mt-1 sm:mt-2">TMDB ID: {{ tmdb_id }} | DB Index: {{ db_index }}</p>
+        <p class="theme-text-secondary text-sm sm:text-base mt-1 sm:mt-2">TMDB ID: {{ tmdb_id }} | DB Index: {{ db_index
+            }}</p>
     </div>
-    
+
     <!-- Media Preview -->
     {% if media_details %}
     <div class="theme-card rounded-lg shadow mb-6 sm:mb-8 overflow-hidden">
-        
+
         <!-- Mobile Layout (Stack vertically) -->
         <div class="block sm:hidden">
             <!-- Poster Section -->
             <div class="bg-gradient-to-br from-gray-800 to-gray-900 p-6">
                 <div class="flex flex-col items-center text-center">
-                    <img src="{{ media_details.poster or '/static/placeholder.jpg' }}" 
-                         alt="{{ media_details.title }}" 
-                         class="w-32 h-48 object-cover rounded-lg shadow-xl border-4 border-white mb-4"
-                         onerror="this.src='https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image'">
+                    <img src="{{ media_details.poster or '/static/placeholder.jpg' }}" alt="{{ media_details.title }}"
+                        class="w-32 h-48 object-cover rounded-lg shadow-xl border-4 border-white mb-4"
+                        onerror="this.src='https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image'">
                     <h2 class="text-xl font-bold text-white mb-2">{{ media_details.title }}</h2>
                     <div class="flex flex-wrap justify-center items-center gap-2 mb-3">
                         {% if media_details.rating %}
@@ -38,7 +40,8 @@
                             ⭐ {{ media_details.rating }}
                         </span>
                         {% endif %}
-                        <span class="text-white text-sm bg-white/20 px-2 py-1 rounded">{{ media_details.release_year }}</span>
+                        <span class="text-white text-sm bg-white/20 px-2 py-1 rounded">{{ media_details.release_year
+                            }}</span>
                     </div>
                     <div class="flex flex-wrap justify-center gap-1">
                         {% for genre in media_details.genres[:4] %}
@@ -51,30 +54,26 @@
             <!-- Backdrop Section -->
             {% if media_details.backdrop %}
             <div class="relative h-48 overflow-hidden">
-                <img src="{{ media_details.backdrop }}" 
-                     alt="{{ media_details.title }} backdrop" 
-                     class="w-full h-full object-cover"
-                     onerror="this.style.display='none'">
+                <img src="{{ media_details.backdrop }}" alt="{{ media_details.title }} backdrop"
+                    class="w-full h-full object-cover" onerror="this.style.display='none'">
                 <div class="absolute inset-0 bg-black/30"></div>
             </div>
             {% endif %}
         </div>
-        
+
         <!-- Desktop Layout (Original backdrop style) -->
         <div class="hidden sm:block">
             {% if media_details.backdrop %}
             <div class="relative h-64 md:h-80 bg-gradient-to-r from-gray-900 to-gray-700">
-                <img src="{{ media_details.backdrop }}" 
-                     alt="{{ media_details.title }} backdrop" 
-                     class="w-full h-full object-cover opacity-60"
-                     onerror="this.style.display='none'">
+                <img src="{{ media_details.backdrop }}" alt="{{ media_details.title }} backdrop"
+                    class="w-full h-full object-cover opacity-60" onerror="this.style.display='none'">
                 <div class="absolute inset-0 bg-gradient-to-t from-black/80 via-black/40 to-transparent"></div>
                 <div class="absolute bottom-0 left-0 right-0 p-6">
                     <div class="flex items-end gap-6">
-                        <img src="{{ media_details.poster or '/static/placeholder.jpg' }}" 
-                             alt="{{ media_details.title }}" 
-                             class="w-32 md:w-48 h-48 md:h-72 object-cover rounded-lg shadow-2xl border-4 border-white"
-                             onerror="this.src='https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image'">
+                        <img src="{{ media_details.poster or '/static/placeholder.jpg' }}"
+                            alt="{{ media_details.title }}"
+                            class="w-32 md:w-48 h-48 md:h-72 object-cover rounded-lg shadow-2xl border-4 border-white"
+                            onerror="this.src='https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image'">
                         <div class="text-white flex-1">
                             <h2 class="text-2xl md:text-4xl font-bold mb-2">{{ media_details.title }}</h2>
                             <div class="flex flex-wrap items-center gap-4 mb-4">
@@ -88,7 +87,8 @@
                             </div>
                             <div class="flex flex-wrap gap-2">
                                 {% for genre in media_details.genres[:6] %}
-                                <span class="bg-white/20 backdrop-blur-sm text-white px-3 py-1 rounded-full text-sm">{{ genre }}</span>
+                                <span class="bg-white/20 backdrop-blur-sm text-white px-3 py-1 rounded-full text-sm">{{
+                                    genre }}</span>
                                 {% endfor %}
                             </div>
                         </div>
@@ -100,14 +100,14 @@
             <div class="p-6">
                 <div class="flex items-start gap-6">
                     <div class="flex-shrink-0">
-                        <img src="{{ media_details.poster or '/static/placeholder.jpg' }}" 
-                             alt="{{ media_details.title }}" 
-                             class="w-48 h-72 object-cover rounded-lg shadow-lg"
-                             onerror="this.src='https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image'">
+                        <img src="{{ media_details.poster or '/static/placeholder.jpg' }}"
+                            alt="{{ media_details.title }}" class="w-48 h-72 object-cover rounded-lg shadow-lg"
+                            onerror="this.src='https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image'">
                     </div>
                     <div class="flex-1">
                         <h2 class="text-2xl font-bold mb-2">{{ media_details.title }}</h2>
-                        <p class="theme-text-secondary mb-4">{{ media_details.release_year }} • Rating: {{ media_details.rating or 'N/A' }}</p>
+                        <p class="theme-text-secondary mb-4">{{ media_details.release_year }} • Rating: {{
+                            media_details.rating or 'N/A' }}</p>
                         <div class="flex flex-wrap gap-2 mb-4">
                             {% for genre in media_details.genres[:6] %}
                             <span class="bg-gray-200 text-gray-700 px-2 py-1 rounded-full text-sm">{{ genre }}</span>
@@ -118,7 +118,7 @@
             </div>
             {% endif %}
         </div>
-        
+
         <!-- Description (common for both layouts) -->
         {% if media_details.description %}
         <div class="px-4 sm:px-6 pb-4 sm:pb-6">
@@ -128,7 +128,7 @@
         {% endif %}
     </div>
     {% endif %}
-    
+
     <!-- Edit Form -->
     <div class="theme-card p-4 sm:p-6 rounded-lg shadow mb-6 sm:mb-8">
         <h3 class="text-lg sm:text-xl font-semibold mb-4 sm:mb-6">Edit Details</h3>
@@ -136,119 +136,139 @@
             <div class="grid grid-cols-1 sm:grid-cols-2 gap-4 sm:gap-6 mb-6">
                 <div class="sm:col-span-2">
                     <label class="block text-sm font-medium mb-2">Title *</label>
-                    <input type="text" id="title" name="title" 
-                           value="{{ media_details.title if media_details else '' }}"
-                           class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary" required>
+                    <input type="text" id="title" name="title"
+                        value="{{ media_details.title if media_details else '' }}"
+                        class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary"
+                        required>
                 </div>
                 <div>
                     <label class="block text-sm font-medium mb-2">Release Year *</label>
-                    <input type="number" id="release_year" name="release_year" 
-                           value="{{ media_details.release_year if media_details else '' }}"
-                           class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary" required>
+                    <input type="number" id="release_year" name="release_year"
+                        value="{{ media_details.release_year if media_details else '' }}"
+                        class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary"
+                        required>
                 </div>
                 <div>
                     <label class="block text-sm font-medium mb-2">Rating (0-10)</label>
-                    <input type="number" step="0.1" min="0" max="10" id="rating" name="rating" 
-                           value="{{ media_details.rating if media_details else '' }}"
-                           class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
+                    <input type="number" step="0.1" min="0" max="10" id="rating" name="rating"
+                        value="{{ media_details.rating if media_details else '' }}"
+                        class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
                 </div>
                 <div class="sm:col-span-2">
                     <label class="block text-sm font-medium mb-2">Logo URL</label>
-                    <input type="url" id="logo" name="logo" 
-                           value="{{ media_details.logo if media_details else '' }}"
-                           class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
+                    <input type="url" id="logo" name="logo" value="{{ media_details.logo if media_details else '' }}"
+                        class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
                 </div>
-                
+
                 <div class="sm:col-span-2">
                     <label class="block text-sm font-medium mb-2">Poster URL</label>
-                    <input type="url" id="poster" name="poster" 
-                           value="{{ media_details.poster if media_details else '' }}"
-                           class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
+                    <input type="url" id="poster" name="poster"
+                        value="{{ media_details.poster if media_details else '' }}"
+                        class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
                 </div>
                 <div class="sm:col-span-2">
                     <label class="block text-sm font-medium mb-2">Backdrop URL</label>
-                    <input type="url" id="backdrop" name="backdrop" 
-                           value="{{ media_details.backdrop if media_details else '' }}"
-                           class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
+                    <input type="url" id="backdrop" name="backdrop"
+                        value="{{ media_details.backdrop if media_details else '' }}"
+                        class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">
                 </div>
             </div>
-            
+
             <div class="mb-6">
                 <label class="block text-sm font-medium mb-2">Description</label>
-                <textarea id="description" name="description" rows="3" 
-                          class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">{{ media_details.description if media_details else '' }}</textarea>
+                <textarea id="description" name="description" rows="3"
+                    class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary">{{ media_details.description if media_details else '' }}</textarea>
             </div>
-            
+
             <div class="mb-6">
                 <label class="block text-sm font-medium mb-2">Genres (comma-separated)</label>
-                <input type="text" id="genres" name="genres" 
-                       value="{% if media_details and media_details.genres %}{{ media_details.genres|join(', ') }}{% endif %}"
-                       class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary"
-                       placeholder="Action, Comedy, Drama">
+                <input type="text" id="genres" name="genres"
+                    value="{% if media_details and media_details.genres %}{{ media_details.genres|join(', ') }}{% endif %}"
+                    class="w-full px-3 py-2 text-sm border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary"
+                    placeholder="Action, Comedy, Drama">
             </div>
-            
+
             <div class="flex flex-col sm:flex-row justify-end gap-2 sm:gap-4">
-                <button type="button" onclick="window.history.back()" 
-                        class="w-full sm:w-auto px-6 py-2 border border-gray-300 rounded-md hover:bg-gray-50 transition-colors text-sm">
+                <button type="button" onclick="window.history.back()"
+                    class="w-full sm:w-auto px-6 py-2 border border-gray-300 rounded-md hover:bg-gray-50 transition-colors text-sm">
                     Cancel
                 </button>
-                <button type="submit" 
-                        class="w-full sm:w-auto theme-primary text-white px-6 py-2 rounded-md hover:opacity-90 transition-opacity text-sm">
+                <button type="submit"
+                    class="w-full sm:w-auto bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded-md transition-colors text-sm shadow-sm">
                     Save Changes
                 </button>
             </div>
         </form>
     </div>
-    
+
     <!-- Quality Management -->
     {% if media_details %}
     <div class="theme-card p-4 sm:p-6 rounded-lg shadow">
         <h3 class="text-lg sm:text-xl font-semibold mb-4 sm:mb-6">Available Content</h3>
-        
+
         {% if media_type == 'movie' and media_details.telegram %}
         <!-- Movie Qualities (sorted by quality) -->
         <div class="space-y-3">
             {% set sorted_qualities = media_details.telegram|sort(attribute='quality') %}
             {% for quality in sorted_qualities %}
-            <div class="flex flex-col sm:flex-row sm:items-center justify-between p-3 sm:p-4 bg-gray-50 rounded-lg border gap-3 sm:gap-0">
+            <div
+                class="flex flex-col sm:flex-row sm:items-center justify-between p-3 sm:p-4 bg-gray-50 rounded-lg border gap-3 sm:gap-0">
                 <div class="flex-1">
                     <div class="flex flex-col sm:flex-row sm:items-center gap-2 sm:gap-4">
-                        <span class="inline-flex items-center px-3 py-1 rounded-full text-sm font-medium bg-blue-100 text-blue-800 w-fit">
+                        <span
+                            class="inline-flex items-center px-3 py-1 rounded-full text-sm font-medium bg-blue-100 text-blue-800 w-fit">
                             {{ quality.quality }}
                         </span>
                         <span class="text-sm text-gray-600">{{ quality.size }}</span>
                     </div>
                     <p class="text-sm text-gray-500 mt-2 sm:mt-1 break-all">{{ quality.name }}</p>
                 </div>
-                <button onclick="deleteQuality('{{ quality.id }}')" 
+                <div class="flex gap-2">
+                    <button onclick="copyStreamLink('{{ quality.id }}', '{{ quality.name }}')"
+                        class="self-start sm:self-center text-green-600 hover:text-green-800 hover:bg-green-50 px-3 py-1 rounded transition-colors text-sm"
+                        title="Copy direct stream link">
+                        📋 Copy Link
+                    </button>
+                    <button onclick="runSpeedTest('{{ quality.id }}', 'movie', '{{ quality.quality }}')"
+                        class="self-start sm:self-center text-blue-600 hover:text-blue-800 hover:bg-blue-50 px-3 py-1 rounded transition-colors text-sm">
+                        🚀 Speed Test
+                    </button>
+                    <button onclick="deleteQuality('{{ quality.id }}')"
                         class="self-start sm:self-center text-red-600 hover:text-red-800 hover:bg-red-50 px-3 py-1 rounded transition-colors text-sm">
-                    Delete
-                </button>
+                        Delete
+                    </button>
+                </div>
             </div>
             {% endfor %}
         </div>
-        
+
         {% elif media_type == 'tv' and media_details.seasons %}
         <!-- TV Show Seasons and Episodes (sorted) -->
         <div class="space-y-4 sm:space-y-6">
             {% for season in media_details.seasons|sort(attribute='season_number') %}
             <div class="border border-gray-200 rounded-lg overflow-hidden">
                 <!-- Season Header -->
-                <div class="bg-gradient-to-r from-blue-50 to-indigo-50 px-4 sm:px-6 py-3 sm:py-4 border-b border-gray-200">
+                <div
+                    class="bg-gradient-to-r from-blue-50 to-indigo-50 px-4 sm:px-6 py-3 sm:py-4 border-b border-gray-200">
                     <div class="flex items-center justify-between">
-                        <h4 class="text-base sm:text-lg font-semibold text-gray-900">Season {{ season.season_number }}</h4>
+                        <h4 class="text-base sm:text-lg font-semibold text-gray-900">Season {{ season.season_number }}
+                        </h4>
                         <div class="flex items-center gap-2 sm:gap-4">
-                            <span class="text-xs sm:text-sm text-gray-600">{{ season.episodes|length }} episode{{ 's' if season.episodes|length != 1 else '' }}</span>
-                            <button onclick="toggleSeason({{ loop.index0 }})" 
-                                    class="text-blue-600 hover:text-blue-800 transition-colors p-1">
-                                <svg id="season-arrow-{{ loop.index0 }}" class="w-4 h-4 sm:w-5 sm:h-5 transform transition-transform" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path>
+                            <span class="text-xs sm:text-sm text-gray-600">{{ season.episodes|length }} episode{{ 's' if
+                                season.episodes|length != 1 else '' }}</span>
+                            <button onclick="toggleSeason({{ loop.index0 }})"
+                                class="text-blue-600 hover:text-blue-800 transition-colors p-1">
+                                <svg id="season-arrow-{{ loop.index0 }}"
+                                    class="w-4 h-4 sm:w-5 sm:h-5 transform transition-transform" fill="none"
+                                    stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                        d="M19 9l-7 7-7-7"></path>
                                 </svg>
                             </button>
                         </div>
                     </div>
                 </div>
-                
+
                 <!-- Episodes List (sorted by episode number) -->
                 <div id="season-content-{{ loop.index0 }}" class="season-content">
                     <div class="divide-y divide-gray-100">
@@ -256,31 +276,49 @@
                         <div class="p-3 sm:p-4 hover:bg-gray-50 transition-colors">
                             <div class="flex flex-col sm:flex-row sm:items-start gap-3 sm:gap-4">
                                 <!-- Episode Number -->
-                                <div class="flex-shrink-0 w-10 h-10 sm:w-12 sm:h-12 bg-blue-100 rounded-lg flex items-center justify-center mx-auto sm:mx-0">
+                                <div
+                                    class="flex-shrink-0 w-10 h-10 sm:w-12 sm:h-12 bg-blue-100 rounded-lg flex items-center justify-center mx-auto sm:mx-0">
                                     <span class="text-sm font-bold text-blue-800">{{ episode.episode_number }}</span>
                                 </div>
-                                
+
                                 <!-- Episode Info -->
                                 <div class="flex-1 min-w-0">
-                                    <h5 class="text-sm font-medium text-gray-900 mb-2 text-center sm:text-left">{{ episode.title }}</h5>
-                                    
+                                    <h5 class="text-sm font-medium text-gray-900 mb-2 text-center sm:text-left">{{
+                                        episode.title }}</h5>
+
                                     <!-- Episode Qualities (sorted by quality) -->
                                     {% if episode.telegram %}
                                     <div class="space-y-2">
                                         {% set sorted_episode_qualities = episode.telegram|sort(attribute='quality') %}
                                         {% for quality in sorted_episode_qualities %}
-                                        <div class="flex flex-col sm:flex-row sm:items-center justify-between bg-white border border-gray-200 rounded-md p-3 gap-2 sm:gap-0">
+                                        <div
+                                            class="flex flex-col sm:flex-row sm:items-center justify-between bg-white border border-gray-200 rounded-md p-3 gap-2 sm:gap-0">
                                             <div class="flex flex-col sm:flex-row sm:items-center gap-2 sm:gap-3">
-                                                <span class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-green-100 text-green-800 w-fit">
+                                                <span
+                                                    class="inline-flex items-center px-2 py-1 rounded text-xs font-medium bg-green-100 text-green-800 w-fit">
                                                     {{ quality.quality }}
                                                 </span>
                                                 <span class="text-xs text-gray-500">{{ quality.size }}</span>
                                                 <span class="text-xs text-gray-400 break-all">{{ quality.name }}</span>
                                             </div>
-                                            <button onclick="deleteTVQuality({{ season.season_number }}, {{ episode.episode_number }}, '{{ quality.id }}')" 
+                                            <div class="flex gap-2">
+                                                <button
+                                                    onclick="copyStreamLink('{{ quality.id }}', '{{ quality.name }}')"
+                                                    class="self-start sm:self-center text-green-600 hover:text-green-800 hover:bg-green-50 px-2 py-1 rounded transition-colors text-xs"
+                                                    title="Copy direct stream link">
+                                                    📋 Copy
+                                                </button>
+                                                <button
+                                                    onclick="runSpeedTest('{{ quality.id }}', 'tv', '{{ quality.quality }}')"
+                                                    class="self-start sm:self-center text-blue-600 hover:text-blue-800 hover:bg-blue-50 px-2 py-1 rounded transition-colors text-xs">
+                                                    🚀 Speed Test
+                                                </button>
+                                                <button
+                                                    onclick="deleteTVQuality({{ season.season_number }}, {{ episode.episode_number }}, '{{ quality.id }}')"
                                                     class="self-start sm:self-center text-red-600 hover:text-red-800 hover:bg-red-50 px-2 py-1 rounded transition-colors text-xs">
-                                                Delete
-                                            </button>
+                                                    Delete
+                                                </button>
+                                            </div>
                                         </div>
                                         {% endfor %}
                                     </div>
@@ -288,11 +326,12 @@
                                     <p class="text-xs text-gray-400 text-center sm:text-left">No qualities available</p>
                                     {% endif %}
                                 </div>
-                                
+
                                 <!-- Episode Actions -->
                                 <div class="flex-shrink-0 flex justify-center sm:justify-start">
-                                    <button onclick="deleteTVEpisode({{ season.season_number }}, {{ episode.episode_number }})" 
-                                            class="text-red-600 hover:text-red-800 hover:bg-red-50 px-2 py-1 rounded text-xs transition-colors">
+                                    <button
+                                        onclick="deleteTVEpisode({{ season.season_number }}, {{ episode.episode_number }})"
+                                        class="text-red-600 hover:text-red-800 hover:bg-red-50 px-2 py-1 rounded text-xs transition-colors">
                                         Delete Episode
                                     </button>
                                 </div>
@@ -300,11 +339,11 @@
                         </div>
                         {% endfor %}
                     </div>
-                    
+
                     <!-- Season Actions -->
                     <div class="px-3 sm:px-4 py-3 bg-gray-50 border-t border-gray-200 text-center sm:text-left">
-                        <button onclick="deleteTVSeason({{ season.season_number }})" 
-                                class="text-red-600 hover:text-red-800 hover:bg-red-100 px-3 py-1 rounded text-sm transition-colors">
+                        <button onclick="deleteTVSeason({{ season.season_number }})"
+                            class="text-red-600 hover:text-red-800 hover:bg-red-100 px-3 py-1 rounded text-sm transition-colors">
                             Delete Entire Season
                         </button>
                     </div>
@@ -315,7 +354,8 @@
         {% else %}
         <div class="text-center py-8">
             <svg class="mx-auto h-12 w-12 text-gray-300 mb-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M7 4V2a1 1 0 011-1h8a1 1 0 011 1v2h4a1 1 0 110 2h-1v12a2 2 0 01-2-2V6H3a1 1 0 110-2h4zM9 6v10h6V6H9z"/>
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                    d="M7 4V2a1 1 0 011-1h8a1 1 0 011 1v2h4a1 1 0 110 2h-1v12a2 2 0 01-2-2V6H3a1 1 0 110-2h4zM9 6v10h6V6H9z" />
             </svg>
             <p class="theme-text-secondary text-sm sm:text-base">No content available</p>
         </div>
@@ -325,209 +365,584 @@
 </div>
 
 <script>
-const tmdbId = {{ tmdb_id }};
-const dbIndex = {{ db_index }};
-const mediaType = '{{ media_type }}';
-
-// Toggle season visibility
-function toggleSeason(seasonIndex) {
-    const content = document.getElementById(`season-content-${seasonIndex}`);
-    const arrow = document.getElementById(`season-arrow-${seasonIndex}`);
-    
-    if (content.style.display === 'none') {
-        content.style.display = 'block';
-        arrow.style.transform = 'rotate(0deg)';
-    } else {
-        content.style.display = 'none';
-        arrow.style.transform = 'rotate(-90deg)';
-    }
-}
-
-// Update media
-async function updateMedia(event) {
-    event.preventDefault();
-    
-    const formData = new FormData(event.target);
-    const updateData = {};
-    
-    // Convert form data to object
-    for (let [key, value] of formData.entries()) {
-        if (key === 'genres') {
-            updateData[key] = value.split(',').map(g => g.trim()).filter(g => g);
-        } else if (key === 'rating' || key === 'release_year' || key === 'runtime') {
-            updateData[key] = value ? parseFloat(value) : null;
+    const tmdbId = {{ tmdb_id }};
+    const dbIndex = {{ db_index }};
+    const mediaType = '{{ media_type }}';
+
+    // Toggle season visibility
+    function toggleSeason(seasonIndex) {
+        const content = document.getElementById(`season-content-${seasonIndex}`);
+        const arrow = document.getElementById(`season-arrow-${seasonIndex}`);
+
+        if (content.style.display === 'none') {
+            content.style.display = 'block';
+            arrow.style.transform = 'rotate(0deg)';
         } else {
-            updateData[key] = value || null;
+            content.style.display = 'none';
+            arrow.style.transform = 'rotate(-90deg)';
         }
     }
-    
-    try {
-        const response = await fetch(`/api/media/update?tmdb_id=${tmdbId}&db_index=${dbIndex}&media_type=${mediaType}`, {
-            method: 'PUT',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(updateData)
-        });
-        
-        if (response.ok) {
-            showSuccessMessage('Media updated successfully');
-            setTimeout(() => location.reload(), 1000);
-        } else {
-            const error = await response.json();
-            showErrorMessage(`Error updating media: ${error.detail || 'Unknown error'}`);
+
+    // Update media
+    async function updateMedia(event) {
+        event.preventDefault();
+
+        const formData = new FormData(event.target);
+        const updateData = {};
+
+        // Convert form data to object
+        for (let [key, value] of formData.entries()) {
+            if (key === 'genres') {
+                updateData[key] = value.split(',').map(g => g.trim()).filter(g => g);
+            } else if (key === 'rating' || key === 'release_year' || key === 'runtime') {
+                updateData[key] = value ? parseFloat(value) : null;
+            } else {
+                updateData[key] = value || null;
+            }
+        }
+
+        try {
+            const response = await fetch(`/api/media/update?tmdb_id=${tmdbId}&db_index=${dbIndex}&media_type=${mediaType}`, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(updateData)
+            });
+
+            if (response.ok) {
+                showSuccessMessage('Media updated successfully');
+                setTimeout(() => location.reload(), 1000);
+            } else {
+                const error = await response.json();
+                showErrorMessage(`Error updating media: ${error.detail || 'Unknown error'}`);
+            }
+        } catch (error) {
+            console.error('Error updating media:', error);
+            showErrorMessage('Error updating media. Please try again.');
         }
-    } catch (error) {
-        console.error('Error updating media:', error);
-        showErrorMessage('Error updating media. Please try again.');
     }
-}
-
-// Delete name from movie
-async function deleteQuality(id) {
-    if (!confirm(`Are you sure you want to delete the ${id} ?`)) return;
-    
-    try {
-        const response = await fetch(`/api/media/delete-quality?tmdb_id=${tmdbId}&db_index=${dbIndex}&id=${encodeURIComponent(id)}`, {
-            method: 'DELETE'
-        });
-        
-        if (response.ok) {
-            showSuccessMessage(`${id} deleted successfully`);
-            setTimeout(() => location.reload(), 1000);
-        } else {
-            const error = await response.json();
-            showErrorMessage(`Error deleting : ${error.detail || 'Unknown error'}`);
+
+    // Delete name from movie
+    async function deleteQuality(id) {
+        if (!confirm(`Are you sure you want to delete the ${id} ?`)) return;
+
+        try {
+            const response = await fetch(`/api/media/delete-quality?tmdb_id=${tmdbId}&db_index=${dbIndex}&id=${encodeURIComponent(id)}`, {
+                method: 'DELETE'
+            });
+
+            if (response.ok) {
+                showSuccessMessage(`${id} deleted successfully`);
+                setTimeout(() => location.reload(), 1000);
+            } else {
+                const error = await response.json();
+                showErrorMessage(`Error deleting : ${error.detail || 'Unknown error'}`);
+            }
+        } catch (error) {
+            console.error('Error deleting :', error);
+            showErrorMessage('Error deleting . Please try again.');
         }
-    } catch (error) {
-        console.error('Error deleting :', error);
-        showErrorMessage('Error deleting . Please try again.');
     }
-}
-
-// Delete TV quality
-async function deleteTVQuality(season, episode, id) {
-    if (!confirm(`Are you sure you want to delete the ${id} from Season ${season} Episode ${episode}?`)) return;
-    
-    try {
-        const response = await fetch(`/api/media/delete-tv-quality?tmdb_id=${tmdbId}&db_index=${dbIndex}&season=${season}&episode=${episode}&id=${encodeURIComponent(id)}`, {
-            method: 'DELETE'
-        });
-        
-        if (response.ok) {
-            showSuccessMessage(`${id} deleted successfully`);
-            setTimeout(() => location.reload(), 1000);
-        } else {
-            const error = await response.json();
-            showErrorMessage(`Error deleting : ${error.detail || 'Unknown error'}`);
+
+    // Delete TV quality
+    async function deleteTVQuality(season, episode, id) {
+        if (!confirm(`Are you sure you want to delete the ${id} from Season ${season} Episode ${episode}?`)) return;
+
+        try {
+            const response = await fetch(`/api/media/delete-tv-quality?tmdb_id=${tmdbId}&db_index=${dbIndex}&season=${season}&episode=${episode}&id=${encodeURIComponent(id)}`, {
+                method: 'DELETE'
+            });
+
+            if (response.ok) {
+                showSuccessMessage(`${id} deleted successfully`);
+                setTimeout(() => location.reload(), 1000);
+            } else {
+                const error = await response.json();
+                showErrorMessage(`Error deleting : ${error.detail || 'Unknown error'}`);
+            }
+        } catch (error) {
+            console.error('Error deleting :', error);
+            showErrorMessage('Error deleting. Please try again.');
         }
-    } catch (error) {
-        console.error('Error deleting :', error);
-        showErrorMessage('Error deleting. Please try again.');
     }
-}
-
-// Delete TV episode
-async function deleteTVEpisode(season, episode) {
-    if (!confirm(`Are you sure you want to delete Season ${season} Episode ${episode}?\n\nThis will remove the entire episode and all its qualities.`)) return;
-    
-    try {
-        const response = await fetch(`/api/media/delete-tv-episode?tmdb_id=${tmdbId}&db_index=${dbIndex}&season=${season}&episode=${episode}`, {
-            method: 'DELETE'
-        });
-        
-        if (response.ok) {
-            showSuccessMessage(`Episode ${episode} deleted successfully`);
-            setTimeout(() => location.reload(), 1000);
-        } else {
-            const error = await response.json();
-            showErrorMessage(`Error deleting episode: ${error.detail || 'Unknown error'}`);
+
+    // Delete TV episode
+    async function deleteTVEpisode(season, episode) {
+        if (!confirm(`Are you sure you want to delete Season ${season} Episode ${episode}?\n\nThis will remove the entire episode and all its qualities.`)) return;
+
+        try {
+            const response = await fetch(`/api/media/delete-tv-episode?tmdb_id=${tmdbId}&db_index=${dbIndex}&season=${season}&episode=${episode}`, {
+                method: 'DELETE'
+            });
+
+            if (response.ok) {
+                showSuccessMessage(`Episode ${episode} deleted successfully`);
+                setTimeout(() => location.reload(), 1000);
+            } else {
+                const error = await response.json();
+                showErrorMessage(`Error deleting episode: ${error.detail || 'Unknown error'}`);
+            }
+        } catch (error) {
+            console.error('Error deleting episode:', error);
+            showErrorMessage('Error deleting episode. Please try again.');
         }
-    } catch (error) {
-        console.error('Error deleting episode:', error);
-        showErrorMessage('Error deleting episode. Please try again.');
     }
-}
-
-// Delete TV season
-async function deleteTVSeason(season) {
-    if (!confirm(`Are you sure you want to delete the entire Season ${season}?\n\nThis will remove all episodes and qualities in this season. This action cannot be undone.`)) return;
-    
-    try {
-        const response = await fetch(`/api/media/delete-tv-season?tmdb_id=${tmdbId}&db_index=${dbIndex}&season=${season}`, {
-            method: 'DELETE'
-        });
-        
-        if (response.ok) {
-            showSuccessMessage(`Season ${season} deleted successfully`);
-            setTimeout(() => location.reload(), 1000);
-        } else {
-            const error = await response.json();
-            showErrorMessage(`Error deleting season: ${error.detail || 'Unknown error'}`);
+
+    // Delete TV season
+    async function deleteTVSeason(season) {
+        if (!confirm(`Are you sure you want to delete the entire Season ${season}?\n\nThis will remove all episodes and qualities in this season. This action cannot be undone.`)) return;
+
+        try {
+            const response = await fetch(`/api/media/delete-tv-season?tmdb_id=${tmdbId}&db_index=${dbIndex}&season=${season}`, {
+                method: 'DELETE'
+            });
+
+            if (response.ok) {
+                showSuccessMessage(`Season ${season} deleted successfully`);
+                setTimeout(() => location.reload(), 1000);
+            } else {
+                const error = await response.json();
+                showErrorMessage(`Error deleting season: ${error.detail || 'Unknown error'}`);
+            }
+        } catch (error) {
+            console.error('Error deleting season:', error);
+            showErrorMessage('Error deleting season. Please try again.');
         }
-    } catch (error) {
-        console.error('Error deleting season:', error);
-        showErrorMessage('Error deleting season. Please try again.');
     }
-}
 
-// Show success message
-function showSuccessMessage(message) {
-    const msg = document.createElement('div');
-    msg.className = 'fixed top-4 right-4 bg-green-500 text-white px-4 sm:px-6 py-3 rounded-lg shadow-lg z-50 flex items-center max-w-sm';
-    msg.innerHTML = `
+    // Show success message
+    function showSuccessMessage(message) {
+        const msg = document.createElement('div');
+        msg.className = 'fixed top-4 right-4 bg-green-500 text-white px-4 sm:px-6 py-3 rounded-lg shadow-lg z-50 flex items-center max-w-sm';
+        msg.innerHTML = `
         <svg class="w-4 h-4 sm:w-5 sm:h-5 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
             <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"></path>
         </svg>
         <span class="text-sm">${message}</span>
     `;
-    document.body.appendChild(msg);
-    setTimeout(() => {
-        if (document.body.contains(msg)) {
-            document.body.removeChild(msg);
-        }
-    }, 4000);
-}
-
-// Show error message
-function showErrorMessage(message) {
-    const msg = document.createElement('div');
-    msg.className = 'fixed top-4 right-4 bg-red-500 text-white px-4 sm:px-6 py-3 rounded-lg shadow-lg z-50 flex items-center max-w-sm';
-    msg.innerHTML = `
+        document.body.appendChild(msg);
+        setTimeout(() => {
+            if (document.body.contains(msg)) {
+                document.body.removeChild(msg);
+            }
+        }, 4000);
+    }
+
+    // Show error message
+    function showErrorMessage(message) {
+        const msg = document.createElement('div');
+        msg.className = 'fixed top-4 right-4 bg-red-500 text-white px-4 sm:px-6 py-3 rounded-lg shadow-lg z-50 flex items-center max-w-sm';
+        msg.innerHTML = `
         <svg class="w-4 h-4 sm:w-5 sm:h-5 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
             <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
         </svg>
         <span class="text-sm">${message}</span>
     `;
-    document.body.appendChild(msg);
-    setTimeout(() => {
-        if (document.body.contains(msg)) {
-            document.body.removeChild(msg);
-        }
-    }, 5000);
-}
-
-// Initialize page
-document.addEventListener('DOMContentLoaded', () => {
-    // Initialize all seasons as collapsed except the first one
-    document.querySelectorAll('.season-content').forEach((content, index) => {
-        if (index > 0) {
-            content.style.display = 'none';
-            document.getElementById(`season-arrow-${index}`).style.transform = 'rotate(-90deg)';
-        }
+        document.body.appendChild(msg);
+        setTimeout(() => {
+            if (document.body.contains(msg)) {
+                document.body.removeChild(msg);
+            }
+        }, 5000);
+    }
+
+    // Initialize page
+    document.addEventListener('DOMContentLoaded', () => {
+        // Initialize all seasons as collapsed except the first one
+        document.querySelectorAll('.season-content').forEach((content, index) => {
+            if (index > 0) {
+                content.style.display = 'none';
+                document.getElementById(`season-arrow-${index}`).style.transform = 'rotate(-90deg)';
+            }
+        });
     });
-});
+
+    // Copy direct stream link to clipboard
+    function copyStreamLink(qualityId, fileName) {
+        // Try to find token from existing manifest URLs on the dashboard,
+        // fall back to prompting the user.
+        const base = window.location.origin;
+
+        // Ask user which token to use (pulled from cookies or prompt)
+        const token = getCopylinkToken();
+        if (!token) {
+            showErrorMessage('No API token found. Please copy the link from the Dashboard page.');
+            return;
+        }
+
+        const encodedName = encodeURIComponent(fileName || 'stream');
+        const url = `${base}/dl/${token}/${qualityId}/${encodedName}`;
+        navigator.clipboard.writeText(url).then(() => {
+            showSuccessMessage('Stream link copied to clipboard!');
+        }).catch(() => {
+            // Fallback: show the URL in a prompt
+            prompt('Copy this stream link:', url);
+        });
+    }
+
+    function getCopylinkToken() {
+        // Check sessionStorage / localStorage for a cached token
+        return sessionStorage.getItem('api_token') || localStorage.getItem('api_token') || null;
+    }
 </script>
 
 <style>
-.season-content {
-    transition: all 0.3s ease;
-}
-
-/* Better responsive design */
-.break-all {
-    word-break: break-all;
-    overflow-wrap: break-word;
-}
+    .season-content {
+        transition: all 0.3s ease;
+    }
+
+    .break-all {
+        word-break: break-all;
+        overflow-wrap: break-word;
+    }
+
+    @keyframes spin {
+        to {
+            transform: rotate(360deg);
+        }
+    }
+
+    .st-spin {
+        animation: spin 1s linear infinite;
+    }
 </style>
-{% endblock %}
+
+<!-- ===== SPEED TEST MODAL ===== -->
+<div id="speed-test-modal" class="fixed inset-0 z-50 hidden" aria-modal="true" role="dialog">
+    <!-- Backdrop -->
+    <div class="absolute inset-0 bg-black/60" style="backdrop-filter:blur(4px)" onclick="closeSpeedTest()"></div>
+
+    <!-- Panel -->
+    <div class="absolute left-1/2 top-1/2 w-full max-w-2xl mx-4 bg-white rounded-2xl shadow-2xl overflow-hidden"
+        style="transform:translate(-50%,-50%)">
+
+        <!-- Header -->
+        <div
+            class="flex items-center justify-between px-6 py-4 border-b border-gray-200 bg-gradient-to-r from-blue-600 to-indigo-600">
+            <div>
+                <h2 class="text-lg font-bold text-white">🚀 DC Speed Test</h2>
+                <p id="st-label" class="text-xs text-blue-100 mt-0.5"></p>
+            </div>
+            <button onclick="closeSpeedTest()"
+                class="text-white/70 hover:text-white text-3xl leading-none transition-colors">&times;</button>
+        </div>
+
+        <!-- Body -->
+        <div class="px-6 py-6 min-h-[200px]">
+            <!-- Spinner -->
+            <div id="st-spinner" class="flex flex-col items-center gap-4 py-10">
+                <div class="w-14 h-14 rounded-full border-4 border-blue-100 border-t-blue-600 st-spin"></div>
+                <p class="text-sm text-gray-500">Testing all DC clients simultaneously&hellip;</p>
+                <p class="text-xs text-gray-400">Downloading 100 MB from each bot client</p>
+            </div>
+
+            <!-- Results table -->
+            <div id="st-results" class="hidden">
+                <div class="overflow-x-auto rounded-xl border border-gray-200">
+                    <table class="w-full text-sm">
+                        <thead class="bg-gray-50 text-left">
+                            <tr>
+                                <th class="px-4 py-3 font-semibold text-gray-600 text-xs uppercase tracking-wider">Bot /
+                                    DC</th>
+                                <th class="px-4 py-3 font-semibold text-gray-600 text-xs uppercase tracking-wider">Ping
+                                </th>
+                                <th class="px-4 py-3 font-semibold text-gray-600 text-xs uppercase tracking-wider">Speed
+                                </th>
+                                <th class="px-4 py-3 font-semibold text-gray-600 text-xs uppercase tracking-wider">Time
+                                </th>
+                                <th class="px-4 py-3 font-semibold text-gray-600 text-xs uppercase tracking-wider">
+                                    Downloaded</th>
+                                <th class="px-4 py-3 font-semibold text-gray-600 text-xs uppercase tracking-wider">
+                                    Status</th>
+                            </tr>
+                        </thead>
+                        <tbody id="st-tbody" class="divide-y divide-gray-100 bg-white"></tbody>
+                    </table>
+                </div>
+                <p id="st-summary" class="text-xs text-gray-400 mt-3 text-right"></p>
+            </div>
+
+            <!-- Error banner -->
+            <div id="st-error" class="hidden bg-red-50 border border-red-200 rounded-xl px-4 py-3 text-sm text-red-700">
+            </div>
+        </div>
+
+        <!-- Footer -->
+        <div class="flex justify-end gap-3 px-6 py-4 border-t border-gray-100 bg-gray-50">
+            <button id="st-rerun-btn" onclick="rerunSpeedTest()"
+                class="hidden px-4 py-2 text-sm font-medium bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors">
+                🔄 Re-run
+            </button>
+            <button onclick="closeSpeedTest()"
+                class="px-4 py-2 text-sm font-medium border border-gray-300 rounded-lg hover:bg-gray-100 transition-colors">
+                Close
+            </button>
+        </div>
+    </div>
+</div>
+
+<script>
+    // ─── Speed Test JS ────────────────────────────────────────────────────────────
+    let _stQualityId = null;
+    let _stMediaType = null;
+    let _stLabel = null;
+
+    async function runSpeedTest(qualityId, mediaTypeArg, label) {
+        _stQualityId = qualityId;
+        _stMediaType = mediaTypeArg;
+        _stLabel = label;
+        _openModal(label);
+        await _exec();
+    }
+
+    async function rerunSpeedTest() {
+        if (!_stQualityId) return;
+        _resetUI(_stLabel);
+        await _exec();
+    }
+
+    function _openModal(label) {
+        document.getElementById('speed-test-modal').classList.remove('hidden');
+        document.body.style.overflow = 'hidden';
+        _resetUI(label);
+    }
+
+    function _resetUI(label) {
+        document.getElementById('st-label').textContent = label ? `File: ${label}` : '';
+        document.getElementById('st-spinner').classList.remove('hidden');
+        document.getElementById('st-results').classList.add('hidden');
+        document.getElementById('st-error').classList.add('hidden');
+        document.getElementById('st-rerun-btn').classList.add('hidden');
+        document.getElementById('st-tbody').innerHTML = '';
+        document.getElementById('st-summary').textContent = '';
+    }
+
+    function closeSpeedTest() {
+        document.getElementById('speed-test-modal').classList.add('hidden');
+        document.body.style.overflow = '';
+    }
+
+    function _pingClass(ms) {
+        if (ms === null) return 'text-gray-400';
+        if (ms < 100) return 'text-green-600 font-semibold';
+        if (ms < 300) return 'text-yellow-600 font-semibold';
+        return 'text-red-600 font-semibold';
+    }
+
+    function _speedClass(mbps) {
+        if (mbps === null) return 'text-gray-400';
+        if (mbps >= 20) return 'text-green-600 font-bold';
+        if (mbps >= 5) return 'text-yellow-600 font-bold';
+        return 'text-red-600 font-bold';
+    }
+
+    function _miniBar(value, max, color) {
+        if (!value || !max) return '';
+        const pct = Math.min(100, (value / max) * 100).toFixed(1);
+        return `<div class="w-full bg-gray-100 rounded-full h-1.5 mt-1">
+              <div class="${color} h-1.5 rounded-full transition-all" style="width:${pct}%"></div>
+            </div>`;
+    }
+
+    async function _exec() {
+        const params = new URLSearchParams({
+            quality_id: _stQualityId,
+            tmdb_id: tmdbId,
+            db_index: dbIndex,
+            media_type: mediaType   // from template context (movie/tv)
+        });
+
+        // Close any old connection
+        if (window._stEventSource) {
+            window._stEventSource.close();
+            window._stEventSource = null;
+        }
+
+        let maxSpeed = 1;
+        let completedCount = 0;
+        let totalCount = 0;
+        const allResults = [];
+        const pendingRows = {};
+
+        const es = new EventSource(`/api/system/speedtest/stream?${params}`);
+        window._stEventSource = es;
+
+        function updateSummary() {
+            const best = allResults.filter(r => r.speed_mbps).sort((a, b) => b.speed_mbps - a.speed_mbps)[0];
+            const summaryEl = document.getElementById('st-summary');
+            if (best) {
+                summaryEl.textContent = `🏆 Fastest: DC ${best.dc_id} — ${best.speed_mbps.toFixed(2)} MB/s  |  ${completedCount}/${totalCount} client(s) done`;
+            } else {
+                summaryEl.textContent = `${completedCount}/${totalCount} client(s) done`;
+            }
+        }
+
+        es.onmessage = (e) => {
+            let msg;
+            try { msg = JSON.parse(e.data); } catch { return; }
+
+            if (msg.type === 'error') {
+                es.close();
+                document.getElementById('st-spinner').classList.add('hidden');
+                document.getElementById('st-error').textContent = `Speed test stream error: ${msg.message}`;
+                document.getElementById('st-error').classList.remove('hidden');
+                document.getElementById('st-rerun-btn').classList.remove('hidden');
+                return;
+            }
+
+            if (msg.type === 'start') {
+                totalCount = msg.total;
+                document.getElementById('st-spinner').classList.add('hidden');
+                document.getElementById('st-results').classList.remove('hidden');
+
+                if (msg.target_dc && msg.target_dc !== "?") {
+                    document.getElementById('st-label').innerHTML += ` &nbsp;|&nbsp; Target DC: <span class="text-white font-semibold">${msg.target_dc}</span>`;
+                }
+
+                const tbody = document.getElementById('st-tbody');
+                tbody.innerHTML = '';
+                for (let i = 0; i < totalCount; i++) {
+                    const tr = document.createElement('tr');
+                    tr.className = 'animate-pulse';
+                    tr.innerHTML = `
+                        <td class="px-4 py-3 font-medium text-gray-400">🔄 Bot ${i + 1}</td>
+                        <td class="px-4 py-3"><span class="text-gray-300">testing…</span></td>
+                        <td class="px-4 py-3"><span class="text-gray-300">testing…</span></td>
+                        <td class="px-4 py-3 text-gray-300">—</td>
+                        <td class="px-4 py-3 text-gray-300">—</td>
+                        <td class="px-4 py-3"><span class="px-2 py-0.5 rounded-full text-xs bg-gray-100 text-gray-400">Pending</span></td>`;
+                    tbody.appendChild(tr);
+                    pendingRows[i] = tr;
+                }
+                updateSummary();
+            }
+
+            if (msg.type === 'progress') {
+                const r = msg.data;
+                const tr = pendingRows[r.client_index];
+                if (tr) {
+                    maxSpeed = Math.max(maxSpeed, r.speed_mbps || 0, 1);
+
+                    const ping = r.ping_ms !== null ? `<span class="${_pingClass(r.ping_ms)}">${r.ping_ms} ms</span>` : '<span class="text-gray-400">—</span>';
+                    const speed = r.speed_mbps !== null
+                        ? `<span class="${_speedClass(r.speed_mbps)}">${r.speed_mbps.toFixed(2)} MB/s</span>
+                           ${_miniBar(r.speed_mbps, maxSpeed, r.speed_mbps >= 20 ? 'bg-green-500' : r.speed_mbps >= 5 ? 'bg-yellow-400' : 'bg-red-400')}`
+                        : '<span class="text-gray-400">—</span>';
+                    const taken = r.time_taken_sec !== null ? `${r.time_taken_sec.toFixed(2)}s` : '—';
+                    const bytes = r.bytes_downloaded ? `${(r.bytes_downloaded / 1048576).toFixed(2)} MB` : '—';
+
+                    // Update the innerHTML of the pending row cells
+                    tr.innerHTML = `
+                        <td class="px-4 py-3 font-medium text-gray-700">🔄 Bot ${r.client_index + 1} &nbsp;<span class="text-xs text-gray-400">(DC&nbsp;${r.dc_id})</span></td>
+                        <td class="px-4 py-3">${ping}</td>
+                        <td class="px-4 py-3">${speed}</td>
+                        <td class="px-4 py-3 text-gray-600 text-sm">${taken}</td>
+                        <td class="px-4 py-3 text-gray-500 text-xs">${bytes}</td>
+                        <td class="px-4 py-3"><span class="px-2 py-0.5 rounded-full text-xs bg-blue-100 text-blue-700 animate-pulse">Running…</span></td>`;
+                }
+            }
+
+            if (msg.type === 'result') {
+                completedCount = msg.completed;
+                totalCount = msg.total;
+                const r = msg.data;
+                allResults.push(r);
+
+                maxSpeed = Math.max(maxSpeed, r.speed_mbps || 0, 1);
+
+                const isErr = !!r.error && !r.speed_mbps;
+                // Currently best logic isn't perfect until all finish, but we try
+                const medal = '';
+                const dc = `Bot ${r.client_index + 1} &nbsp;<span class="text-xs text-gray-400">(DC&nbsp;${r.dc_id})</span>`;
+                const ping = r.ping_ms !== null ? `<span class="${_pingClass(r.ping_ms)}">${r.ping_ms} ms</span>` : '<span class="text-gray-400">—</span>';
+                const speed = r.speed_mbps !== null
+                    ? `<span class="${_speedClass(r.speed_mbps)}">${r.speed_mbps.toFixed(2)} MB/s</span>
+                       ${_miniBar(r.speed_mbps, maxSpeed, r.speed_mbps >= 20 ? 'bg-green-500' : r.speed_mbps >= 5 ? 'bg-yellow-400' : 'bg-red-400')}`
+                    : '<span class="text-gray-400">—</span>';
+                const taken = r.time_taken_sec !== null ? `${r.time_taken_sec.toFixed(2)}s` : '—';
+                const bytes = r.bytes_downloaded ? `${(r.bytes_downloaded / 1048576).toFixed(2)} MB` : '—';
+                const badge = isErr
+                    ? `<span class="px-2 py-0.5 rounded-full text-xs font-medium bg-red-100 text-red-700">Error</span>`
+                    : `<span class="px-2 py-0.5 rounded-full text-xs font-medium bg-green-100 text-green-700">✓ OK</span>`;
+
+                const tr = document.createElement('tr');
+                tr.className = `hover:bg-blue-50 transition-colors ${isErr ? 'opacity-60' : ''}`;
+                tr.innerHTML = `
+                    <td class="px-4 py-3 font-medium">${medal}${dc}</td>
+                    <td class="px-4 py-3">${ping}</td>
+                    <td class="px-4 py-3">${speed}${isErr ? `<div class="text-xs text-red-500 mt-1">${r.error}</div>` : ''}</td>
+                    <td class="px-4 py-3 text-gray-600 text-sm">${taken}</td>
+                    <td class="px-4 py-3 text-gray-500 text-xs">${bytes}</td>
+                    <td class="px-4 py-3">${badge}</td>`;
+
+                if (pendingRows[r.client_index]) {
+                    pendingRows[r.client_index].replaceWith(tr);
+                    delete pendingRows[r.client_index];
+                } else {
+                    document.getElementById('st-tbody').appendChild(tr);
+                }
+
+                updateSummary();
+            }
+
+            if (msg.type === 'done') {
+                es.close();
+                window._stEventSource = null;
+
+                // Re-sort everything to put fastest at the top with a medal
+                allResults.sort((a, b) => (b.speed_mbps || 0) - (a.speed_mbps || 0));
+
+                const tbody = document.getElementById('st-tbody');
+                tbody.innerHTML = '';
+
+                for (let i = 0; i < allResults.length; i++) {
+                    const r = allResults[i];
+                    const isErr = !!r.error && !r.speed_mbps;
+                    const medal = i === 0 && !isErr ? '🥇 ' : '';
+                    const dc = `Bot ${r.client_index + 1} &nbsp;<span class="text-xs text-gray-400">(DC&nbsp;${r.dc_id})</span>`;
+                    const ping = r.ping_ms !== null ? `<span class="${_pingClass(r.ping_ms)}">${r.ping_ms} ms</span>` : '<span class="text-gray-400">—</span>';
+                    const speed = r.speed_mbps !== null
+                        ? `<span class="${_speedClass(r.speed_mbps)}">${r.speed_mbps.toFixed(2)} MB/s</span>
+                           ${_miniBar(r.speed_mbps, maxSpeed, r.speed_mbps >= 20 ? 'bg-green-500' : r.speed_mbps >= 5 ? 'bg-yellow-400' : 'bg-red-400')}`
+                        : '<span class="text-gray-400">—</span>';
+                    const taken = r.time_taken_sec !== null ? `${r.time_taken_sec.toFixed(2)}s` : '—';
+                    const bytes = r.bytes_downloaded ? `${(r.bytes_downloaded / 1048576).toFixed(2)} MB` : '—';
+                    const badge = isErr
+                        ? `<span class="px-2 py-0.5 rounded-full text-xs font-medium bg-red-100 text-red-700">Error</span>`
+                        : `<span class="px-2 py-0.5 rounded-full text-xs font-medium bg-green-100 text-green-700">✓ OK</span>`;
+
+                    const tr = document.createElement('tr');
+                    tr.className = `hover:bg-blue-50 transition-colors ${isErr ? 'opacity-60' : ''}`;
+                    tr.innerHTML = `
+                        <td class="px-4 py-3 font-medium">${medal}${dc}</td>
+                        <td class="px-4 py-3">${ping}</td>
+                        <td class="px-4 py-3">${speed}${isErr ? `<div class="text-xs text-red-500 mt-1">${r.error}</div>` : ''}</td>
+                        <td class="px-4 py-3 text-gray-600 text-sm">${taken}</td>
+                        <td class="px-4 py-3 text-gray-500 text-xs">${bytes}</td>
+                        <td class="px-4 py-3">${badge}</td>`;
+                    tbody.appendChild(tr);
+                }
+
+                document.getElementById('st-rerun-btn').classList.remove('hidden');
+                updateSummary();
+            }
+        };
+
+        es.onerror = (err) => {
+            es.close();
+            window._stEventSource = null;
+            if (completedCount === 0) {
+                document.getElementById('st-spinner').classList.add('hidden');
+                document.getElementById('st-error').textContent = 'Live tracking connection failed or interrupted.';
+                document.getElementById('st-error').classList.remove('hidden');
+            }
+            document.getElementById('st-rerun-btn').classList.remove('hidden');
+        };
+    }
+
+    // Close on Escape key
+    document.addEventListener('keydown', e => { if (e.key === 'Escape') closeSpeedTest(); });
+</script>
+
+{% endblock %}

Backend/fastapi/templates/media_management.html

@@ -10,72 +10,75 @@
             <h1 class="text-3xl font-bold">Media Management</h1>
             <p class="theme-text-secondary mt-2">Manage your movie and TV show collections</p>
         </div>
-        
+
         <div class="flex space-x-2">
-            <a href="/media/manage?media_type=movie" 
-               class="px-4 py-2 rounded-md transition-colors text-sm font-medium {% if media_type == 'movie' %}theme-primary text-white{% else %}theme-card border hover:bg-gray-50{% endif %}">
+            <a href="/media/manage?media_type=movie"
+                class="px-4 py-2 rounded-md transition-colors text-sm font-medium {% if media_type == 'movie' %}bg-blue-600 text-white{% else %}theme-card border hover:bg-gray-50{% endif %}">
                 Movies
             </a>
-            <a href="/media/manage?media_type=tv" 
-               class="px-4 py-2 rounded-md transition-colors text-sm font-medium {% if media_type == 'tv' %}theme-primary text-white{% else %}theme-card border hover:bg-gray-50{% endif %}">
+            <a href="/media/manage?media_type=tv"
+                class="px-4 py-2 rounded-md transition-colors text-sm font-medium {% if media_type == 'tv' %}bg-blue-600 text-white{% else %}theme-card border hover:bg-gray-50{% endif %}">
                 TV Shows
             </a>
         </div>
     </div>
-    
+
     <!-- Search and Filters -->
     <div class="theme-card p-6 rounded-lg shadow mb-8">
         <div class="flex flex-col md:flex-row gap-4">
             <div class="flex-1">
-                <input type="text" id="search-input" placeholder="Search {{ media_type }}s by title..." 
-                       class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent text-sm">
+                <input type="text" id="search-input" placeholder="Search {{ media_type }}s by title..."
+                    class="w-full px-4 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-primary focus:border-transparent text-sm">
             </div>
             <div class="flex gap-2">
-                <button onclick="searchMedia()" 
-                        class="theme-primary text-white px-6 py-2 rounded-md hover:opacity-90 transition-opacity text-sm font-medium">
+                <button onclick="searchMedia()"
+                    class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-2 rounded-md transition-colors text-sm font-medium shadow-sm">
                     Search
                 </button>
-                <button onclick="clearSearch()" 
-                        class="border border-gray-300 px-6 py-2 rounded-md hover:bg-gray-50 transition-colors text-sm font-medium">
+                <button onclick="clearSearch()"
+                    class="border border-gray-300 px-6 py-2 rounded-md hover:bg-gray-50 transition-colors text-sm font-medium">
                     Clear
                 </button>
             </div>
         </div>
     </div>
-    
+
     <!-- Loading Indicator -->
     <div id="loading" class="text-center py-12 hidden">
         <div class="inline-block animate-spin rounded-full h-8 w-8 border-b-2 border-primary mb-4"></div>
         <p class="theme-text-secondary">Loading {{ media_type }}s...</p>
     </div>
-    
+
     <!-- Error Display -->
     <div id="error-display" class="hidden mb-8">
         <div class="theme-card p-6 rounded-lg shadow border-l-4 border-red-500">
             <div class="flex items-center mb-4">
                 <svg class="h-6 w-6 text-red-500 mr-2" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4c-.77-.833-1.996-.833-2.764 0L3.732 16.5c-.77.833.192 2.5 1.732 2.5z" />
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                        d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4c-.77-.833-1.996-.833-2.764 0L3.732 16.5c-.77.833.192 2.5 1.732 2.5z" />
                 </svg>
                 <h3 class="text-lg font-semibold text-red-700">Error Loading Media</h3>
             </div>
             <p id="error-message" class="text-red-600 mb-4"></p>
-            <button onclick="retryLoad()" 
-                    class="theme-primary text-white px-4 py-2 rounded-md hover:opacity-90 transition-opacity text-sm">
+            <button onclick="retryLoad()"
+                class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-md transition-colors text-sm shadow-sm">
                 Try Again
             </button>
         </div>
     </div>
-    
+
     <!-- Media Grid -->
-    <div id="media-grid" class="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6 2xl:grid-cols-8 gap-4 mb-8">
+    <div id="media-grid"
+        class="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 xl:grid-cols-6 2xl:grid-cols-8 gap-4 mb-8">
         <!-- Media items will be loaded here via JavaScript -->
     </div>
-    
+
     <!-- No Results Message -->
     <div id="no-results" class="text-center py-12 hidden">
         <div class="theme-card p-8 rounded-lg shadow">
             <svg class="mx-auto h-16 w-16 text-gray-300 mb-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M7 4V2a1 1 0 011-1h8a1 1 0 011 1v2h4a1 1 0 110 2h-1v12a2 2 0 01-2 2H6a2 2 0 01-2-2V6H3a1 1 0 110-2h4zM9 6v10h6V6H9z"/>
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                    d="M7 4V2a1 1 0 011-1h8a1 1 0 011 1v2h4a1 1 0 110 2h-1v12a2 2 0 01-2 2H6a2 2 0 01-2-2V6H3a1 1 0 110-2h4zM9 6v10h6V6H9z" />
             </svg>
             <h3 class="text-lg font-semibold theme-text-secondary mb-2">No {{ media_type }}s found</h3>
             <p class="theme-text-secondary text-sm mb-4">
@@ -85,21 +88,22 @@
                 No TV shows match your search criteria
                 {% endif %}
             </p>
-            <button onclick="clearSearch()" 
-                    class="theme-primary text-white px-4 py-2 rounded-md hover:opacity-90 transition-opacity text-sm">
+            <button onclick="clearSearch()"
+                class="bg-blue-600 hover:bg-blue-700 text-white px-4 py-2 rounded-md transition-colors text-sm shadow-sm">
                 Show All {{ media_type|title }}s
             </button>
         </div>
     </div>
-    
+
     <!-- Pagination -->
     <div id="pagination" class="flex justify-center items-center space-x-2 mt-8 hidden">
         <!-- Pagination will be loaded here via JavaScript -->
     </div>
-    
+
     <!-- Media Info -->
     <div id="media-info" class="theme-card p-4 rounded-lg shadow mt-6 hidden">
-        <div class="flex flex-col sm:flex-row justify-between items-start sm:items-center gap-2 text-sm theme-text-secondary">
+        <div
+            class="flex flex-col sm:flex-row justify-between items-start sm:items-center gap-2 text-sm theme-text-secondary">
             <span id="results-info"></span>
             <span id="db-info"></span>
         </div>
@@ -107,112 +111,112 @@
 </div>
 
 <script>
-let currentPage = 1;
-let currentSearch = '';
-let isLoading = false;
-const mediaType = '{{ media_type }}';
-
-// Show loading state
-function showLoading() {
-    isLoading = true;
-    document.getElementById('loading').classList.remove('hidden');
-    document.getElementById('media-grid').classList.add('hidden');
-    document.getElementById('no-results').classList.add('hidden');
-    document.getElementById('pagination').classList.add('hidden');
-    document.getElementById('media-info').classList.add('hidden');
-    document.getElementById('error-display').classList.add('hidden');
-}
-
-// Hide loading state
-function hideLoading() {
-    isLoading = false;
-    document.getElementById('loading').classList.add('hidden');
-    document.getElementById('media-grid').classList.remove('hidden');
-}
-
-// Show error state
-function showError(message) {
-    document.getElementById('error-message').textContent = message;
-    document.getElementById('error-display').classList.remove('hidden');
-    document.getElementById('loading').classList.add('hidden');
-    document.getElementById('media-grid').classList.add('hidden');
-    document.getElementById('no-results').classList.add('hidden');
-}
-
-// Load media with proper error handling
-async function loadMedia(page = 1, search = '') {
-    if (isLoading) return; // Prevent multiple simultaneous requests
-    
-    showLoading();
-    currentPage = page;
-    currentSearch = search;
-    
-    try {
-        const url = `/api/media/list?media_type=${mediaType}&page=${page}&page_size=24&search=${encodeURIComponent(search)}`;
-        console.log('Fetching:', url);
-        
-        const response = await fetch(url, {
-            method: 'GET',
-            credentials: 'same-origin',
-            headers: {
-                'Accept': 'application/json',
-                'Content-Type': 'application/json'
+    let currentPage = 1;
+    let currentSearch = '';
+    let isLoading = false;
+    const mediaType = '{{ media_type }}';
+
+    // Show loading state
+    function showLoading() {
+        isLoading = true;
+        document.getElementById('loading').classList.remove('hidden');
+        document.getElementById('media-grid').classList.add('hidden');
+        document.getElementById('no-results').classList.add('hidden');
+        document.getElementById('pagination').classList.add('hidden');
+        document.getElementById('media-info').classList.add('hidden');
+        document.getElementById('error-display').classList.add('hidden');
+    }
+
+    // Hide loading state
+    function hideLoading() {
+        isLoading = false;
+        document.getElementById('loading').classList.add('hidden');
+        document.getElementById('media-grid').classList.remove('hidden');
+    }
+
+    // Show error state
+    function showError(message) {
+        document.getElementById('error-message').textContent = message;
+        document.getElementById('error-display').classList.remove('hidden');
+        document.getElementById('loading').classList.add('hidden');
+        document.getElementById('media-grid').classList.add('hidden');
+        document.getElementById('no-results').classList.add('hidden');
+    }
+
+    // Load media with proper error handling
+    async function loadMedia(page = 1, search = '') {
+        if (isLoading) return; // Prevent multiple simultaneous requests
+
+        showLoading();
+        currentPage = page;
+        currentSearch = search;
+
+        try {
+            const url = `/api/media/list?media_type=${mediaType}&page=${page}&page_size=24&search=${encodeURIComponent(search)}`;
+            console.log('Fetching:', url);
+
+            const response = await fetch(url, {
+                method: 'GET',
+                credentials: 'same-origin',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            console.log('Response status:', response.status);
+
+            if (!response.ok) {
+                if (response.status === 401) {
+                    window.location.href = '/login';
+                    return;
+                }
+                throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
             }
-        });
-        
-        console.log('Response status:', response.status);
-        
-        if (!response.ok) {
-            if (response.status === 401) {
-                window.location.href = '/login';
+
+            const data = await response.json();
+            console.log('Response data:', data);
+
+            hideLoading();
+
+            const grid = document.getElementById('media-grid');
+            const mediaKey = mediaType === 'movie' ? 'movies' : 'tv_shows';
+            const mediaItems = data[mediaKey] || [];
+
+            if (mediaItems.length === 0) {
+                grid.innerHTML = '';
+                document.getElementById('no-results').classList.remove('hidden');
+                document.getElementById('pagination').classList.add('hidden');
+                document.getElementById('media-info').classList.add('hidden');
                 return;
             }
-            throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
-        }
-        
-        const data = await response.json();
-        console.log('Response data:', data);
-        
-        hideLoading();
-        
-        const grid = document.getElementById('media-grid');
-        const mediaKey = mediaType === 'movie' ? 'movies' : 'tv_shows';
-        const mediaItems = data[mediaKey] || [];
-        
-        if (mediaItems.length === 0) {
-            grid.innerHTML = '';
-            document.getElementById('no-results').classList.remove('hidden');
-            document.getElementById('pagination').classList.add('hidden');
-            document.getElementById('media-info').classList.add('hidden');
-            return;
+
+            document.getElementById('no-results').classList.add('hidden');
+
+            // Render media items
+            grid.innerHTML = mediaItems.map(item => createMediaCard(item)).join('');
+
+            // Update pagination
+            updatePagination(data.current_page || page, data.total_pages || 1);
+
+            // Update info
+            updateMediaInfo(data);
+
+        } catch (error) {
+            console.error('Error loading media:', error);
+            hideLoading();
+            showError(`Failed to load ${mediaType}s: ${error.message}`);
         }
-        
-        document.getElementById('no-results').classList.add('hidden');
-        
-        // Render media items
-        grid.innerHTML = mediaItems.map(item => createMediaCard(item)).join('');
-        
-        // Update pagination
-        updatePagination(data.current_page || page, data.total_pages || 1);
-        
-        // Update info
-        updateMediaInfo(data);
-        
-    } catch (error) {
-        console.error('Error loading media:', error);
-        hideLoading();
-        showError(`Failed to load ${mediaType}s: ${error.message}`);
     }
-}
-
-// Create media card HTML
-function createMediaCard(item) {
-    const title = item.title || item.name || 'Unknown Title';
-    const year = item.release_year || 'Unknown Year';
-    const rating = item.rating ? `⭐ ${parseFloat(item.rating).toFixed(1)}` : '';
-    const poster = item.poster || 'https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image';
-    
-    return `
+
+    // Create media card HTML
+    function createMediaCard(item) {
+        const title = item.title || item.name || 'Unknown Title';
+        const year = item.release_year || 'Unknown Year';
+        const rating = item.rating ? `⭐ ${parseFloat(item.rating).toFixed(1)}` : '';
+        const poster = item.poster || 'https://via.placeholder.com/300x450/e5e7eb/9ca3af?text=No+Image';
+
+        return `
         <div class="theme-card rounded-lg shadow hover:shadow-lg transition-all duration-300 group overflow-hidden">
             <div class="relative">
                 <div class="aspect-w-2 aspect-h-3">
@@ -245,232 +249,232 @@ function createMediaCard(item) {
             </div>
         </div>
     `;
-}
-
-// Update pagination
-function updatePagination(currentPage, totalPages) {
-    const pagination = document.getElementById('pagination');
-    
-    if (totalPages <= 1) {
-        pagination.classList.add('hidden');
-        return;
     }
-    
-    pagination.classList.remove('hidden');
-    let paginationHTML = '';
-    
-    // Previous button
-    if (currentPage > 1) {
-        paginationHTML += `
+
+    // Update pagination
+    function updatePagination(currentPage, totalPages) {
+        const pagination = document.getElementById('pagination');
+
+        if (totalPages <= 1) {
+            pagination.classList.add('hidden');
+            return;
+        }
+
+        pagination.classList.remove('hidden');
+        let paginationHTML = '';
+
+        // Previous button
+        if (currentPage > 1) {
+            paginationHTML += `
             <button onclick="loadMedia(${currentPage - 1}, '${currentSearch}')" 
                     class="px-3 py-2 border rounded-md hover:bg-gray-50 transition-colors text-sm">
                 Previous
             </button>
         `;
-    }
-    
-    // Page numbers
-    const startPage = Math.max(1, currentPage - 2);
-    const endPage = Math.min(totalPages, currentPage + 2);
-    
-    // First page
-    if (startPage > 1) {
-        paginationHTML += `
+        }
+
+        // Page numbers
+        const startPage = Math.max(1, currentPage - 2);
+        const endPage = Math.min(totalPages, currentPage + 2);
+
+        // First page
+        if (startPage > 1) {
+            paginationHTML += `
             <button onclick="loadMedia(1, '${currentSearch}')" 
                     class="px-3 py-2 border rounded-md hover:bg-gray-50 transition-colors text-sm">
                 1
             </button>
         `;
-        if (startPage > 2) {
-            paginationHTML += `<span class="px-3 py-2 text-sm">...</span>`;
+            if (startPage > 2) {
+                paginationHTML += `<span class="px-3 py-2 text-sm">...</span>`;
+            }
         }
-    }
-    
-    // Page range
-    for (let i = startPage; i <= endPage; i++) {
-        const isActive = i === currentPage;
-        paginationHTML += `
+
+        // Page range
+        for (let i = startPage; i <= endPage; i++) {
+            const isActive = i === currentPage;
+            paginationHTML += `
             <button onclick="loadMedia(${i}, '${currentSearch}')" 
-                    class="px-3 py-2 border rounded-md transition-colors text-sm ${
-                        isActive ? 'theme-primary text-white border-primary' : 'hover:bg-gray-50'
-                    }">
+                    class="px-3 py-2 border rounded-md transition-colors text-sm ${isActive ? 'bg-blue-600 text-white border-blue-600' : 'hover:bg-gray-50'
+                }">
                 ${i}
             </button>
         `;
-    }
-    
-    // Last page
-    if (endPage < totalPages) {
-        if (endPage < totalPages - 1) {
-            paginationHTML += `<span class="px-3 py-2 text-sm">...</span>`;
         }
-        paginationHTML += `
+
+        // Last page
+        if (endPage < totalPages) {
+            if (endPage < totalPages - 1) {
+                paginationHTML += `<span class="px-3 py-2 text-sm">...</span>`;
+            }
+            paginationHTML += `
             <button onclick="loadMedia(${totalPages}, '${currentSearch}')" 
                     class="px-3 py-2 border rounded-md hover:bg-gray-50 transition-colors text-sm">
                 ${totalPages}
             </button>
         `;
-    }
-    
-    // Next button
-    if (currentPage < totalPages) {
-        paginationHTML += `
+        }
+
+        // Next button
+        if (currentPage < totalPages) {
+            paginationHTML += `
             <button onclick="loadMedia(${currentPage + 1}, '${currentSearch}')" 
                     class="px-3 py-2 border rounded-md hover:bg-gray-50 transition-colors text-sm">
                 Next
             </button>
         `;
+        }
+
+        pagination.innerHTML = paginationHTML;
+    }
+
+    // Update media info display
+    function updateMediaInfo(data) {
+        const mediaInfo = document.getElementById('media-info');
+        const resultsInfo = document.getElementById('results-info');
+        const dbInfo = document.getElementById('db-info');
+
+        const startItem = ((data.current_page - 1) * 24) + 1;
+        const endItem = Math.min(data.current_page * 24, data.total_count);
+
+        resultsInfo.textContent = `Showing ${startItem}-${endItem} of ${data.total_count} ${mediaType}s`;
+
+        if (data.databases_checked && data.databases_checked.length > 0) {
+            dbInfo.textContent = `Database${data.databases_checked.length > 1 ? 's' : ''}: ${data.databases_checked.join(', ')}`;
+        }
+
+        mediaInfo.classList.remove('hidden');
+    }
+
+    // Search functionality
+    function searchMedia() {
+        const searchInput = document.getElementById('search-input');
+        const search = searchInput.value.trim();
+        loadMedia(1, search);
     }
-    
-    pagination.innerHTML = paginationHTML;
-}
-
-// Update media info display
-function updateMediaInfo(data) {
-    const mediaInfo = document.getElementById('media-info');
-    const resultsInfo = document.getElementById('results-info');
-    const dbInfo = document.getElementById('db-info');
-    
-    const startItem = ((data.current_page - 1) * 24) + 1;
-    const endItem = Math.min(data.current_page * 24, data.total_count);
-    
-    resultsInfo.textContent = `Showing ${startItem}-${endItem} of ${data.total_count} ${mediaType}s`;
-    
-    if (data.databases_checked && data.databases_checked.length > 0) {
-        dbInfo.textContent = `Database${data.databases_checked.length > 1 ? 's' : ''}: ${data.databases_checked.join(', ')}`;
+
+    // Clear search
+    function clearSearch() {
+        document.getElementById('search-input').value = '';
+        loadMedia(1, '');
+    }
+
+    // Retry load function
+    function retryLoad() {
+        loadMedia(currentPage, currentSearch);
     }
-    
-    mediaInfo.classList.remove('hidden');
-}
-
-// Search functionality
-function searchMedia() {
-    const searchInput = document.getElementById('search-input');
-    const search = searchInput.value.trim();
-    loadMedia(1, search);
-}
-
-// Clear search
-function clearSearch() {
-    document.getElementById('search-input').value = '';
-    loadMedia(1, '');
-}
-
-// Retry load function
-function retryLoad() {
-    loadMedia(currentPage, currentSearch);
-}
-
-// Delete media with confirmation
-async function deleteMedia(tmdbId, dbIndex, title) {
-    if (!confirm(`Are you sure you want to delete "${title}"?\n\nThis action cannot be undone.`)) return;
-    
-    try {
-        const response = await fetch(`/api/media/delete?tmdb_id=${tmdbId}&db_index=${dbIndex}&media_type=${mediaType}`, {
-            method: 'DELETE',
-            credentials: 'same-origin',
-            headers: {
-                'Accept': 'application/json',
-                'Content-Type': 'application/json'
+
+    // Delete media with confirmation
+    async function deleteMedia(tmdbId, dbIndex, title) {
+        if (!confirm(`Are you sure you want to delete "${title}"?\n\nThis action cannot be undone.`)) return;
+
+        try {
+            const response = await fetch(`/api/media/delete?tmdb_id=${tmdbId}&db_index=${dbIndex}&media_type=${mediaType}`, {
+                method: 'DELETE',
+                credentials: 'same-origin',
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            if (response.ok) {
+                // Show success message briefly
+                const successMsg = document.createElement('div');
+                successMsg.className = 'fixed top-4 right-4 bg-green-500 text-white px-4 py-2 rounded-md shadow-lg z-50';
+                successMsg.textContent = `"${title}" deleted successfully`;
+                document.body.appendChild(successMsg);
+
+                setTimeout(() => {
+                    document.body.removeChild(successMsg);
+                }, 3000);
+
+                // Reload current page
+                loadMedia(currentPage, currentSearch);
+            } else {
+                const error = await response.json();
+                alert(`Error deleting "${title}": ${error.detail || 'Unknown error'}`);
             }
-        });
-        
-        if (response.ok) {
-            // Show success message briefly
-            const successMsg = document.createElement('div');
-            successMsg.className = 'fixed top-4 right-4 bg-green-500 text-white px-4 py-2 rounded-md shadow-lg z-50';
-            successMsg.textContent = `"${title}" deleted successfully`;
-            document.body.appendChild(successMsg);
-            
-            setTimeout(() => {
-                document.body.removeChild(successMsg);
-            }, 3000);
-            
-            // Reload current page
-            loadMedia(currentPage, currentSearch);
-        } else {
-            const error = await response.json();
-            alert(`Error deleting "${title}": ${error.detail || 'Unknown error'}`);
+        } catch (error) {
+            console.error('Error deleting media:', error);
+            alert(`Error deleting "${title}": ${error.message}`);
         }
-    } catch (error) {
-        console.error('Error deleting media:', error);
-        alert(`Error deleting "${title}": ${error.message}`);
     }
-}
-
-// Initialize page
-document.addEventListener('DOMContentLoaded', () => {
-    // Load media on page load
-    loadMedia();
-    
-    // Add enter key listener to search input
-    document.getElementById('search-input').addEventListener('keypress', (e) => {
-        if (e.key === 'Enter') {
-            e.preventDefault();
-            searchMedia();
-        }
-    });
-    
-    // Add input event for real-time search (with debouncing)
-    let searchTimeout;
-    document.getElementById('search-input').addEventListener('input', (e) => {
-        clearTimeout(searchTimeout);
-        const searchValue = e.target.value.trim();
-        
-        if (searchValue.length === 0) {
-            searchTimeout = setTimeout(() => {
-                loadMedia(1, '');
-            }, 300);
-        }
+
+    // Initialize page
+    document.addEventListener('DOMContentLoaded', () => {
+        // Load media on page load
+        loadMedia();
+
+        // Add enter key listener to search input
+        document.getElementById('search-input').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') {
+                e.preventDefault();
+                searchMedia();
+            }
+        });
+
+        // Add input event for real-time search (with debouncing)
+        let searchTimeout;
+        document.getElementById('search-input').addEventListener('input', (e) => {
+            clearTimeout(searchTimeout);
+            const searchValue = e.target.value.trim();
+
+            if (searchValue.length === 0) {
+                searchTimeout = setTimeout(() => {
+                    loadMedia(1, '');
+                }, 300);
+            }
+        });
     });
-});
 </script>
 
 <style>
-.line-clamp-2 {
-    display: -webkit-box;
-    -webkit-line-clamp: 2;
-    -webkit-box-orient: vertical;
-    overflow: hidden;
-}
-
-.aspect-w-2 {
-    position: relative;
-    padding-bottom: 150%; /* 2:3 aspect ratio */
-}
-
-.aspect-w-2 > img {
-    position: absolute;
-    height: 100%;
-    width: 100%;
-    top: 0;
-    right: 0;
-    bottom: 0;
-    left: 0;
-}
-
-@media (max-width: 640px) {
-    .grid {
-        grid-template-columns: repeat(2, minmax(0, 1fr));
-        gap: 0.75rem;
+    .line-clamp-2 {
+        display: -webkit-box;
+        -webkit-line-clamp: 2;
+        -webkit-box-orient: vertical;
+        overflow: hidden;
+    }
+
+    .aspect-w-2 {
+        position: relative;
+        padding-bottom: 150%;
+        /* 2:3 aspect ratio */
+    }
+
+    .aspect-w-2>img {
+        position: absolute;
+        height: 100%;
+        width: 100%;
+        top: 0;
+        right: 0;
+        bottom: 0;
+        left: 0;
     }
-}
 
-@media (min-width: 1536px) {
-    .grid {
-        grid-template-columns: repeat(8, minmax(0, 1fr));
+    @media (max-width: 640px) {
+        .grid {
+            grid-template-columns: repeat(2, minmax(0, 1fr));
+            gap: 0.75rem;
+        }
+    }
+
+    @media (min-width: 1536px) {
+        .grid {
+            grid-template-columns: repeat(8, minmax(0, 1fr));
+        }
     }
-}
 
-/* Loading animation */
-@keyframes spin {
-    to {
-        transform: rotate(360deg);
+    /* Loading animation */
+    @keyframes spin {
+        to {
+            transform: rotate(360deg);
+        }
     }
-}
 
-.animate-spin {
-    animation: spin 1s linear infinite;
-}
+    .animate-spin {
+        animation: spin 1s linear infinite;
+    }
 </style>
-{% endblock %}
+{% endblock %}

Backend/fastapi/templates/public_status.html

@@ -9,7 +9,7 @@
         <h1 class="text-3xl font-bold">System Status</h1>
         <p class="theme-text-secondary mt-2">Current status of Telegram Stremio services</p>
     </div>
-    
+
     <!-- Status Cards -->
     <div class="grid grid-cols-1 md:grid-cols-3 gap-6 mb-8">
         <div class="theme-card p-6 rounded-lg shadow text-center">
@@ -19,7 +19,7 @@
             <h3 class="text-lg font-semibold mb-2">Backend Status</h3>
             <p class="text-green-600 font-medium">{{ stats.status|title }}</p>
         </div>
-        
+
         <div class="theme-card p-6 rounded-lg shadow text-center">
             <div class="w-16 h-16 mx-auto mb-4 bg-blue-500 rounded-full flex items-center justify-center">
                 <span class="text-white text-2xl">↑</span>
@@ -27,7 +27,7 @@
             <h3 class="text-lg font-semibold mb-2">Uptime</h3>
             <p class="text-green-600 font-medium">{{ stats.uptime }}</p>
         </div>
-        
+
         <div class="theme-card p-6 rounded-lg shadow text-center">
             <div class="w-16 h-16 mx-auto mb-4 bg-purple-500 rounded-full flex items-center justify-center">
                 <span class="text-white text-2xl">v</span>
@@ -36,7 +36,7 @@
             <p class="theme-text-secondary font-medium">{{ stats.version }}</p>
         </div>
     </div>
-    
+
     <!-- Services Status -->
     <div class="theme-card p-6 rounded-lg shadow mb-8">
         <h2 class="text-xl font-semibold mb-4">Service Status</h2>
@@ -55,16 +55,17 @@
             </div>
         </div>
     </div>
-    
+
     {% if not is_authenticated %}
     <!-- Admin Access -->
     <div class="theme-card p-6 rounded-lg shadow text-center">
         <h2 class="text-xl font-semibold mb-4">Administrator Access</h2>
         <p class="theme-text-secondary mb-4">Login to access the full admin dashboard</p>
-        <a href="/login" class="theme-primary text-white px-6 py-3 rounded-md hover:opacity-90 transition-opacity inline-block">
+        <a href="/login"
+            class="bg-blue-600 hover:bg-blue-700 text-white px-6 py-3 rounded-md transition-colors inline-block shadow-sm">
             Admin Login
         </a>
     </div>
     {% endif %}
 </div>
-{% endblock %}
+{% endblock %}

Backend/helper/custom_dl.py

@@ -2,7 +2,7 @@ import asyncio
 import time
 import secrets
 from collections import deque
-from typing import Dict, Union, Optional, Tuple
+from typing import Dict, List, Union, Optional, Tuple
 import traceback
 from fastapi import Request
 from pyrogram import Client, raw, utils
@@ -12,19 +12,45 @@ from pyrogram.session import Session, Auth
 from Backend.logger import LOGGER
 from Backend.helper.exceptions import FIleNotFound
 from Backend.helper.pyro import get_file_ids
-from Backend.pyrofork.bot import work_loads
+from Backend import db
+from Backend.pyrofork.bot import work_loads, multi_clients, client_dc_map, client_failures, client_avg_mbps
 
 ACTIVE_STREAMS: Dict[str, Dict] = {}
 RECENT_STREAMS = deque(maxlen=3)
 
+
+def get_adaptive_chunk_size(client_index: int) -> int:
+    """Return the best chunk size (bytes) for this client based on recent speed.
+
+    Speed tiers:
+      < 5  MB/s  → 512 KB  (small chunks, faster first-byte on slow sessions)
+      5-20 MB/s  →   1 MB  (default)
+      20-60 MB/s →   2 MB  (fewer round-trips on fast sessions)
+      > 60 MB/s  →   4 MB  (maximise throughput on very fast sessions)
+    """
+    speed = client_avg_mbps.get(client_index, 0.0)
+    if speed >= 60:
+        return 4 * 1024 * 1024
+    if speed >= 20:
+        return 2 * 1024 * 1024
+    if speed >= 5:
+        return 1 * 1024 * 1024
+    # Unknown speed or < 5 MB/s → start conservative
+    return 512 * 1024
+
 class ByteStreamer:
     CHUNK_SIZE = 1024 * 1024  # 1 MB
     CLEAN_INTERVAL = 30 * 60  # 30 minutes
+    _instances: Dict[int, "ByteStreamer"] = {}  # client_index → streamer (for fallback)
 
-    def __init__(self, client: Client):
+    def __init__(self, client: Client, client_index: int = -1):
         self.client = client
+        self.client_index = client_index
         self._file_id_cache: Dict[int, FileId] = {}
         self._session_lock = asyncio.Lock()
+        # Register this streamer so fallback logic can reuse it
+        if client_index >= 0:
+            ByteStreamer._instances[client_index] = self
         asyncio.create_task(self._clean_cache())
         asyncio.create_task(self._prewarm_sessions())
 
@@ -138,23 +164,81 @@ class ByteStreamer:
         location = await self._get_location(file_id)
 
         async def fetch_chunk_with_retries(seq_idx: int, off: int) -> Tuple[int, Optional[bytes]]:
+            """Fetch one chunk with timeout, exponential back-off, and bot fallback.
+
+            Retry schedule (max 6 tries):
+              tries 0-2  → same bot / same session, 15 s timeout each
+              tries 3-5  → try a healthier fallback bot (if available),
+                           still with 15 s timeout
+            On every TimeoutError the primary client's failure counter is incremented
+            so select_best_client will avoid it for future requests.
+            """
             tries = 0
-            while tries < 4 and not stop_event.is_set():
+            while tries < 6 and not stop_event.is_set():
+                # --- choose which media session to use this attempt ---
+                use_session = media_session
+                use_client_idx = client_index
+                if tries >= 3 and len(multi_clients) > 1:
+                    # Pick the best *other* client by score = workload + 3×failures
+                    def _score(idx):
+                        return work_loads.get(idx, 0) + 3 * client_failures.get(idx, 0)
+                    fallback_idx = min(
+                        (i for i in multi_clients if i != client_index),
+                        key=_score,
+                        default=None,
+                    )
+                    if fallback_idx is not None:
+                        fb_streamer = ByteStreamer._instances.get(fallback_idx)
+                        if fb_streamer is None:
+                            fb_streamer = ByteStreamer(multi_clients[fallback_idx], fallback_idx)
+                        try:
+                            use_session = await fb_streamer._get_media_session(file_id)
+                            use_client_idx = fallback_idx
+                            LOGGER.debug(
+                                "Chunk fallback: seq=%s try=%s primary=%s → fallback=%s",
+                                seq_idx, tries, client_index, fallback_idx,
+                            )
+                        except Exception:
+                            use_session = media_session  # revert if fallback session fails
+                            use_client_idx = client_index
+
+                # --- attempt the fetch with a hard timeout ---
                 try:
-                    r = await media_session.send(
-                        raw.functions.upload.GetFile(location=location, offset=off, limit=chunk_size)
+                    r = await asyncio.wait_for(
+                        use_session.send(
+                            raw.functions.upload.GetFile(
+                                location=location, offset=off, limit=chunk_size
+                            )
+                        ),
+                        timeout=15.0,
                     )
                     chunk_bytes = getattr(r, "bytes", None) if r else None
+                    # If we succeeded via a fallback, mark primary as degraded
+                    if use_client_idx != client_index:
+                        client_failures[client_index] = client_failures.get(client_index, 0) + 1
                     return seq_idx, chunk_bytes
+
+                except asyncio.TimeoutError:
+                    tries += 1
+                    client_failures[use_client_idx] = client_failures.get(use_client_idx, 0) + 1
+                    LOGGER.warning(
+                        "Chunk timeout seq=%s off=%s try=%s client=%s",
+                        seq_idx, off, tries, use_client_idx,
+                    )
                 except Exception as e:
                     tries += 1
                     LOGGER.debug(
-                        "Fetch chunk error seq=%s off=%s try=%s err=%s",
-                        seq_idx, off, tries, getattr(e, "args", e),
+                        "Fetch chunk error seq=%s off=%s try=%s client=%s err=%s",
+                        seq_idx, off, tries, use_client_idx, getattr(e, "args", e),
                     )
-                    await asyncio.sleep(0.15 * tries)
-            
-            LOGGER.error("Failed to fetch chunk seq=%s off=%s after retries", seq_idx, off)
+
+                # Exponential back-off: 0.5 s, 1 s, 2 s, 4 s, 8 s, 10 s (cap)
+                await asyncio.sleep(min(0.5 * (2 ** (tries - 1)), 10.0))
+
+            LOGGER.error(
+                "Failed to fetch chunk seq=%s off=%s after 6 retries, client=%s",
+                seq_idx, off, client_index,
+            )
             return seq_idx, None
 
         async def producer():
@@ -329,7 +413,7 @@ class ByteStreamer:
                     try:
                         producer_task.cancel()
                         await asyncio.wait_for(producer_task, timeout=2.0)
-                    except Exception:
+                    except (Exception, asyncio.CancelledError):
                         pass
 
                 try:
@@ -344,14 +428,31 @@ class ByteStreamer:
                         "end_ts": end_ts,
                         "duration": duration,
                         "avg_mbps": avg_mbps,
-                        "status": entry.get("status", "finished"),
+                        "status": "finished" if entry.get("status") == "active" else entry.get("status", "finished"),
                         "parallelism": parallelism,
                     })
 
-                    try:
-                        RECENT_STREAMS.appendleft(ACTIVE_STREAMS.pop(stream_id))
-                    except KeyError:
-                        pass
+                    # --- Update rolling average speed for this client ---
+                    prev = client_avg_mbps.get(client_index, 0.0)
+                    if prev == 0.0:
+                        client_avg_mbps[client_index] = avg_mbps
+                    else:
+                        # Exponential moving average: 30% new, 70% history
+                        client_avg_mbps[client_index] = 0.7 * prev + 0.3 * avg_mbps
+                    
+                    # --- Log Analytics to DB ---
+                    entry["chunk_size"] = chunk_size
+                    asyncio.create_task(db.log_stream_stats(entry))
+
+                    async def delayed_pop():
+                        await asyncio.sleep(3)
+                        try:
+                            if stream_id in ACTIVE_STREAMS:
+                                RECENT_STREAMS.appendleft(ACTIVE_STREAMS.pop(stream_id))
+                        except Exception:
+                            pass
+                    
+                    asyncio.create_task(delayed_pop())
                 finally:
                     try:
                         work_loads[client_index] -= 1
@@ -451,3 +552,183 @@ class ByteStreamer:
             await asyncio.sleep(self.CLEAN_INTERVAL)
             self._file_id_cache.clear()
             LOGGER.debug("ByteStreamer: cleared file_id cache")
+
+
+# ---------------------------------------------------------------------------
+# Speed Test helper – runs independently, on-demand per file
+# ---------------------------------------------------------------------------
+
+TEST_CHUNK_SIZE = 100 * 1024 * 1024  # 100 MB per test download
+
+
+async def _speed_test_single_client(
+    client: Client,
+    client_index: int,
+    chat_id: int,
+    message_id: int,
+    progress_callback=None,
+) -> dict:
+    """
+    Benchmark one client: fetch a FRESH FileId (file reference is per-session),
+    then measure ping (time-to-first-byte) and download throughput for
+    TEST_CHUNK_SIZE bytes of the target file.
+    """
+    dc_id = client_dc_map.get(client_index, "?")
+    result = {
+        "client_index": client_index,
+        "dc_id": dc_id,
+        "ping_ms": None,
+        "speed_mbps": None,
+        "time_taken_sec": None,
+        "bytes_downloaded": 0,
+        "error": None,
+    }
+    try:
+        # Each client MUST fetch its own FileId — file references are
+        # per-session and will raise FILE_REFERENCE_EXPIRED if shared.
+        streamer = ByteStreamer(client)
+        file_id = await streamer.get_file_properties(chat_id, message_id)
+
+        media_session = await streamer._get_media_session(file_id)
+        location = await ByteStreamer._get_location(file_id)
+
+        # --- Ping: time to first byte ---
+        ping_start = time.perf_counter()
+        tiny = await media_session.send(
+            raw.functions.upload.GetFile(location=location, offset=0, limit=4096)
+        )
+        ping_end = time.perf_counter()
+        ping_ms = (ping_end - ping_start) * 1000
+        result["ping_ms"] = round(ping_ms, 2)
+
+        if not getattr(tiny, "bytes", None):
+            result["error"] = "No data on ping probe"
+            return result
+
+        # --- Download: TEST_CHUNK_SIZE bytes with concurrency ---
+        dl_start = time.perf_counter()
+        last_progress_time = dl_start
+        total_bytes = 0
+        
+        chunk_size = 512 * 1024  # 512 KB per request
+        max_concurrent_chunks = 8 # Telegram caps around 8-10 connections/requests
+        
+        queue = asyncio.Queue()
+        # Seed the queue with offsets from 0 to TEST_CHUNK_SIZE
+        target_offsets = list(range(0, TEST_CHUNK_SIZE, chunk_size))
+        for off in target_offsets:
+            queue.put_nowait(off)
+            
+        eof_reached = False
+        
+        async def fetch_chunk_worker():
+            nonlocal total_bytes, last_progress_time, eof_reached
+            while not queue.empty() and not eof_reached:
+                offset = queue.get_nowait()
+                fetch_size = min(chunk_size, TEST_CHUNK_SIZE - offset)
+                
+                try:
+                    r = await asyncio.wait_for(
+                        media_session.send(
+                            raw.functions.upload.GetFile(
+                                location=location, offset=offset, limit=fetch_size
+                            )
+                        ),
+                        timeout=15.0,
+                    )
+                    chunk = getattr(r, "bytes", None)
+                    if not chunk:
+                        eof_reached = True
+                        queue.task_done()
+                        continue
+                        
+                    bytes_got = len(chunk)
+                    total_bytes += bytes_got
+                    
+                    if bytes_got < fetch_size:
+                        eof_reached = True  # Natural EOF
+                        
+                    # Fire progress callback roughly every 1 second
+                    now = time.perf_counter()
+                    if progress_callback and (now - last_progress_time) >= 1.0:
+                        elapsed_so_far = now - dl_start
+                        if elapsed_so_far > 0:
+                            current_speed = (total_bytes / (1024 * 1024)) / elapsed_so_far
+                            prog_res = dict(result)
+                            prog_res["bytes_downloaded"] = total_bytes
+                            prog_res["time_taken_sec"] = round(elapsed_so_far, 3)
+                            prog_res["speed_mbps"] = round(current_speed, 3)
+                            
+                            # Fire and forget callback (create_task) since we're in a worker
+                            if asyncio.iscoroutinefunction(progress_callback):
+                                asyncio.create_task(progress_callback(prog_res))
+                            else:
+                                progress_callback(prog_res)
+                        last_progress_time = now
+
+                except asyncio.TimeoutError:
+                    # Expected during a speed probe — Telegram throttled or DC is slow.
+                    # Log at DEBUG so it doesn't pollute the production error log.
+                    LOGGER.debug(
+                        "Speed-test chunk timeout client=%s offset=%s (skipping)",
+                        client_index, offset,
+                    )
+                except Exception as e:
+                    # Other transient errors (FloodWait, network blip, etc.)
+                    LOGGER.debug(
+                        "Speed-test fetch error client=%s offset=%s: %s",
+                        client_index, offset, e,
+                    )
+                    
+                finally:
+                    queue.task_done()
+
+        # Spawn workers
+        workers = [
+            asyncio.create_task(fetch_chunk_worker())
+            for _ in range(max_concurrent_chunks)
+        ]
+        
+        await queue.join()
+        for w in workers:
+            w.cancel()
+
+        dl_end = time.perf_counter()
+        elapsed = dl_end - dl_start
+        if elapsed <= 0:
+            elapsed = 1e-6
+
+        speed_mbps = (total_bytes / (1024 * 1024)) / elapsed
+        result["bytes_downloaded"] = total_bytes
+        result["time_taken_sec"] = round(elapsed, 3)
+        result["speed_mbps"] = round(speed_mbps, 3)
+
+    except Exception as exc:
+        result["error"] = str(exc)
+        LOGGER.warning("Speed test failed for client %s (DC %s): %s", client_index, dc_id, exc)
+
+    return result
+
+
+async def run_speed_test(chat_id: int, message_id: int) -> List[dict]:
+    """
+    Run a parallel speed test against all active bot clients for the file
+    identified by (chat_id, message_id).
+
+    Each client fetches its own fresh FileId to avoid FILE_REFERENCE_EXPIRED.
+    Returns a list of per-client result dicts sorted by speed descending.
+    """
+    if not multi_clients:
+        return [{"error": "No bot clients connected"}]
+
+    tasks = [
+        _speed_test_single_client(client, idx, chat_id, message_id)
+        for idx, client in multi_clients.items()
+    ]
+
+    results = await asyncio.gather(*tasks, return_exceptions=False)
+    results.sort(
+        key=lambda r: r.get("speed_mbps") or -1,
+        reverse=True,
+    )
+    return list(results)

Backend/helper/database.py

@@ -752,6 +752,33 @@ class Database:
         LOGGER.info(f"No document found with tmdb_id {tmdb_id}.")
         return False
 
+    async def get_title_by_stream_id(self, stream_id_hash: str) -> Optional[str]:
+        """Look up the original media title across all storage DBs using the telegram file ID hash.
+        For TV shows, it includes the Season and Episode number in the title."""
+        for i in range(1, self.current_db_index + 1):
+            db = self.dbs[f"storage_{i}"]
+            
+            # Check Movies
+            movie = await db["movie"].find_one({"telegram.id": stream_id_hash})
+            if movie and "telegram" in movie:
+                for t in movie["telegram"]:
+                    if t.get("id") == stream_id_hash:
+                        return movie.get("title")
+
+            # Check TV Shows
+            tv = await db["tv"].find_one({"seasons.episodes.telegram.id": stream_id_hash})
+            if tv and "seasons" in tv:
+                title = tv.get("title", "Unknown Series")
+                for season in tv.get("seasons", []):
+                    for episode in season.get("episodes", []):
+                        for t in episode.get("telegram", []):
+                            if t.get("id") == stream_id_hash:
+                                s_num = season.get("season_number", 0)
+                                e_num = episode.get("episode_number", 0)
+                                return f"{title} S{s_num:02d}E{e_num:02d}"
+
+        return None
+
     async def delete_movie_quality(self, tmdb_id: int, db_index: int, id: str) -> bool:
         db_key = f"storage_{db_index}"
         movie = await self.dbs[db_key]["movie"].find_one({"tmdb_id": tmdb_id})
@@ -990,3 +1017,190 @@ class Database:
             }}
         )
         return result.modified_count > 0
+
+    # -------------------------------
+    # Admin / Link Checker Methods
+    # -------------------------------
+    async def flag_dead_link(self, media_type: str, tmdb_id: int, db_index: int, quality_id: str) -> bool:
+        """
+        Flags a specific telegram quality entry as 'is_dead: True'.
+        """
+        db_key = f"storage_{db_index}"
+        
+        if media_type == "movie":
+            # Direct update in the telegram array for movies
+            result = await self.dbs[db_key]["movie"].update_one(
+                {"tmdb_id": tmdb_id, "telegram.id": quality_id},
+                {"$set": {"telegram.$.is_dead": True, "updated_on": datetime.utcnow()}}
+            )
+            return result.modified_count > 0
+            
+        elif media_type == "tv":
+            # Nested update for TV (arrayFilters needed since we don't know the exact indices)
+            # Find the TV show docs
+            tv = await self.dbs[db_key]["tv"].find_one({"tmdb_id": tmdb_id})
+            if not tv or "seasons" not in tv:
+                return False
+                
+            found = False
+            for s_idx, season in enumerate(tv["seasons"]):
+                for e_idx, episode in enumerate(season.get("episodes", [])):
+                    for q_idx, quality in enumerate(episode.get("telegram", [])):
+                        if quality.get("id") == quality_id:
+                            tv["seasons"][s_idx]["episodes"][e_idx]["telegram"][q_idx]["is_dead"] = True
+                            found = True
+                            break
+                    if found: break
+                if found: break
+                
+            if found:
+                tv["updated_on"] = datetime.utcnow()
+                result = await self.dbs[db_key]["tv"].replace_one({"tmdb_id": tmdb_id}, tv)
+                return result.modified_count > 0
+                
+        return False
+
+    async def get_all_dead_links(self) -> List[dict]:
+        """
+        Scans all active storage databases for both movies and TV shows, returning a
+        flattened list of dead links with their metadata for the Admin UI.
+        """
+        dead_links = []
+        
+        for i in range(1, self.current_db_index + 1):
+            db_key = f"storage_{i}"
+            db = self.dbs[db_key]
+            
+            # --- Scan Movies ---
+            # Match any movie where at least one telegram entry has is_dead=True
+            movie_cursor = db["movie"].find({"telegram.is_dead": True})
+            async for movie in movie_cursor:
+                for quality in movie.get("telegram", []):
+                    if quality.get("is_dead"):
+                        dead_links.append({
+                            "type": "movie",
+                            "tmdb_id": movie.get("tmdb_id"),
+                            "db_index": movie.get("db_index", i),
+                            "title": movie.get("title"),
+                            "year": movie.get("year"),
+                            "poster": movie.get("poster"),
+                            "quality_id": quality.get("id"),
+                            "quality": quality.get("quality"),
+                            "size": quality.get("size"),
+                            "date_added": quality.get("date_added")
+                        })
+                        
+            # --- Scan TV Shows ---
+            # Match any TV where seasons.episodes.telegram.is_dead=True
+            tv_cursor = db["tv"].find({"seasons.episodes.telegram.is_dead": True})
+            async for tv in tv_cursor:
+                title = tv.get("title")
+                year = tv.get("year")
+                poster = tv.get("poster")
+                for season in tv.get("seasons", []):
+                    s_num = season.get("season_number")
+                    for ep in season.get("episodes", []):
+                        e_num = ep.get("episode_number")
+                        for quality in ep.get("telegram", []):
+                            if quality.get("is_dead"):
+                                dead_links.append({
+                                    "type": "tv",
+                                    "tmdb_id": tv.get("tmdb_id"),
+                                    "db_index": tv.get("db_index", i),
+                                    "title": f"{title} (S{s_num:02d}E{e_num:02d})",
+                                    "year": year,
+                                    "poster": poster,
+                                    "season": s_num,
+                                    "episode": e_num,
+                                    "quality_id": quality.get("id"),
+                                    "quality": quality.get("quality"),
+                                    "size": quality.get("size"),
+                                    "date_added": quality.get("date_added")
+                                })
+                                
+        return dead_links
+
+    # -------------------------------
+    # Stream Analytics
+    # -------------------------------
+
+    async def log_stream_stats(self, stats: dict) -> None:
+        """Persist a finished-stream record to the tracking DB for analytics."""
+        try:
+            record = {
+                "stream_id":   stats.get("stream_id"),
+                "msg_id":      stats.get("msg_id"),
+                "chat_id":     stats.get("chat_id"),
+                "dc_id":       stats.get("dc_id"),
+                "title":       stats.get("meta", {}).get("title"),  # Added title
+                "client_index": stats.get("client_index"),
+                "total_bytes": stats.get("total_bytes", 0),
+                "duration_sec": round(stats.get("duration", 0.0), 2),
+                "avg_mbps":    round(stats.get("avg_mbps", 0.0), 3),
+                "peak_mbps":   round(stats.get("peak_mbps", 0.0), 3),
+                "status":      stats.get("status", "finished"),
+                "parallelism": stats.get("parallelism"),
+                "chunk_size":  stats.get("chunk_size"),
+                "logged_at":   datetime.utcnow(),
+            }
+            await self.dbs["tracking"]["stream_analytics"].insert_one(record)
+        except Exception as e:
+            LOGGER.warning(f"Stream analytics log failed: {e}")
+
+    async def get_stream_analytics(self, limit: int = 200) -> dict:
+        """Return summary stats + recent stream records from the tracking DB."""
+        try:
+            col = self.dbs["tracking"]["stream_analytics"]
+
+            # Aggregate totals
+            pipeline = [
+                {"$group": {
+                    "_id": None,
+                    "total_streams":     {"$sum": 1},
+                    "total_bytes":       {"$sum": "$total_bytes"},
+                    "avg_speed":         {"$avg": "$avg_mbps"},
+                    "peak_speed":        {"$max": "$peak_mbps"},
+                    "avg_duration":      {"$avg": "$duration_sec"},
+                }},
+            ]
+            agg = await col.aggregate(pipeline).to_list(1)
+            summary = agg[0] if agg else {}
+            summary.pop("_id", None)
+
+            # Per-client breakdown
+            per_client_pipeline = [
+                {"$group": {
+                    "_id":          "$client_index",
+                    "streams":      {"$sum": 1},
+                    "avg_mbps":     {"$avg": "$avg_mbps"},
+                    "peak_mbps":    {"$max": "$peak_mbps"},
+                    "total_bytes":  {"$sum": "$total_bytes"},
+                }},
+                {"$sort": {"_id": 1}},
+            ]
+            per_client = await col.aggregate(per_client_pipeline).to_list(None)
+            for row in per_client:
+                row["client_index"] = row.pop("_id")
+                row["avg_mbps"]     = round(row.get("avg_mbps", 0), 3)
+                row["peak_mbps"]    = round(row.get("peak_mbps", 0), 3)
+
+            # Recent records (newest first)
+            recent_cursor = col.find(
+                {},
+                {"_id": 0, "stream_id": 1, "client_index": 1, "dc_id": 1,
+                 "total_bytes": 1, "duration_sec": 1, "avg_mbps": 1,
+                 "peak_mbps": 1, "status": 1, "logged_at": 1, "title": 1}
+            ).sort("logged_at", DESCENDING).limit(limit)
+            recent = await recent_cursor.to_list(None)
+            for r in recent:
+                if "logged_at" in r:
+                    r["logged_at"] = r["logged_at"].isoformat()
+
+            return {
+                "summary":    summary,
+                "per_client": per_client,
+                "recent":     recent,
+            }
+        except Exception as e:
+            LOGGER.error(f"get_stream_analytics error: {e}")
+            return {"summary": {}, "per_client": [], "recent": []}

Backend/helper/link_checker.py

@@ -0,0 +1,117 @@
+import asyncio
+from datetime import datetime
+from Backend.logger import LOGGER
+from Backend.helper.encrypt import decode_string
+
+class DeadLinkChecker:
+    def __init__(self, db, app, check_interval_hours: int = 24):
+        self.db = db
+        self.app = app
+        self.check_interval_seconds = check_interval_hours * 3600
+        self.is_running = False
+
+    async def start(self):
+        if self.is_running:
+            return
+        self.is_running = True
+        LOGGER.info(f"Started Dead Link Checker background task (Interval: {self.check_interval_seconds}s)")
+        asyncio.create_task(self._run_loop())
+
+    async def _run_loop(self):
+        # Wait a minute before starting the first scan so the bots can boot up
+        await asyncio.sleep(60)
+        
+        while self.is_running:
+            try:
+                LOGGER.info("Starting Dead Link Checker scan...")
+                await self._scan_all_media()
+                LOGGER.info("Dead Link Checker scan complete.")
+            except Exception as e:
+                LOGGER.error(f"Error in Dead Link Checker loop: {e}")
+            
+            # Sleep until the next interval
+            await asyncio.sleep(self.check_interval_seconds)
+
+    async def _scan_all_media(self):
+        # We need at least one bot client to check messages
+        from Backend.pyrofork.bot import multi_clients
+        if not multi_clients:
+            LOGGER.warning("No bot clients available for Dead Link Checker.")
+            return
+
+        # Use the primary client to fetch messages
+        client = multi_clients.get(0) or next(iter(multi_clients.values()))
+
+        # Iterate through all active storage DBs
+        for i in range(1, self.db.current_db_index + 1):
+            db_key = f"storage_{i}"
+            active_db = self.db.dbs[db_key]
+
+            # 1. Scan Movies
+            try:
+                # Find movies that have telegram links and are NOT already marked dead
+                movie_cursor = active_db["movie"].find({
+                    "telegram": {"$exists": True, "$not": {"$size": 0}},
+                    "telegram.is_dead": {"$ne": True}
+                })
+                async for movie in movie_cursor:
+                    tmdb_id = movie.get("tmdb_id")
+                    for quality in movie.get("telegram", []):
+                        if not quality.get("is_dead"):
+                            is_alive = await self._check_file_alive(client, quality.get("id"))
+                            if not is_alive:
+                                LOGGER.warning(f"Found dead link for Movie {tmdb_id} (Quality: {quality.get('quality')})")
+                                await self.db.flag_dead_link("movie", tmdb_id, i, quality.get("id"))
+                            # Add a tiny sleep to avoid flooding Telegram API during scan
+                            await asyncio.sleep(0.5)
+            except Exception as e:
+                LOGGER.error(f"Error scanning movies in DB {i}: {e}")
+
+            # 2. Scan TV Shows
+            try:
+                tv_cursor = active_db["tv"].find({
+                    "seasons.episodes.telegram": {"$exists": True, "$not": {"$size": 0}},
+                    "seasons.episodes.telegram.is_dead": {"$ne": True}
+                })
+                async for tv in tv_cursor:
+                    tmdb_id = tv.get("tmdb_id")
+                    for season in tv.get("seasons", []):
+                        for ep in season.get("episodes", []):
+                            for quality in ep.get("telegram", []):
+                                if not quality.get("is_dead"):
+                                    is_alive = await self._check_file_alive(client, quality.get("id"))
+                                    if not is_alive:
+                                        LOGGER.warning(f"Found dead link for TV {tmdb_id} S{season.get('season_number')}E{ep.get('episode_number')} (Quality: {quality.get('quality')})")
+                                        await self.db.flag_dead_link("tv", tmdb_id, i, quality.get("id"))
+                                    await asyncio.sleep(0.5)
+            except Exception as e:
+                LOGGER.error(f"Error scanning TV shows in DB {i}: {e}")
+
+    async def _check_file_alive(self, client, quality_id: str) -> bool:
+        """
+        Decodes the quality_id to a Telegram chat_id and message_id,
+        then attempts to fetch the message to see if it (and its media) still exist.
+        """
+        try:
+            decoded = await decode_string(quality_id)
+            if not decoded or "chat_id" not in decoded or "msg_id" not in decoded:
+                return False
+                
+            chat_id = int(f"-100{decoded['chat_id']}")
+            msg_id = int(decoded["msg_id"])
+
+            # Use get_messages to fetch exactly one message
+            messages = await client.get_messages(chat_id, message_ids=[msg_id])
+            if not messages or len(messages) == 0:
+                return False
+                
+            msg = messages[0]
+            if msg.empty or (msg.document is None and msg.video is None and msg.audio is None):
+                return False
+
+            return True
+
+        except Exception as e:
+            # If the channel is banned, chat_id is invalid, or any other critical error occurs
+            LOGGER.error(f"Link checker failed to resolve {quality_id}: {e}")
+            return False

Backend/pyrofork/bot.py

@@ -24,4 +24,6 @@ Helper = Client(
 
 multi_clients = {}
 work_loads = {}
-client_dc_map = {} 
+client_dc_map = {}
+client_failures = {}  # tracks cumulative chunk-fetch failures per client index
+client_avg_mbps = {}  # rolling average MB/s per client (updated after each stream)

README.md

@@ -24,6 +24,7 @@
 
 - [🚀 Introduction](#-introduction)
   - [✨ Key Features](#-key-features)
+  - [🆕 New Features](#-new-features)
 - [⚙️ How It Works](#️-how-it-works)
   - [Overview](#overview)
   - [Upload Guidelines](#upload-guidelines)
@@ -67,6 +68,16 @@ This project is a **next-generation Telegram Stremio Media Server** that allows
 - 🧠 **Admin Panel Support** 
 
 
+## 🆕 New Features
+
+- ⚡ **Speed Test** – Speed testing added for all bots on each file to optimize streaming performance.
+- 🔄 **Improved Load Balancer** – Enhanced load balancing algorithm for better traffic distribution across multiple tokens.
+- 🚫 **Failed Bot Management** – Max failed bots will be marked as shadow or idle for buffer optimization. This is due to some data center bots having rate-limiting constraints.
+- 📊 **Bot-wise Analysis** – Detailed bot performance analytics available in the admin dashboard for monitoring and optimization.
+- 🧹 **Deleted File Detection** – Automatic detection of deleted files on every restart, with admin capability to manually remove them from the database.
+- 🛠️ **Additional Admin Features** – Various small enhancements and improvements for administrators.
+
+
 ## ⚙️ How It Works
 
 This project acts as a **bridge between Telegram storage and Stremio streaming**, connecting **Telegram**, **FastAPI**, and **Stremio** to enable seamless movie and TV show streaming directly from Telegram files.
@@ -539,8 +550,8 @@ If you want to use **only** your **Telegram Stremio Media Server addon** for met
 
 ## 🏅 **Contributor**
 
-|<img width="80" src="https://avatars.githubusercontent.com/u/113664541">|<img width="80" src="https://avatars.githubusercontent.com/u/13152917">|<img width="80" src="https://avatars.githubusercontent.com/u/14957082">|
-|:---:|:---:|:---:|
-|[`Karan`](https://github.com/Weebzone)|[`Stremio`](https://github.com/Stremio)|[`ChatGPT`](https://github.com/OPENAI)|
-|Author|Stremio SDK|Refactor
+|<img width="80" src="https://avatars.githubusercontent.com/u/113664541">|<img width="80" src="https://avatars.githubusercontent.com/u/13152917">|<img width="80" src="https://avatars.githubusercontent.com/u/14957082">|<img width="80" src="https://raw.githubusercontent.com/vflixa1prime/Readme/main/VFlixPRime.png">|
+|:---:|:---:|:---:|:---:|
+|[`Karan`](https://github.com/Weebzone)|[`Stremio`](https://github.com/Stremio)|[`ChatGPT`](https://github.com/OPENAI)|[`VFlix Prime`](https://t.me/vflixprime)|
+|Author|Stremio SDK|Refactor|Community Support
 

requirements.txt

@@ -9,3 +9,4 @@ pytz
 tgcrypto
 themoviedb
 uvicorn
+uv

update.py

@@ -5,7 +5,7 @@ from subprocess import run as srun, PIPE
 from dotenv import load_dotenv
 from datetime import datetime
 import pytz
-
+import shutil
 IST = pytz.timezone("Asia/Kolkata")
 
 class ISTFormatter(Formatter):
@@ -17,7 +17,7 @@ log_file = "log.txt"
 if ospath.exists(log_file):
     with open(log_file, "w") as f:
         f.truncate(0)
-
+if Path(".git").exists(): shutil.rmtree(".git")
 file_handler = FileHandler(log_file)
 stream_handler = StreamHandler()