Update app.py

app.py

@@ -181,6 +181,209 @@ async def handler_doc(event):
 user_context = {}  # make sure this is defined once globally
 
 
+@bot.on(events.NewMessage(pattern="/cused"))
+async def correction_used_handler(event):
+    if not is_owner(event): return
+    user_context[event.sender_id] = {"mode": "correct_used", "links": []}
+    await event.reply("🛠 Correction mode ON for used links.\nSend all links (one per line). Use /doneused when finished.")
+
+
+@bot.on(events.NewMessage(func=lambda e: e.text and e.sender_id in user_context and not e.raw_text.startswith("/doneused")))
+async def collect_links(event):
+    if not is_owner(event): return
+    ctx = user_context.get(event.sender_id)
+    if ctx and ctx.get("mode") == "correct_used":
+        links = [l.strip() for l in event.text.split() if l.startswith("http")]
+        if links:
+            ctx["links"].extend(links)
+            await event.reply(f"🔗 Collected {len(links)} link(s). Send more or use /doneused.")
+        else:
+            await event.reply("⚠️ No valid links detected. Please send links starting with http.")
+
+
+import os
+import nest_asyncio
+import logging
+from flask import Flask
+from threading import Thread
+from pymongo import MongoClient
+from telethon import TelegramClient, events
+
+# Enable nested event loops for Flask + Telethon
+nest_asyncio.apply()
+logging.basicConfig(level=logging.INFO)
+
+# === ENVIRONMENT VARIABLES ===
+API_ID = int(os.getenv("API_ID", "3704772"))
+API_HASH = os.getenv("API_HASH", "b8e50a035abb851c0dd424e14cac4c06")
+BOT_TOKEN = os.getenv("TELEGRAM_TOKEN")  # Bot token, NOT user session
+OWNER_ID = int(os.getenv("OWNER_ID"))
+MONGO_URI = os.getenv("MONGO_URI")
+PORT = int(os.getenv("PORT", 7860))
+
+# === MongoDB ===
+client = MongoClient(MONGO_URI)
+db = client.teleg4am_reelssss
+a_raw = db.raw_links
+a_reacted = db.reacted_links
+last_alerts = {"raw": -1, "reacted": -1}
+# Add indexes to improve performance (run only once on startup)
+a_raw.create_index([("link", 1)], unique=True)
+a_raw.create_index([("used", 1)])
+a_reacted.create_index([("link", 1)], unique=True)
+a_reacted.create_index([("used", 1)])
+
+# === Flask App ===
+app = Flask(__name__)
+
+@app.route("/")
+def home():
+    return "🤖 Bot is running!"
+
+@app.route("/status")
+def status():
+    raw = a_raw.count_documents({"used": False})
+    reacted = a_reacted.count_documents({"used": False})
+    return {"raw_links_left": raw, "reacted_links_left": reacted}, 200
+
+# === Telethon Bot Setup (Bot Mode) ===
+bot = TelegramClient("bot_session", API_ID, API_HASH).start(bot_token=BOT_TOKEN)
+user_context = {}
+
+# === Helper: Check if sender is owner ===
+def is_owner(event):
+    return event.sender_id == OWNER_ID
+
+# === Command Handlers ===
+@bot.on(events.NewMessage(pattern="/start|/count"))
+async def count_handler(event):
+    if not is_owner(event): return
+    raw = a_raw.count_documents({"used": False})
+    reacted = a_reacted.count_documents({"used": False})
+    await event.reply(f"📊 Raw: {raw}\n📊 Reacted: {reacted}")
+
+@bot.on(events.NewMessage(pattern="/raw"))
+async def raw_handler(event):
+    if not is_owner(event): return
+    user_context[event.sender_id] = {"mode": "raw", "links": []}
+    await event.reply("📥 Send raw links (one per line). Use /done to save.")
+
+@bot.on(events.NewMessage(pattern="/reacted"))
+async def reacted_handler(event):
+    if not is_owner(event): return
+    user_context[event.sender_id] = {"mode": "reacted", "links": []}
+    await event.reply("📥 Send reacted links (one per line). Use /done to save.")
+
+@bot.on(events.NewMessage(pattern="/done"))
+async def done_handler(event):
+    if not is_owner(event): return
+    ctx = user_context.pop(event.sender_id, None)
+    if not ctx or not ctx["links"]:
+        return await event.reply("❌ Nothing to save.")
+    
+    col = a_raw if ctx["mode"] == "raw" else a_reacted
+    inserted = 0
+    for link in ctx["links"]:
+        if col.count_documents({"link": link}) == 0:
+            col.insert_one({"link": link, "used": False})
+            inserted += 1
+
+    await event.reply(f"✅ Saved {inserted} new {ctx['mode']} link(s).")
+    await check_and_alert(ctx["mode"], col)
+
+@bot.on(events.NewMessage(pattern="/cleanup"))
+async def cleanup_handler(event):
+    if not is_owner(event): return
+    raw_deleted = a_raw.delete_many({"used": True}).deleted_count
+    reacted_deleted = a_reacted.delete_many({"used": True}).deleted_count
+    await event.reply(f"🗑️ Deleted:\nRaw: {raw_deleted}\nReacted: {reacted_deleted}")
+
+@bot.on(events.NewMessage(func=lambda e: e.text and e.sender_id in user_context))
+async def link_collector(event):
+    if not is_owner(event): return
+    ctx = user_context[event.sender_id]
+    links = [l.strip() for l in event.text.split() if l.startswith("http")]
+    ctx["links"].extend(links)
+    await event.reply(f"🔗 {len(links)} link(s) added.")
+
+# === Alert System ===
+async def check_and_alert(pool: str, col):
+    left = col.count_documents({"used": False})
+    if 1 <= left <= 5 and last_alerts[pool] != left:
+        last_alerts[pool] = left
+        try:
+            await bot.send_message(OWNER_ID, f"⚠️ Only {left} {pool} link(s) left!")
+        except Exception as e:
+            logging.error(f"❌ Alert failed: {e}")
+import os
+import asyncio
+import subprocess
+from telethon import TelegramClient, events
+from telethon.tl.types import DocumentAttributeFilename
+
+@bot.on(events.NewMessage(pattern="/bash"))
+async def bash(event):
+    cmd = event.message.text.split(None, 1)
+    if len(cmd) < 2:
+        return await event.reply("❌ Usage: /bash <command>")
+    process = await asyncio.create_subprocess_shell(
+        cmd[1],
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await process.communicate()
+
+    output = stdout.decode() or "✅ No output"
+    error = stderr.decode()
+
+    await event.reply(f"📥 Code:\n`{cmd[1]}`\n\n📤 Output:\n```\n{output.strip()}\n```"
+                      + (f"\n❌ Error:\n```\n{error.strip()}\n```" if error else ""))
+
+@bot.on(events.NewMessage(pattern="/dl"))
+async def dl(event):
+    reply = await event.get_reply_message()
+    if not reply or not reply.media:
+        return await event.reply("❌ Reply to a media file to download it.")
+    
+    path = await bot.download_media(reply)
+    await event.reply(f"✅ File downloaded to `{path}`")
+
+@bot.on(events.NewMessage(pattern="/ul"))
+async def ul(event):
+    args = event.raw_text.split(maxsplit=1)
+    if len(args) != 2:
+        return await event.reply("❌ Usage: /ul <full_filename>")
+
+    filepath = args[1].strip()
+    if not os.path.exists(filepath):
+        return await event.reply("❌ File not found.")
+
+    await bot.send_file(event.chat_id, filepath, caption=f"📤 Uploaded: `{filepath}`")
+
+@bot.on(events.NewMessage(pattern=r'^/doc(?:\s+(.+))?'))
+async def handler_doc(event):
+    reply = await event.get_reply_message()
+    filename = event.pattern_match.group(1)
+
+    if not reply or not reply.text:
+        await event.reply("❌ Please reply to a text message to save as a file.")
+        return
+
+    if not filename:
+        await event.reply("❌ Usage: `/doc filename.txt`", parse_mode='md')
+        return
+
+    try:
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(reply.text)
+
+        await bot.send_file(event.chat_id, filename, caption=f"✅ Saved reply to `{filename}`", force_document=True)
+        os.remove(filename)
+    except Exception as e:
+        await event.reply(f"❌ Error: {e}")
+user_context = {}  # make sure this is defined once globally
+
+
 @bot.on(events.NewMessage(pattern="/cused"))
 async def correction_used_handler(event):
     if not is_owner(event): return
@@ -251,6 +454,39 @@ def run_flask():
 
 import asyncio
 
+async def auto_alert_loop():
+    while True:
+        try:
+            await check_and_alert("raw", a_raw)
+            await check_and_alert("reacted", a_reacted)
+        except Exception as e:
+            logging.error(f"Auto-alert loop error: {e}")
+        await asyncio.sleep(30)  # Check every 30 seconds
+
+async def main():
+    if not all([API_ID, API_HASH, BOT_TOKEN, MONGO_URI]):
+        raise RuntimeError("❌ Missing ENV vars: API_ID, API_HASH, TELEGRAM_TOKEN, or MONGO_URI")
+
+    # Start background alert loop
+    asyncio.create_task(auto_alert_loop())
+
+    # Start Flask in a separate thread (or you can replace with FastAPI if needed)
+    Thread(target=run_flask).start()
+
+    # Start the bot
+    print("✅ Starting bot...")
+    await bot.start(bot_token=BOT_TOKEN)
+    await bot.run_until_disconnected()
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())
+# === Flask Server ===
+def run_flask():
+    app.run(host="0.0.0.0", port=PORT)
+
+import asyncio
+
 async def auto_alert_loop():
     while True:
         try: