Update bot.py

bot.py

@@ -3,32 +3,43 @@ import re
 import time
 import io
 import asyncio
-import aiohttp
-from telethon import events, Button
+from pyrogram import Client, filters
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from pyrogram.errors import MessageNotModified
 import db
 import scraper
 from curl_cffi.requests import AsyncSession
 
-# --- AUTHENTICATION ---
-ADMIN_IDS = {int(x) for x in os.environ.get("ADMIN_IDS", "").split(",") if x}
+# --- CONFIG & AUTH ---
+API_ID = int(os.environ.get("API_ID", 0))
+API_HASH = os.environ.get("API_HASH", "")
+BOT_TOKEN = os.environ.get("BOT_TOKEN", "")
+ADMIN_IDS = [int(x) for x in os.environ.get("ADMIN_IDS", "").split(",") if x]
 
-def is_admin(event):
-    return event.sender_id in ADMIN_IDS
+app = Client("bot_session", api_id=API_ID, api_hash=API_HASH, bot_token=BOT_TOKEN)
 
-# --- MENUS & DASHBOARD ---
+# Custom admin filter for Pyrogram
+is_admin = filters.user(ADMIN_IDS)
+
+# --- NAVIGATION MENUS ---
 def get_main_menu():
-    return [
-        [Button.inline("▶️ Start Scan", b"start_scan"), Button.inline("⏸ Pause", b"pause_scan"), Button.inline("⏹ Stop", b"stop_scan")],
-        [Button.inline("📊 Live Status", b"show_status"), Button.inline("📥 Export Data", b"export_files")],
-        [Button.inline("⚙️ System Settings", b"menu_settings")]
-    ]
+    return InlineKeyboardMarkup([
+        [InlineKeyboardButton("▶️ Start", callback_data="start_scan"), 
+         InlineKeyboardButton("⏸ Pause", callback_data="pause_scan"), 
+         InlineKeyboardButton("⏹ Stop", callback_data="stop_scan")],
+        [InlineKeyboardButton("📊 Live Status", callback_data="show_status"), 
+         InlineKeyboardButton("📥 Export Data", callback_data="export_files")],
+        [InlineKeyboardButton("⚙️ System Settings", callback_data="menu_settings")]
+    ])
 
 def get_settings_menu():
-    return [
-        [Button.inline("💾 Load Words", b"load_words"), Button.inline("📏 Set Length", b"set_min_length")],
-        [Button.inline("⚡ Set Speed", b"set_speed"), Button.inline("🔴 Wipe DB", b"reset_confirm")],
-        [Button.inline("« Back to Main Menu", b"back_main")]
-    ]
+    return InlineKeyboardMarkup([
+        [InlineKeyboardButton("💾 Load Words", callback_data="load_words"), 
+         InlineKeyboardButton("📏 Set Length", callback_data="set_min_length")],
+        [InlineKeyboardButton("⚡ Set Speed", callback_data="set_speed"), 
+         InlineKeyboardButton("🔴 Wipe DB", callback_data="reset_confirm")],
+        [InlineKeyboardButton("« Back to Main", callback_data="back_main")]
+    ])
 
 async def generate_status_msg():
     state = await db.get_state()
@@ -84,323 +95,320 @@ async def test_proxy(proxy_url):
         pass
     return proxy_url, None
 
-# --- HANDLER SETUP ---
-def setup_handlers(client):
-    
-    @client.on(events.NewMessage(pattern='/start'))
-    async def start_cmd(event):
-        if is_admin(event): 
-            await event.respond("**Fragment Control System**", buttons=get_main_menu())
+# --- MESSAGE HANDLERS ---
+@app.on_message(filters.command("start") & is_admin)
+async def start_cmd(client, message):
+    await message.reply_text("**Fragment Control System**", reply_markup=get_main_menu())
 
