Rename index.js to app.py

app.py

@@ -0,0 +1,198 @@
+import os
+import uuid
+import asyncio
+import subprocess
+import shutil
+from fastapi import FastAPI, Query, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="M3U8 to MP4 Converter", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+TEMP_DIR = "/tmp/m3u8_conversions"
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+active_conversions = {}
+
+
+def cleanup_files(file_paths):
+    for path in file_paths:
+        try:
+            if os.path.exists(path):
+                if os.path.isdir(path):
+                    shutil.rmtree(path)
+                else:
+                    os.remove(path)
+                logger.info(f"Cleaned up: {path}")
+        except Exception as e:
+            logger.error(f"Cleanup error for {path}: {e}")
+
+
+def get_ffmpeg_path():
+    ffmpeg_path = shutil.which("ffmpeg")
+    if ffmpeg_path:
+        return ffmpeg_path
+    for path in ["/usr/bin/ffmpeg", "/usr/local/bin/ffmpeg", "/app/ffmpeg", "./ffmpeg"]:
+        if os.path.exists(path):
+            return path
+    return "ffmpeg"
+
+
+async def convert_m3u8_to_mp4(m3u8_url: str, output_path: str, task_id: str):
+    ffmpeg = get_ffmpeg_path()
+    
+    cmd = [
+        ffmpeg,
+        "-i", m3u8_url,
+        "-c", "copy",
+        "-bsf:a", "aac_adtstoasc",
+        "-movflags", "+faststart",
+        "-y",
+        output_path
+    ]
+    
+    cmd_fallback = [
+        ffmpeg,
+        "-i", m3u8_url,
+        "-c:v", "libx264",
+        "-preset", "fast",
+        "-crf", "23",
+        "-c:a", "aac",
+        "-b:a", "128k",
+        "-movflags", "+faststart",
+        "-y",
+        output_path
+    ]
+    
+    logger.info(f"Starting conversion: {task_id}")
+    logger.info(f"Command: {' '.join(cmd)}")
+    
+    active_conversions[task_id] = {"status": "converting", "progress": 0}
+    
+    try:
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        
+        stdout, stderr = await process.communicate()
+        
+        if process.returncode != 0:
+            logger.warning(f"Copy mode failed, trying re-encode mode: {stderr.decode()[:500]}")
+            active_conversions[task_id]["status"] = "re-encoding"
+            
+            process = await asyncio.create_subprocess_exec(
+                *cmd_fallback,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await process.communicate()
+            
+            if process.returncode != 0:
+                raise Exception(f"Conversion failed: {stderr.decode()[:1000]}")
+        
+        active_conversions[task_id]["status"] = "completed"
+        logger.info(f"Conversion completed: {task_id}")
+        
+    except Exception as e:
+        active_conversions[task_id]["status"] = "failed"
+        active_conversions[task_id]["error"] = str(e)
+        logger.error(f"Conversion error: {e}")
+        raise
+
+
+@app.get("/")
+def root():
+    return {
+        "message": "M3U8 to MP4 Converter API",
+        "usage": "/video?url=<m3u8-url>&format=mp4",
+        "endpoints": {
+            "convert": "/video?url=<m3u8-url>&format=mp4",
+            "status": "/status/<task_id>"
+        }
+    }
+
+
+@app.get("/video")
+async def convert_video(
+    url: str = Query(..., description="M3U8 URL to convert"),
+    format: str = Query("mp4", description="Output format (mp4 only)")
+):
+    if not url:
+        raise HTTPException(status_code=400, detail="URL parameter is required")
+    
+    if not url.startswith(("http://", "https://")):
+        raise HTTPException(status_code=400, detail="Invalid URL format")
+    
+    task_id = str(uuid.uuid4())
+    output_filename = f"video_{task_id}.mp4"
+    output_path = os.path.join(TEMP_DIR, output_filename)
+    
+    try:
+        await convert_m3u8_to_mp4(url, output_path, task_id)
+        
+        if not os.path.exists(output_path):
+            raise HTTPException(status_code=500, detail="Conversion failed - output file not created")
+        
+        file_size = os.path.getsize(output_path)
+        logger.info(f"File size: {file_size} bytes")
+        
+        response = FileResponse(
+            path=output_path,
+            media_type="video/mp4",
+            filename=f"converted_video_{task_id}.mp4",
+            headers={
+                "Content-Disposition": f'attachment; filename="converted_video_{task_id}.mp4"'
+            }
+        )
+        
+        @response.background
+        def cleanup():
+            cleanup_files([output_path])
+        
+        return response
+        
+    except HTTPException:
+        cleanup_files([output_path])
+        raise
+    except Exception as e:
+        cleanup_files([output_path])
+        logger.error(f"Error: {e}")
+        raise HTTPException(status_code=500, detail=f"Conversion error: {str(e)}")
+
+
+@app.get("/status/{task_id}")
+def get_status(task_id: str):
+    if task_id not in active_conversions:
+        return {"status": "not_found"}
+    return active_conversions[task_id]
+
+
+@app.get("/health")
+def health_check():
+    ffmpeg = get_ffmpeg_path()
+    ffmpeg_available = os.path.exists(ffmpeg) or shutil.which("ffmpeg") is not None
+    return {
+        "status": "healthy",
+        "ffmpeg_available": ffmpeg_available,
+        "ffmpeg_path": ffmpeg
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(app, host="0.0.0.0", port=port)

index.js

@@ -1,46 +0,0 @@
-const express = require("express");
-const { Client, GatewayIntentBits } = require("discord.js");
-
-const app = express();
-const PORT = process.env.PORT || 7860;
-
-app.get("/", (req, res) => {
-  res.send("Bot is alive");
-});
-
-app.listen(PORT, () => {
-  console.log("Web server running on port", PORT);
-});
-
-const client = new Client({
-  intents: [
-    GatewayIntentBits.Guilds,
-    GatewayIntentBits.GuildMessages,
-    GatewayIntentBits.MessageContent
-  ]
-});
-
-// ✅ prevent crash
-process.on("uncaughtException", console.error);
-process.on("unhandledRejection", console.error);
-
-client.once("ready", () => {
-  console.log(`Logged in as ${client.user.tag}`);
-});
-
-// safer message handler
-client.on("messageCreate", async (message) => {
-  try {
-    if (message.author.bot) return;
-
-    if (message.content === "!ping") {
-      await message.reply("Pong!");
-    }
-  } catch (err) {
-    console.error("Message error:", err);
-  }
-});
-
-client.login(process.env.DISCORD_TOKEN).catch((err) => {
-  console.error("Login failed:", err);
-});