Update bot.py

bot.py

@@ -126,6 +126,154 @@ async def proxy_cmd(client, message):
     
     await msg.edit_text(f"✅ Saved **{len(working)}** working proxies to memory.", reply_markup=get_dynamic_menu())
 
+@app.on_message(filters.command("upload") & is_admin)
+async def upload_cmd(client, message):
+    # Support both replying to a file, OR sending the file with the command as a caption
+    target_message = message if message.document else message.reply_to_message
+    
+    if not target_message or not target_message.document:
+        return await message.reply_text("⚠️ Send a `.txt` file with the caption `/upload`, or reply to a file with `/upload`.")
+        
+    msg = await message.reply_text("⏳ Downloading `words.txt`...")
+    
+    try:
+        # Pyrogram downloads to a hidden folder. We capture the exact path.
+        file_path = await target_message.download()
+        
+        # Move it to the root directory where the bot is looking for it and overwrite the old one
+        if os.path.exists("words.txt"):
+            os.remove("words.txt")
+        os.replace(file_path, "words.txt")
+        
+        await msg.edit_text("✅ **Uploaded!**\nGo to System Settings -> Load Words to add them to the queue.", reply_markup=get_dynamic_menu())
+    except Exception as e:
+        await msg.edit_text(f"❌ **Upload Error:** `{str(e)}`")
+        log.error(f"Upload Error: {str(e)}")
+
+@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)
+
+@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) 
+        
+        caption = (f"📄 **Raw Response for** `@{target}`\n"
+                   f"**Requested URL:** `{url}`\n"
+                   f"**Final URL:** `{final_url}`\n"
+                   f"**Status Code:** `{status_code}`")
+        
+        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
+
+
+# --- STRING SESSION STATE MACHINE ---
+input_waiters = {}
+
+@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()
+
+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]
+
+@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 message.reply_text("Enter your `API_HASH`:")
+        api_hash = (await get_response(chat_id)).strip()
+
+        await message.reply_text("Enter the **Phone Number** (e.g., +1234567890):")
+        phone = (await get_response(chat_id)).replace(" ", "").strip()
+
+        await message.reply_text("⏳ Requesting OTP from Telegram...")
+        
+        from pyrogram import Client as TmpClient
+        from pyrogram.errors import SessionPasswordNeeded
+
+        tmp_app = TmpClient("temp_session", api_id=api_id, api_hash=api_hash, in_memory=True)
+        await tmp_app.connect()
+        
+        sent_code = await tmp_app.send_code(phone)
+        
+        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()
+        
+        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
+
 # --- UI CALLBACKS ---
 @app.on_callback_query(is_admin)
 async def button_handler(client, query):
@@ -160,6 +308,19 @@ async def button_handler(client, query):
             log.info("Scanner Stopped")
             await query.edit_message_text("⏹ Scanner Stopped", reply_markup=get_dynamic_menu())
             
+        elif data == "set_min_length":
+            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])
+            state.min_length = new_len
+            await query.edit_message_text(f"✅ Filter updated to `{new_len}` letters.", reply_markup=get_settings_menu())
+            
         elif data == "load_words": 
             await query.edit_message_text("⏳ Processing and loading chunk into memory...")
             try:
@@ -182,6 +343,18 @@ async def button_handler(client, query):
             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":
+            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_"):
+            state.concurrency = int(data.split("_")[1])
+            await query.edit_message_text("✅ Speed Updated", reply_markup=get_settings_menu())
 
         elif data == "export_files":
             await query.edit_message_text("⏳ Preparing files from disk...")