-    # --- NEW: PROXY UPLOADER & CHECKER ---
-    @client.on(events.NewMessage(pattern='/proxies'))
-    async def proxy_cmd(event):
-        if not is_admin(event): return
-        if not event.is_reply:
-            return await event.respond("⚠️ Reply to a `proxies.txt` file with `/proxies`.")
-            
-        reply = await event.get_reply_message()
-        if not reply.document:
-            return await event.respond("⚠️ Attached message is not a document.")
-            
-        msg = await event.respond("⏳ Downloading proxies...")
-        file_path = await reply.download_media(file="temp_proxies.txt")
-        
-        with open(file_path, "r", encoding="utf-8") as f:
-            raw_proxies = [line.strip() for line in f if line.strip()]
-            
-        os.remove(file_path)
-        
-        if not raw_proxies:
-            return await msg.edit("⚠️ No proxies found in file.")
-            
-        await msg.edit(f"🔍 Testing **{len(raw_proxies)}** proxies concurrently...")
-        
-        # Test all proxies concurrently
-        tasks = [test_proxy(p) for p in raw_proxies]
-        results = await asyncio.gather(*tasks)
-        
-        working_proxies = []
-        latency_board = []
+@app.on_message(filters.command("proxies") & is_admin)
+async def proxy_cmd(client, message):
+    if not message.reply_to_message or not message.reply_to_message.document:
+        return await message.reply_text("⚠️ Reply to a `proxies.txt` file with `/proxies`.")
         
-        for p_url, latency in results:
-            if latency is not None:
-                working_proxies.append(p_url)
-                latency_board.append((p_url, latency))
-                
-        # Sort by fastest latency
-        latency_board.sort(key=lambda x: x[1])
-        
-        # Save working proxies to Redis
-        await db.save_working_proxies(working_proxies)
+    msg = await message.reply_text("⏳ Downloading proxies...")
+    file_path = await message.reply_to_message.download(file_name="temp_proxies.txt")
+    
+    with open(file_path, "r", encoding="utf-8") as f:
+        raw_proxies = [line.strip() for line in f if line.strip()]
         
-        # Format Top 10 Report
-        top_str = "\n".join([f"⏱ `{lat}ms` | {url.split('@')[-1] if '@' in url else url}" for url, lat in latency_board[:10]])
+    os.remove(file_path)
+    if not raw_proxies: return await msg.edit_text("⚠️ No proxies found in file.")
         
-        report = (
-            f"✅ **Proxy Test Complete**\n"
-            f"━━━━━━━━━━━━━━━━\n"
-            f"**Total Tested:** `{len(raw_proxies)}`\n"
-            f"**Working & Saved:** `{len(working_proxies)}`\n\n"
-            f"🏆 **Top Fastest Proxies:**\n{top_str if top_str else 'None'}"
-        )
-        await msg.edit(report, buttons=get_main_menu())
+    await msg.edit_text(f"🔍 Testing **{len(raw_proxies)}** proxies concurrently...")
+    
+    tasks = [test_proxy(p) for p in raw_proxies]
+    results = await asyncio.gather(*tasks)
+    
+    working_proxies = []
+    latency_board = []
+    
+    for p_url, latency in results:
+        if latency is not None:
+            working_proxies.append(p_url)
+            latency_board.append((p_url, latency))
+            
+    latency_board.sort(key=lambda x: x[1])
+    await db.save_working_proxies(working_proxies)
+    
+    top_str = "\n".join([f"⏱ `{lat}ms` | {url.split('@')[-1] if '@' in url else url}" for url, lat in latency_board[:10]])
+    report = (
+        f"✅ **Proxy Test Complete**\n"
+        f"━━━━━━━━━━━━━━━━\n"
+        f"**Total Tested:** `{len(raw_proxies)}`\n"
+        f"**Working & Saved:** `{len(working_proxies)}`\n\n"
+        f"🏆 **Top Fastest Proxies:**\n{top_str if top_str else 'None'}"
+    )
+    await msg.edit_text(report, reply_markup=get_main_menu())
+
+@app.on_message(filters.command("check") & is_admin)
+async def check_cmd(client, message):
+    if len(message.command) < 2: return await message.reply_text("Usage: `/check <word>`")
+    target = message.command[1].lower()
+    msg = await message.reply_text(f"📸 Taking live screenshot of `@{target}` on Fragment...")
+    
+    url = f"https://fragment.com/username/{target}"
+    img_filename = None
+    
+    try:
+        def take_screenshot():
+            from html2image import Html2Image
+            hti = Html2Image(
+                browser_executable='/usr/bin/chromium',
+                custom_flags=['--no-sandbox', '--disable-gpu', '--hide-scrollbars', '--disable-dev-shm-usage']
+            ) 
+            hti.size = (1000, 750) 
+            name = f"{target}_fragment.png"
+            hti.screenshot(url=url, save_as=name)
+            return name
 
