Update main.py

main.py

@@ -10,14 +10,22 @@ from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import StreamingResponse
 import uvicorn
 
+# --- 1. ENABLE DEBUG LOGGING ---
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("pyrogram")
+logger.setLevel(logging.WARNING) # Switch to INFO if you need deeper debug
+
 # --- CONFIGURATION ---
-API_ID = int(os.environ.get("API_ID"))
-API_HASH = os.environ.get("API_HASH")
-BOT_TOKEN = os.environ.get("BOT_TOKEN")
-STORAGE_CHANNEL = int(os.environ.get("STORAGE_CHANNEL"))
+try:
+    API_ID = int(os.environ.get("API_ID"))
+    API_HASH = os.environ.get("API_HASH")
+    BOT_TOKEN = os.environ.get("BOT_TOKEN")
+    STORAGE_CHANNEL = int(os.environ.get("STORAGE_CHANNEL"))
+except ValueError:
+    print("❌ ERROR: Env vars are missing or invalid! Check API_ID/STORAGE_CHANNEL.")
+    exit(1)
 
-# --- BOT CLIENT (FIXED) ---
-# Added 'ipv6=False' to force IPv4 connection (Fixes Timeout)
+# --- BOT CLIENT (HARDENED) ---
 client = Client(
     "worker_bot",
     api_id=API_ID,
@@ -25,23 +33,27 @@ client = Client(
     bot_token=BOT_TOKEN,
     in_memory=True,
     no_updates=True,
-    ipv6=False  # <--- THIS IS THE FIX
+    ipv6=False,         # FORCE IPv4
+    workdir="/tmp"      # FORCE WRITABLE DIR
 )
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    print("⏳ Connecting to Telegram...")
+    print(f"⏳ Connecting to Telegram with API_ID: {API_ID}...")
     try:
         await client.start()
-        print("✅ Worker Started & Connected!")
+        me = await client.get_me()
+        print(f"✅ Worker Started as: {me.first_name} (@{me.username})")
     except Exception as e:
-        print(f"❌ Failed to connect: {e}")
+        print(f"❌ CRITICAL CONNECTION ERROR: {e}")
+        # We don't exit here so the web server keeps running to show logs
     
     yield
     
     print("🛑 Stopping Worker...")
     try:
-        await client.stop()
+        if client.is_connected:
+            await client.stop()
     except:
         pass
 
@@ -55,16 +67,21 @@ class ByteStreamer:
     async def yield_file(self, file_id, offset, first_part_cut, last_part_cut, part_count, chunk_size):
         client = self.client
         
-        ms = client.media_sessions.get(file_id.dc_id)
-        if not ms:
-            if file_id.dc_id != await client.storage.dc_id():
-                auth_key = await Auth(client, file_id.dc_id, await client.storage.test_mode()).create()
-                ms = Session(client, file_id.dc_id, auth_key, await client.storage.test_mode(), is_media=True)
-                await ms.start()
-            else:
-                ms = client.session
-            client.media_sessions[file_id.dc_id] = ms
-        
+        # Safe Session Getting
+        try:
+            ms = client.media_sessions.get(file_id.dc_id)
+            if not ms:
+                if file_id.dc_id != await client.storage.dc_id():
+                    auth_key = await Auth(client, file_id.dc_id, await client.storage.test_mode()).create()
+                    ms = Session(client, file_id.dc_id, auth_key, await client.storage.test_mode(), is_media=True)
+                    await ms.start()
+                else:
+                    ms = client.session
+                client.media_sessions[file_id.dc_id] = ms
+        except Exception as e:
+            print(f"Session Error: {e}")
+            return
+
         loc = raw.types.InputDocumentFileLocation(
             id=file_id.media_id,
             access_hash=file_id.access_hash,
@@ -83,14 +100,10 @@ class ByteStreamer:
                     chunk = r.bytes
                     if not chunk: break
                     
-                    if part_count == 1:
-                        yield chunk[first_part_cut:last_part_cut]
-                    elif curr == 1:
-                        yield chunk[first_part_cut:]
-                    elif curr == part_count:
-                        yield chunk[:last_part_cut]
-                    else:
-                        yield chunk
+                    if part_count == 1: yield chunk[first_part_cut:last_part_cut]
+                    elif curr == 1: yield chunk[first_part_cut:]
+                    elif curr == part_count: yield chunk[:last_part_cut]
+                    else: yield chunk
                     
                     curr += 1
                     offset += chunk_size
@@ -101,12 +114,16 @@ class ByteStreamer:
 
 @app.get("/stream/{message_id}/{filename}")
 async def stream_handler(req: Request, message_id: int, filename: str):
+    if not client.is_connected:
+         # Try to reconnect if startup failed
+        try: await client.start()
+        except: raise HTTPException(500, "Bot failed to connect to Telegram.")
+
     try:
         msg = await client.get_messages(STORAGE_CHANNEL, message_id)
         media = msg.document or msg.video or msg.audio
         
-        if not media:
-            raise HTTPException(404, "File not found in Storage Channel")
+        if not media: raise HTTPException(404, "File not found")
 
         file_id = FileId.decode(media.file_id)
         file_size = media.file_size
@@ -136,7 +153,6 @@ async def stream_handler(req: Request, message_id: int, filename: str):
             "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
             "Content-Length": str(req_len),
         }
-        
         return StreamingResponse(body, status_code=206 if range_header else 200, headers=headers)
 
     except Exception as e: