Update main.py

main.py

@@ -1,12 +1,11 @@
 import uvicorn
 import httpx
-from fastapi import FastAPI, Response, HTTPException
+from fastapi import FastAPI, Response, Request, HTTPException # Added Request
 from fastapi.responses import StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
 from contextlib import asynccontextmanager
 
 # --- Configuration ---
-# Mimic a real browser to avoid being blocked by the video server
 HEADERS = {
     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
     "Referer": "https://media.javtrailers.com/",
@@ -15,18 +14,16 @@ HEADERS = {
 # Global client variable
 http_client: httpx.AsyncClient = None
 
-# --- Lifespan Management (Best Practice) ---
+# --- Lifespan Management ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Startup: Create a shared client with longer timeouts
     global http_client
     http_client = httpx.AsyncClient(
         headers=HEADERS, 
-        timeout=httpx.Timeout(10.0, read=30.0), # 30s read timeout for video buffering
+        timeout=httpx.Timeout(10.0, read=30.0),
         follow_redirects=True
     )
     yield
-    # Shutdown: Clean up resources
     await http_client.aclose()
 
 app = FastAPI(lifespan=lifespan)
@@ -56,36 +53,84 @@ def rewrite_m3u8_content(content_text: str, base_url: str) -> str:
         elif line.startswith("http://") or line.startswith("https://"):
             new_lines.append(line)
         else:
-            # Rewrite relative paths
             new_lines.append(f"/proxy-segment?base={base_url}&segment={line}")
             
     return "\n".join(new_lines)
 
 async def stream_generator(response: httpx.Response):
-    """
-    Safely iterates over the stream. 
-    If the upstream server cuts the connection (ReadError), we stop gracefully
-    instead of crashing the whole worker.
-    """
+    """Safely iterates over the stream, handling upstream disconnects."""
     try:
         async for chunk in response.aiter_raw():
             yield chunk
     except (httpx.ReadError, httpx.RemoteProtocolError, httpx.ConnectError) as e:
         print(f"Warning: Stream interrupted by upstream: {e}")
     finally:
-        # Always close the response explicitly
         await response.aclose()
 
 # --- Routes ---
 
 @app.get("/")
 def home():
-    return {"status": "Running", "usage": "/proxy-playlist?url=..."}
+    return {
+        "status": "Running", 
+        "usage_hls": "/proxy-playlist?url=...",
+        "usage_mp4": "/proxy-video?url=..."
+    }
+
+# ---------------------------------------------------------
+# NEW: MP4 Proxy Support (Supports Seeking/Scrubbing)
+# ---------------------------------------------------------
+@app.get("/proxy-video")
+async def proxy_video(url: str, request: Request):
+    try:
+        # 1. Forward the 'Range' header if the browser sent one.
+        #    This allows the browser to request specific byte chunks (seeking).
+        req_headers = {}
+        if "range" in request.headers:
+            req_headers["Range"] = request.headers["range"]
+
+        # 2. Build the request manually
+        req = http_client.build_request("GET", url, headers=req_headers)
+        
+        # 3. Send request (stream=True)
+        r = await http_client.send(req, stream=True)
+        
+        # 4. Handle errors
+        if r.status_code >= 400:
+            await r.aclose()
+            return Response(content=f"Upstream Error {r.status_code}", status_code=r.status_code)
+
+        # 5. Prepare Response Headers
+        #    We must forward Content-Range/Length so the browser knows the video size.
+        resp_headers = {
+            "Accept-Ranges": "bytes", # Tell browser we support seeking
+            "Content-Type": r.headers.get("Content-Type", "video/mp4"),
+        }
+        
+        # Only add these if they exist in the upstream response
+        if "Content-Length" in r.headers:
+            resp_headers["Content-Length"] = r.headers["Content-Length"]
+        if "Content-Range" in r.headers:
+            resp_headers["Content-Range"] = r.headers["Content-Range"]
+
+        # 6. Return StreamingResponse
+        #    We pass r.status_code (usually 206 or 200) directly.
+        return StreamingResponse(
+            stream_generator(r),
+            status_code=r.status_code,
+            headers=resp_headers,
+            media_type="video/mp4"
+        )
+
+    except httpx.RequestError as e:
+        return Response(content=f"Video Error: {e}", status_code=502)
+
+
+# --- Existing HLS Routes ---
 
 @app.get("/proxy-playlist")
 async def proxy_playlist(url: str):
     try:
-        # Use the global client
         resp = await http_client.get(url)
         resp.raise_for_status()
         
@@ -113,15 +158,11 @@ async def proxy_segment(base: str, segment: str):
         except httpx.RequestError as e:
             return Response(content=f"Playlist Error: {e}", status_code=502)
 
-    # CASE 2: Video Segment (.ts) - STREAMING
+    # CASE 2: Video Segment (.ts)
     try:
-        # Build request manually to fine-tune streaming
         req = http_client.build_request("GET", full_url)
-        
-        # Send request but DO NOT read body yet (stream=True)
         r = await http_client.send(req, stream=True)
         
-        # If upstream returns 404 or 403, fail early
         if r.status_code >= 400:
             await r.aclose()
             return Response(content=f"Upstream Error {r.status_code}", status_code=r.status_code)