+        img_filename = await asyncio.to_thread(take_screenshot)
+        await message.reply_document(document=img_filename, caption=f"**Live Web Snapshot:** `@{target}`")
+        await msg.delete()
+            
+    except Exception as e:
+        try: await msg.edit_text(f"❌ **Screenshot Error:**\n`{str(e)}`")
+        except: pass
+    finally:
+        if img_filename and os.path.exists(img_filename):
+            os.remove(img_filename)
 
-    # --- LIVE HTML SCREENSHOT COMMAND ---
-    @client.on(events.NewMessage(pattern=r'/check\s+([a-zA-Z0-9_]+)'))
-    async def check_cmd(event):
-        if not is_admin(event): return
-        target = event.pattern_match.group(1).lower()
-        msg = await event.respond(f"📸 Taking live screenshot of `@{target}` on Fragment...")
+@app.on_message(filters.command("html") & is_admin)
+async def html_cmd(client, message):
+    if len(message.command) < 2: return await message.reply_text("Usage: `/html <word>`")
+    target = message.command[1].lower()
+    msg = await message.reply_text(f"🔍 Fetching raw HTML for `@{target}` via Chrome Impersonation...")
+    
+    url = f"https://fragment.com/username/{target}"
+    
+    try:
+        async with AsyncSession(impersonate="chrome120") as session:
+            resp = await session.get(url, timeout=15, allow_redirects=True)
+            html_text = resp.text
+            status_code = resp.status_code
+            final_url = str(resp.url)
+                
+        f = io.BytesIO(html_text.encode('utf-8'))
+        f.name = f"{target}_fragment.html"
+        f.seek(0) 
         
-        url = f"https://fragment.com/username/{target}"
-        img_filename = None
+        caption = (f"📄 **Raw Response for** `@{target}`\n"
+                   f"**Requested URL:** `{url}`\n"
+                   f"**Final URL:** `{final_url}`\n"
+                   f"**Status Code:** `{status_code}`")
         
-        try:
-            def take_screenshot():
-                from html2image import Html2Image
-                hti = Html2Image(
-                    browser_executable='/usr/bin/chromium',
-                    custom_flags=['--no-sandbox', '--disable-gpu', '--hide-scrollbars', '--disable-dev-shm-usage']
-                ) 
-                hti.size = (1000, 750) 
-                name = f"{target}_fragment.png"
-                hti.screenshot(url=url, save_as=name)
-                return name
+        await message.reply_document(document=f, caption=caption)
+        await msg.delete() 
+    except Exception as e:
+        try: await msg.edit_text(f"❌ **Error fetching HTML:** `{str(e)}`")
+        except: pass
 
-            img_filename = await asyncio.to_thread(take_screenshot)
-            
-            await client.send_file(event.chat_id, file=img_filename, caption=f"**Live Web Snapshot:** `@{target}`")
-            await msg.delete()
-                
-        except Exception as e:
-            try: await msg.edit(f"❌ **Screenshot Error:**\n`{str(e)}`")
-            except: pass
-        finally:
-            if img_filename and os.path.exists(img_filename):
-                os.remove(img_filename)
+@app.on_message(filters.command("upload") & is_admin)
+async def upload_cmd(client, message):
+    if not message.reply_to_message or not message.reply_to_message.document:
+        return await message.reply_text("Reply to a `.txt` file.")
+    
+    msg = await message.reply_text("Downloading...")
+    await message.reply_to_message.download(file_name="words.txt")
+    await msg.edit_text("✅ Uploaded. Go to Settings -> Load Database.", reply_markup=get_main_menu())
 
 
-    # --- HTML DEBUG COMMAND (With Redirect Tracking) ---
-    @client.on(events.NewMessage(pattern=r'/html\s+([a-zA-Z0-9_]+)'))
-    async def html_cmd(event):
-        if not is_admin(event): return
-        target = event.pattern_match.group(1).lower()
-        msg = await event.respond(f"🔍 Fetching raw HTML for `@{target}` via Chrome Impersonation...")
-        
-        url = f"https://fragment.com/username/{target}"
-        
-        try:
-            async with AsyncSession(impersonate="chrome120") as session:
-                resp = await session.get(url, timeout=15, allow_redirects=True)
-                html_text = resp.text
-                status_code = resp.status_code
-                final_url = str(resp.url)
-                    
-            f = io.BytesIO(html_text.encode('utf-8'))
-            f.name = f"{target}_fragment.html"
-            f.seek(0) 
-            
-            caption = (
-                f"📄 **Raw Response for** `@{target}`\n"
-                f"**Requested URL:** `{url}`\n"
-                f"**Final URL:** `{final_url}`\n"
-                f"**Status Code:** `{status_code}`\n"
-            )
-            
-            await client.send_file(event.chat_id, file=f, caption=caption)
-            await msg.delete() 
-            
-        except Exception as e:
-            try: await msg.edit(f"❌ **Error fetching HTML:** `{str(e)}`")
-            except: pass
+# --- STRING SESSION STATE MACHINE ---
+# Pyrogram doesn't have native "conversation" handlers, so we use Futures
+input_waiters = {}
 
-    # --- WORDS UPLOAD COMMAND ---
-    @client.on(events.NewMessage(pattern='/upload'))
-    async def upload_cmd(event):
-        if not is_admin(event): return
-        if not event.is_reply: 
-            return await event.respond("Reply to a `.txt` file.")
-        reply = await event.get_reply_message()
-        if not reply.document: 
-            return await event.respond("Not a document.")
-        
-        wait = await event.respond("Downloading...")
-        await reply.download_media(file="words.txt")
-        await wait.edit("✅ Uploaded. Go to Settings -> Load Database.", buttons=get_main_menu())
+@app.on_message(filters.text & is_admin, group=-1)
+async def catch_input(client, message):
+    chat_id = message.chat.id
+    if chat_id in input_waiters and not input_waiters[chat_id].done():
+        input_waiters[chat_id].set_result(message.text)
+        message.stop_propagation()
 
-    # --- SESSION GENERATOR ---
-    @client.on(events.NewMessage(pattern='/getstring'))
-    async def pyrogram_string_cmd(event):
-        if not is_admin(event): return
-        
-        async with client.conversation(event.chat_id, timeout=300) as conv:
-            try:
-                await conv.send_message("🛠 **Pyrogram String Session Generator**\n\nEnter your `API_ID`:")
-                api_id = int((await conv.get_response()).text.strip())
+async def get_response(chat_id, timeout=300):
+    loop = asyncio.get_running_loop()
+    future = loop.create_future()
+    input_waiters[chat_id] = future
+    try: return await asyncio.wait_for(future, timeout)
+    finally: del input_waiters[chat_id]
 
-                await conv.send_message("Enter your `API_HASH`:")
-                api_hash = (await conv.get_response()).text.strip()
+@app.on_message(filters.command("getstring") & is_admin)
+async def pyrogram_string_cmd(client, message):
+    chat_id = message.chat.id
+    try:
+        await message.reply_text("🛠 **Pyrogram Session Generator**\nEnter your `API_ID`:")
+        api_id = int((await get_response(chat_id)).strip())
 
-                await conv.send_message("Enter the **Phone Number** (e.g., +1234567890):")
-                phone = (await conv.get_response()).text.replace(" ", "").strip()
+        await message.reply_text("Enter your `API_HASH`:")
+        api_hash = (await get_response(chat_id)).strip()
 
-                await conv.send_message("⏳ Requesting OTP from Telegram...")
-                
-                from pyrogram import Client
-                from pyrogram.errors import SessionPasswordNeeded
+        await message.reply_text("Enter the **Phone Number** (e.g., +1234567890):")
+        phone = (await get_response(chat_id)).replace(" ", "").strip()
 
-                app = Client("temp_session", api_id=api_id, api_hash=api_hash, in_memory=True)
-                await app.connect()
-                
-                sent_code = await app.send_code(phone)
-                
-                await conv.send_message("📥 **Code Sent!**\n\n⚠️ **CRITICAL:** You MUST enter the code with spaces between numbers.\nExample: `1 2 3 4 5`")
-                otp_code = (await conv.get_response()).text.replace(" ", "").strip()
-                
-                try:
-                    await app.sign_in(phone, sent_code.phone_code_hash, otp_code)
-                except SessionPasswordNeeded:
-                    await conv.send_message("🔐 **2FA Password Required.**\nEnter your Cloud Password:")
-                    pwd = (await conv.get_response()).text.strip()
-                    await app.check_password(pwd)
-                
-                string_session = await app.export_session_string()
-                await conv.send_message(f"✅ **String Session Generated!**\n\n`{string_session}`\n\n⚠️ Keep this secret.")
-            except asyncio.TimeoutError:
-                await conv.send_message("❌ **Timeout.** Run `/getstring` again.")
-            except Exception as e:
-                await conv.send_message(f"❌ **Error:** `{str(e)}`")
-            finally:
-                if 'app' in locals():
-                    try: await app.disconnect()
-                    except: pass
+        await message.reply_text("⏳ Requesting OTP from Telegram...")
+        
+        from pyrogram import Client as TmpClient
+        from pyrogram.errors import SessionPasswordNeeded
 
-    # --- DASHBOARD CALLBACKS ---
-    async def _load_words(event):
-        try:
-            with open("words.txt", "r", encoding="utf-8") as f: 
-                all_lines = [line.strip().lower() for line in f if line.strip()]
-        except Exception:
-            return await event.edit("❌ `words.txt` not found. Upload it first.")
-            
-        if not all_lines: 
-            return await event.edit("Empty file.")
-            
-        state = await db.get_state()
-        min_length = int(state.get("min_length", 4))
-            
-        CHUNK = 200000
-        current = all_lines[:CHUNK]
-        remaining = all_lines[CHUNK:]
+        tmp_app = TmpClient("temp_session", api_id=api_id, api_hash=api_hash, in_memory=True)
+        await tmp_app.connect()
         
-        pattern = re.compile(rf'^[a-z0-9_]{{{min_length},32}}$')
-        valid = {w for w in current if pattern.match(w)}
+        sent_code = await tmp_app.send_code(phone)
         
-        r = await db.get_redis()
-        done = await r.smembers("frag:done")
-        to_q = list(valid - done)
+        await message.reply_text("📥 **Code Sent!**\n⚠️ Enter code with spaces (e.g., `1 2 3 4 5`):")
+        otp_code = (await get_response(chat_id)).replace(" ", "").strip()
         
-        if to_q:
-            pipe = r.pipeline()
-            for i in range(0, len(to_q), 1000): 
-                pipe.lpush("frag:queue", *to_q[i:i+1000])
-            await pipe.execute()
-            
-        with open("words.txt", "w", encoding="utf-8") as f: 
-            f.write("\n".join(remaining))
-            
-        await db.set_state(total=len(valid))
-        await event.edit(f"✅ Loaded {len(to_q):,} words (Min length: {min_length}).", buttons=get_main_menu())
-
-    @client.on(events.CallbackQuery())
-    async def button_handler(event):
-        if not is_admin(event): return
-        try: await event.answer()
-        except: pass
-        data = event.data.decode('utf-8')
+        try:
+            await tmp_app.sign_in(phone, sent_code.phone_code_hash, otp_code)
+        except SessionPasswordNeeded:
+            await message.reply_text("🔐 **2FA Password Required:**")
+            pwd = (await get_response(chat_id)).strip()
+            await tmp_app.check_password(pwd)
+        
+        string_session = await tmp_app.export_session_string()
+        await message.reply_text(f"✅ **Session Generated!**\n\n`{string_session}`\n\n⚠️ Keep this secret.")
+    except asyncio.TimeoutError:
+        await message.reply_text("❌ **Timeout.** Run `/getstring` again.")
+    except Exception as e:
+        await message.reply_text(f"❌ **Error:** `{str(e)}`")
+    finally:
+        if 'tmp_app' in locals():
+            try: await tmp_app.disconnect()
+            except: pass
 
+# --- CALLBACK ROUTER ---
+@app.on_callback_query(is_admin)
+async def button_handler(client, query):
+    data = query.data
+    
+    try:
         if data == "back_main": 
-            await event.edit("**Fragment Control System**", buttons=get_main_menu())
+            await query.edit_message_text("**Fragment Control System**", reply_markup=get_main_menu())
             
         elif data == "menu_settings": 
-            await event.edit("**System Settings**", buttons=get_settings_menu())
+            await query.edit_message_text("**System Settings**", reply_markup=get_settings_menu())
             
         elif data == "set_min_length":
-            await event.edit("📏 **Select Minimum Word Length:**", buttons=[
-                [Button.inline("4 Letters", b"min_len_4"), Button.inline("5 Letters", b"min_len_5")],
-                [Button.inline("6 Letters", b"min_len_6"), Button.inline("7 Letters", b"min_len_7")],
-                [Button.inline("« Back", b"menu_settings")]
+            kb = InlineKeyboardMarkup([
+                [InlineKeyboardButton("4 Letters", callback_data="min_len_4"), InlineKeyboardButton("5 Letters", callback_data="min_len_5")],
+                [InlineKeyboardButton("6 Letters", callback_data="min_len_6"), InlineKeyboardButton("7 Letters", callback_data="min_len_7")],
+                [InlineKeyboardButton("« Back", callback_data="menu_settings")]
             ])
+            await query.edit_message_text("📏 **Select Minimum Word Length:**", reply_markup=kb)
             
         elif data.startswith("min_len_"):
             new_len = int(data.split("_")[2])
             await db.set_state(min_length=new_len)
-            await event.edit(f"✅ Filter updated: Sniping words with at least `{new_len}` letters.", buttons=get_settings_menu())
+            await query.edit_message_text(f"✅ Filter updated to `{new_len}` letters.", reply_markup=get_settings_menu())
             
         elif data == "load_words": 
-            await event.edit("⏳ Processing and loading chunk...")
-            await _load_words(event)
+            await query.edit_message_text("⏳ Processing and loading chunk...")
+            try:
+                with open("words.txt", "r", encoding="utf-8") as f: 
+                    all_lines = [line.strip().lower() for line in f if line.strip()]
+            except Exception:
+                return await query.edit_message_text("❌ `words.txt` not found. Upload it first.")
+                
+            if not all_lines: return await query.edit_message_text("Empty file.")
+                
+            state = await db.get_state()
+            min_length = int(state.get("min_length", 4))
+                
+            CHUNK = 200000
+            current = all_lines[:CHUNK]
+            remaining = all_lines[CHUNK:]
+            
+            pattern = re.compile(rf'^[a-z0-9_]{{{min_length},32}}$')
+            valid = {w for w in current if pattern.match(w)}
+            
+            r = await db.get_redis()
+            done = await r.smembers("frag:done")
+            to_q = list(valid - done)
+            
+            if to_q:
+                pipe = r.pipeline()
+                for i in range(0, len(to_q), 1000): pipe.lpush("frag:queue", *to_q[i:i+1000])
+                await pipe.execute()
+                
+            with open("words.txt", "w", encoding="utf-8") as f: 
+                f.write("\n".join(remaining))
+                
+            await db.set_state(total=len(valid))
+            await query.edit_message_text(f"✅ Loaded {len(to_q):,} words.", reply_markup=get_main_menu())
             
         elif data == "start_scan": 
             await db.set_state(running="1", paused="0")
-            await event.edit("▶️ Scanner Running", buttons=get_main_menu())
+            await query.edit_message_text("▶️ Scanner Running", reply_markup=get_main_menu())
             
         elif data == "pause_scan":
             s = await db.get_state()
             p = "0" if s.get("paused") == "1" else "1"
             await db.set_state(paused=p)
-            await event.edit("⏸ Scanner Paused" if p=="1" else "▶️ Resumed", buttons=get_main_menu())
+            await query.edit_message_text("⏸ Scanner Paused" if p=="1" else "▶️ Resumed", reply_markup=get_main_menu())
             
         elif data == "stop_scan":
             await db.set_state(running="0", paused="0")
-            await event.edit("⏹ Scanner Stopped", buttons=get_main_menu())
+            await query.edit_message_text("⏹ Scanner Stopped", reply_markup=get_main_menu())
             
         elif data in ("show_status", "refresh_status"):
-            try:
-                msg = await generate_status_msg()
-                await event.edit(msg, buttons=[[Button.inline("🔄 Refresh", b"refresh_status")], [Button.inline("« Back", b"back_main")]])
-            except Exception as e:
-                if "not modified" in str(e).lower() or "MessageNotModifiedError" in str(type(e)): pass
-                else: print(f"Status Error: {e}")
+            msg = await generate_status_msg()
+            kb = InlineKeyboardMarkup([[InlineKeyboardButton("🔄 Refresh", callback_data="refresh_status")], [InlineKeyboardButton("« Back", callback_data="back_main")]])
+            try: await query.edit_message_text(msg, reply_markup=kb)
+            except MessageNotModified: pass
             
         elif data == "set_speed":
-            await event.edit("⚡ **Select Concurrent Workers:**", buttons=[
-                [Button.inline("10", b"spd_10"), Button.inline("20", b"spd_20")], 
-                [Button.inline("30", b"spd_30"), Button.inline("50", b"spd_50")], 
-                [Button.inline("« Back", b"menu_settings")]
+            kb = InlineKeyboardMarkup([
+                [InlineKeyboardButton("10", callback_data="spd_10"), InlineKeyboardButton("20", callback_data="spd_20")], 
+                [InlineKeyboardButton("30", callback_data="spd_30"), InlineKeyboardButton("50", callback_data="spd_50")], 
+                [InlineKeyboardButton("« Back", callback_data="menu_settings")]
             ])
+            await query.edit_message_text("⚡ **Select Concurrent Workers:**", reply_markup=kb)
             
         elif data.startswith("spd_"):
             await db.set_concurrency(int(data.split("_")[1]))
-            await event.edit("✅ Speed Updated", buttons=get_settings_menu())
+            await query.edit_message_text("✅ Speed Updated", reply_markup=get_settings_menu())
             
         elif data == "export_files":
-            await event.edit("⏳ Generating text files...")
+            await query.edit_message_text("⏳ Generating text files...")
             exported_count = 0
             
-            # Export all tracking sets including the new 'available' one
             for s in ["taken", "unavailable", "sold", "forsale", "auction", "available"]:
                 lst = sorted(list(await (getattr(db, f"get_all_{s}")())))
                 if lst:
                     f = io.BytesIO("\n".join(lst).encode('utf-8'))
                     f.name = f"{s}.txt"
-                    await client.send_file(event.chat_id, file=f)
+                    await client.send_document(query.message.chat.id, document=f)
                     exported_count += 1
             
             if os.path.exists("other.txt"):
-                await client.send_file(event.chat_id, "other.txt", caption="other.txt (Unknown HTML Responses)")
+                await client.send_document(query.message.chat.id, document="other.txt", caption="Unknown HTML Responses")
                 exported_count += 1
                     
             if exported_count > 0:
-                await event.edit(f"✅ Export complete! Sent {exported_count} files.", buttons=get_main_menu())
+                await query.edit_message_text(f"✅ Export complete! Sent {exported_count} files.", reply_markup=get_main_menu())
             else:
-                await event.edit("⚠️ No data to export yet. Start a scan first!", buttons=get_main_menu())
+                await query.edit_message_text("⚠️ No data to export yet.", reply_markup=get_main_menu())
                 
         elif data == "reset_confirm": 
-            await event.edit("⚠️ WIPE ALL REDIS DATA?", buttons=[[Button.inline("CONFIRM WIPE", b"reset_do")], [Button.inline("Cancel", b"menu_settings")]])
+            kb = InlineKeyboardMarkup([[InlineKeyboardButton("CONFIRM WIPE", callback_data="reset_do")], [InlineKeyboardButton("Cancel", callback_data="menu_settings")]])
+            await query.edit_message_text("⚠️ WIPE ALL REDIS DATA?", reply_markup=kb)
             
         elif data == "reset_do":
             await db.flush_all()
-            await event.edit("💣 Memory purged successfully.", buttons=get_settings_menu())
+            await query.edit_message_text("💣 Memory purged successfully.", reply_markup=get_settings_menu())
+            
+    except Exception as e:
+        if not isinstance(e, MessageNotModified):
+            print(f"Callback Error: {e}")
+
+# If run directly as a script
+if __name__ == "__main__":
+    from worker import run_worker
+    
+    async def main_loop():
+        await app.start()
+        print("🤖 Pyrogram Bot Started!")
+        asyncio.create_task(run_worker())
+        from pyrogram import idle
+        await idle()
+        await app.stop()
+        
+    app.run(main_loop())