Upload main.py

main.py

@@ -1294,4 +1294,807 @@ class Bot:
 
     async def check_target(self, event: Any, actor: Info, target: Target, strict: bool) -> bool:
         if target.id == self.me.id:
-            await self.say(event, "لا يمكنني تنفيذ
+            await self.say(event, "لا يمكنني تنفيذ ذلك على نفسي.")
+            return False
+        if target.id == actor.user_id:
+            await self.say(event, "لا يمكنك تنفيذ ذلك على نفسك.")
+            return False
+        if not strict:
+            return True
+        tinfo = await self.perms.info(event.chat_id, target.peer, target.id)
+        if tinfo.is_creator:
+            await self.say(event, "لا يمكن تنفيذ الأمر على مالك المجموعة.")
+            return False
+        if tinfo.is_admin and tinfo.rank >= actor.rank:
+            await self.say(event, "لا يمكن تنفيذ الأمر على مشرف بصلاحيات مساوية أو أعلى من صلاحياتك.")
+            return False
+        return True
+
+    # ---- registration
+    def register(self) -> None:
+        self.client.add_event_handler(self.on_message, events.NewMessage(incoming=True))
+        self.client.add_event_handler(self.on_callback, events.CallbackQuery())
+
+    # ---- message router
+    async def on_message(self, event: Any) -> None:
+        try:
+            if event.is_private:
+                await self.on_private(event)
+                return
+            if not event.is_group or event.chat_id is None:
+                return
+            msg = event.message
+            text = msg.raw_text or ""
+            anon = self.is_anon(event)
+            group = await self.db.group(event.chat_id)
+            sender = None
+            if not anon:
+                sender = msg.sender
+                if sender is not None:
+                    self.bg(self.db.remember_user(sender))
+                if await self.customs.capture(event):
+                    return
+                if await self.protection.check(event, group, sender):
+                    return
+            first = text.split("\n", 1)[0][:200]
+            if first and not first.startswith("/"):
+                cmd, arg = parse_command(first)
+                if cmd:
+                    await self.dispatch(event, cmd, arg)
+                    return
+                if not anon and len(first) <= 100 and await self.try_custom(event, norm(first), group):
+                    return
+        except Exception:
+            log.exception("on_message failed")
+
+    async def on_private(self, event: Any) -> None:
+        text = (event.message.raw_text or "").strip()
+        if not text.startswith("/start"):
+            return
+        url = ("https://t.me/%s?startgroup=true&admin=delete_messages+restrict_members+pin_messages+invite_users"
+               % (self.me.username or ""))
+        await self.say(
+            event,
+            "مرحباً بك 👋\nأنا بوت مخصص لإدارة المجموعات.\n"
+            "أضفني إلى مجموعتك وارفعني مشرفاً، ثم اكتب: الاوامر",
+            buttons=[[Button.url("➕ إضافة البوت إلى مجموعة", url)]],
+        )
+
+    async def try_custom(self, event: Any, name: str, group: Dict[str, Any]) -> bool:
+        items = await self.db.customs_of(event.chat_id)
+        if not items:
+            return False
+        doc = items.get(("command", name)) or items.get(("reply", name))
+        if not doc:
+            return False
+        if ("c:" + name) in group["locks"]:
+            actor = await self.actor_info(event)
+            if not actor.is_admin:
+                return True
+        await self.customs.send(event, doc)
+        return True
+
+    # ---- dispatcher
+    async def dispatch(self, event: Any, cmd: str, arg: str) -> None:
+        try:
+            if cmd in MOD_CMDS:
+                await self.c_moderate(event, cmd, arg)
+            elif cmd == "warn":
+                await self.c_warn(event, arg)
+            elif cmd == "unwarn":
+                await self.c_unwarn(event, arg)
+            elif cmd == "warns":
+                await self.c_warns(event, arg)
+            elif cmd == "clearwarns":
+                await self.c_clearwarns(event, arg)
+            elif cmd == "id":
+                await self.c_id(event, arg, False)
+            elif cmd == "kash":
+                await self.c_id(event, arg, True)
+            elif cmd == "calc":
+                await self.c_calc(event, arg)
+            elif cmd == "date":
+                await self.c_date(event, arg)
+            elif cmd in ("grp", "owners", "managers", "admins"):
+                await self.c_staff(event, cmd, arg)
+            elif cmd == "mytitle":
+                await self.c_mytitle(event, arg)
+            elif cmd in ("lock", "unlock"):
+                await self.c_lock(event, arg, cmd == "lock")
+            elif cmd in ("enable", "disable"):
+                await self.c_enable(event, arg, cmd == "enable")
+            elif cmd == "menu":
+                text, rows = self.menu.main()
+                await self.say(event, text, buttons=rows)
+            elif cmd == "settings":
+                actor = await self.gate(event, None, arg)
+                if actor:
+                    idx = [s[0] for s in SECTIONS].index("settings")
+                    text, rows = await self.menu.section(idx, event.chat_id)
+                    await self.say(event, text, buttons=rows)
+            elif cmd == "addword":
+                await self.c_addword(event, arg)
+            elif cmd == "delword":
+                await self.c_delword(event, arg)
+            elif cmd == "words":
+                await self.c_words(event, arg)
+            elif cmd == "delete":
+                await self.c_delete(event, arg)
+            elif cmd == "pin":
+                await self.c_pin(event, arg, True)
+            elif cmd == "unpin":
+                await self.c_pin(event, arg, False)
+            elif cmd in ("addreply", "editreply", "addcmd", "editcmd", "delreply", "delcmd"):
+                actor = await self.gate(event, None, arg)
+                if not actor:
+                    return
+                kind = "reply" if cmd.endswith("reply") else "command"
+                if cmd.startswith("del"):
+                    await self.customs.delete(event, kind, arg)
+                else:
+                    await self.customs.begin(event, kind, arg, cmd.startswith("edit"))
+            elif cmd in ("replies", "cmds"):
+                actor = await self.gate(event, None, arg)
+                if actor:
+                    await self.say(event, await self.customs.list_text(
+                        event.chat_id, "reply" if cmd == "replies" else "command"))
+            elif cmd == "rule":
+                await self.c_rule(event, arg)
+            elif cmd == "rules":
+                actor = await self.gate(event, None, arg)
+                if actor:
+                    await self.say(event, self.warnings.rules_text(await self.db.group(event.chat_id)))
+            elif cmd == "setspam":
+                await self.c_setspam(event, arg)
+            elif cmd == "setmute":
+                await self.c_setmute(event, arg)
+        except FloodWaitError as e:
+            await self.say(event, err_text(e))
+        except RPCError as e:
+            await self.say(event, err_text(e))
+        except ValueError:
+            log.warning("command %s failed", cmd, exc_info=True)
+            await self.say(event, "تعذر تنفيذ الأمر. تأكد أن المجموعة سوبر جروب.")
+        except Exception:
+            log.exception("command %s crashed", cmd)
+
+    # ---- moderation commands
+    async def c_moderate(self, event: Any, cmd: str, arg: str) -> None:
+        actor = await self.gate(event, "ban_users", arg)
+        if not actor:
+            return
+        target, err = await self.resolver.resolve(event, arg)
+        if err or target is None:
+            await self.say(event, err or "تعذر تحديد العضو.")
+            return
+        if not await self.check_target(event, actor, target, cmd in ("kick", "ban", "mute", "restrict")):
+            return
+        g = await self.db.group(event.chat_id)
+        await self.moderation.do(event.chat_id, target.peer, cmd, 0)
+        await self.say(event, DONE_TEXT[cmd])
+
+    async def c_warn(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, "ban_users", arg)
+        if not actor:
+            return
+        target, err = await self.resolver.resolve(event, arg)
+        if err or target is None:
+            await self.say(event, err or "تعذر تحديد العضو.")
+            return
+        if not await self.check_target(event, actor, target, True):
+            return
+        count = await self.db.add_warn(event.chat_id, target.id)
+        await self.say(event, await self.warnings.enforce(event.chat_id, target, count))
+
+    async def c_unwarn(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, "ban_users", arg)
+        if not actor:
+            return
+        target, err = await self.resolver.resolve(event, arg)
+        if err or target is None:
+            await self.say(event, err or "تعذر تحديد العضو.")
+            return
+        left = await self.db.remove_warn(event.chat_id, target.id)
+        if left is None:
+            await self.say(event, "لا توجد تحذيرات على هذا العضو.")
+        else:
+            await self.say(event, "تم رفع تحذير عن العضو. المتبقي: %d" % left)
+
+    async def c_clearwarns(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, "ban_users", arg)
+        if not actor:
+            return
+        target, err = await self.resolver.resolve(event, arg)
+        if err or target is None:
+            await self.say(event, err or "تعذر تحديد العضو.")
+            return
+        await self.db.clear_warns(event.chat_id, target.id)
+        await self.say(event, "تم مسح تحذيرات العضو.")
+
+    async def c_warns(self, event: Any, arg: str) -> None:
+        if not self.plausible(event, arg) or self.is_anon(event):
+            return
+        if event.message.is_reply or arg:
+            actor = await self.gate(event, None, arg)
+            if not actor:
+                return
+            target, err = await self.resolver.resolve(event, arg)
+            if err or target is None:
+                await self.say(event, err or "تعذر تحديد العضو.")
+                return
+            uid, who = target.id, "العضو"
+        else:
+            uid, who = event.sender_id, "لديك"
+        n = await self.db.warn_count(event.chat_id, uid)
+        if who == "لديك":
+            await self.say(event, "عدد تحذيراتك: %d" % n)
+        else:
+            await self.say(event, "عدد تحذيرات العضو: %d" % n)
+
+    # ---- id / kash / date / calc
+    async def is_locked_for(self, event: Any, group: Dict[str, Any], key: str) -> bool:
+        if key not in group["locks"] or self.is_anon(event):
+            return False
+        return not (await self.actor_info(event)).is_admin
+
+    @staticmethod
+    def weird_arg(event: Any, arg: str) -> bool:
+        return bool(arg) and not event.message.is_reply and not (arg[0] == "@" or arg[0].isdigit())
+
+    async def pick_user(self, event: Any, arg: str) -> Optional[types.User]:
+        """Reply / @username / ID, or the sender itself. Answers with an error on failure."""
+        msg = event.message
+        if msg.is_reply or arg:
+            target, err = await self.resolver.resolve(event, arg)
+            if err or target is None:
+                await self.say(event, err or "تعذر تحديد الحساب.")
+                return None
+            return target.user
+        user = msg.sender
+        if user is None and not self.is_anon(event):
+            try:
+                user = await event.get_sender()
+            except Exception:
+                user = None
+        if not isinstance(user, types.User):
+            await self.say(event, "لا يمكن تحديد الحساب.")
+            return None
+        return user
+
+    async def c_id(self, event: Any, arg: str, detailed: bool) -> None:
+        if self.weird_arg(event, arg):
+            return
+        group = await self.db.group(event.chat_id)
+        key = "kash" if detailed else "id"
+        if await self.is_locked_for(event, group, key):
+            if not detailed:
+                await self.say(event, "أمر ايدي مقفل للأعضاء.")
+            return
+        user = await self.pick_user(event, arg)
+        if user is None:
+            return
+        chat = event.chat_id
+        uname = ("@" + user.username) if user.username else "لا يوجد"
+        photo_task = self.start_photo(user)  # download in parallel with building the card
+        if detailed:
+            tinfo = await self.perms.info(chat, user, user.id, True)
+            role = tinfo.role if tinfo.known else "عضو"
+            state = STATE_AR.get(tinfo.state, "—") if tinfo.known else "غير معروف (ارفعني مشرفاً)"
+            text = kash_card_text(full_name(user), user.id, uname, role, state)
+        else:
+            tinfo, about = await asyncio.gather(
+                self.perms.info(chat, user, user.id), self.fetch_about(user))
+            est = describe_estimate(user.id)
+            if est:
+                cr = est[0] + (" (دقة منخفضة)" if est[2] == "low" else "")
+            else:
+                cr = "لا يمكن تقديره بشكل موثوق"
+            text = id_card_text(
+                full_name(user), uname, tinfo.role if tinfo.known else "عضو", user.id, cr,
+                about[:100] if about else "لا توجد نبذة")
+        await self.send_card(event, user, text, photo_task)
+
+    async def c_date(self, event: Any, arg: str) -> None:
+        if self.weird_arg(event, arg):
+            return
+        group = await self.db.group(event.chat_id)
+        if await self.is_locked_for(event, group, "date"):
+            return
+        user = await self.pick_user(event, arg)
+        if user is None:
+            return
+        rows = ["👤 <b>الاسم</b> » %s" % esc(display_name(user)),
+                "🆔 <b>الايدي</b> » <code>%d</code>" % user.id]
+        est = describe_estimate(user.id)
+        if est:
+            date, age, level = est
+            rows.append("📅 <b>تاريخ الإنشاء التقريبي</b> » %s" % date)
+            rows.append("⏳ <b>عمر الحساب</b> » %s" % age)
+            rows.append("🎯 <b>الدقة</b> » %s" % (
+                "متوسطة (± عدة أشهر)" if level == "mid" else "منخفضة (± سنة أو أكثر)"))
+        else:
+            rows.append("📅 <i>لا يمكن تقدير تاريخ الإنشاء بشكل موثوق.</i>")
+        rows.append("ℹ️ <i>تقدير مبني على الايدي فقط، وتي��يجرام لا يوفّر التاريخ الحقيقي.</i>")
+        text = "✦ ━━ 🕰 <b>عمر الحساب</b> ━━ ✦\n\n%s" % "\n".join(rows)
+        await self.say(event, text, reply_to=event.message.id)
+
+    async def c_calc(self, event: Any, arg: str) -> None:
+        if not arg:
+            await self.say(event, "اكتب العملية بعد الأمر. مثال: <code>احسب 55+20</code>")
+            return
+        if not _CALC_OK.match(arg):
+            return  # normal chat, not a calculation
+        group = await self.db.group(event.chat_id)
+        if await self.is_locked_for(event, group, "calc"):
+            return
+        res = calc_eval(arg)
+        if res is None:
+            await self.say(event, "عملية غير صحيحة. مثال: <code>احسب 55+20</code>")
+            return
+        await self.say(event, "🧮 <b>الحاسبة</b>\n<code>%s</code> = <b>%s</b>" % (esc(arg), res),
+                       reply_to=event.message.id)
+
+    # ---- cards / staff
+    async def fetch_about(self, user: types.User) -> str:
+        try:
+            full = await asyncio.wait_for(self.client(GetFullUserRequest(user)), timeout=4)
+            return (full.full_user.about or "").strip()
+        except Exception:
+            return ""
+
+    async def get_staff(self, chat_id: int) -> Dict[str, List[Tuple[Any, str]]]:
+        hit = self._staff_cache.get(chat_id)
+        if hit and time.monotonic() - hit[0] < 60:
+            return hit[1]
+        out: Dict[str, List[Tuple[Any, str]]] = {"owner": [], "manager": [], "admin": []}
+        async for u in self.client.iter_participants(chat_id, filter=types.ChannelParticipantsAdmins()):
+            part = getattr(u, "participant", None)
+            if isinstance(part, types.ChannelParticipantCreator):
+                kind = "owner"
+            elif isinstance(part, types.ChannelParticipantAdmin):
+                kind = "manager" if getattr(part.admin_rights, "add_admins", False) else "admin"
+            else:
+                continue
+            if getattr(u, "bot", False) or getattr(u, "deleted", False):
+                continue
+            out[kind].append((u, getattr(part, "rank", None) or ""))
+        if len(self._staff_cache) > 200:
+            self._staff_cache.clear()
+        self._staff_cache[chat_id] = (time.monotonic(), out)
+        return out
+
+    async def c_staff(self, event: Any, cmd: str, arg: str) -> None:
+        if arg:
+            return  # normal chat, not a command
+        chat = event.chat_id
+        staff = await self.get_staff(chat)
+        sec_owner = staff_section("👑 <b>المالك</b>", staff["owner"])
+        sec_mgr = staff_section("🛡 <b>المدراء</b>", staff["manager"])
+        sec_adm = staff_section("👮 <b>الأدمنية</b>", staff["admin"])
+        if cmd == "owners":
+            text = sec_owner
+        elif cmd == "managers":
+            text = sec_mgr
+        elif cmd == "admins":
+            text = sec_adm
+        else:
+            title, count = "", None
+            try:
+                ch = await event.get_chat()
+                title = getattr(ch, "title", "") or ""
+                full = await self.client(GetFullChannelRequest(ch))
+                count = full.full_chat.participants_count
+            except Exception:
+                pass
+            head = ["🏛 <b>كشف المجموعة</b>"]
+            if title:
+                head.append("\u21DC الاسم \u21A2 %s" % esc(title))
+            if count is not None:
+                head.append("\u21DC الأعضاء \u21A2 %s" % "{:,}".format(count))
+            text = "\n".join(head) + "\n\n" + sec_owner + "\n\n" + sec_mgr + "\n\n" + sec_adm
+        await self.say(event, join_limited(text.split("\n"), 3900), reply_to=event.message.id)
+
+    async def c_mytitle(self, event: Any, arg: str) -> None:
+        if arg or self.is_anon(event):
+            return
+        info = await self.perms.info(
+            event.chat_id, event.message.input_sender or event.sender_id, event.sender_id, True)
+        if not info.known:
+            await self.say(event, "ارفعني مشرفاً لأتمكن من قراءة الألقاب.")
+            return
+        await self.say(
+            event,
+            "\u21DC رتبتك \u21A2 %s\n\u21DC لقبك \u21A2 %s" % (
+                info.role, esc(info.title) if info.title else "لا يوجد لقب"),
+            reply_to=event.message.id)
+
+    def start_photo(self, user: types.User) -> Optional["asyncio.Task[Any]"]:
+        c = self._photo_cache.get(user.id)
+        if c and time.monotonic() - c[0] < 3600:
+            return None
+        if not isinstance(user.photo, types.UserProfilePhoto):
+            return None
+        return asyncio.create_task(self._download_photo(user))
+
+    async def _download_photo(self, user: types.User) -> Optional[io.BytesIO]:
+        try:
+            data = await self.client.download_profile_photo(user, file=bytes)
+            if data:
+                bio = io.BytesIO(data)
+                bio.name = "photo.jpg"
+                return bio
+        except Exception:
+            log.debug("photo download failed", exc_info=True)
+        return None
+
+    async def send_card(self, event: Any, user: types.User, text: str, photo_task: Any) -> None:
+        chat, reply_to = event.chat_id, event.message.id
+        cached = self._photo_cache.get(user.id)
+        if cached and time.monotonic() - cached[0] < 3600:
+            try:  # re-use the already uploaded photo: no download, no upload
+                await self.client.send_file(chat, cached[1], caption=text, reply_to=reply_to)
+                return
+            except RPCError:
+                self._photo_cache.pop(user.id, None)
+        photo = await photo_task if photo_task is not None else None
+        if photo is not None:
+            try:
+                sent = await self.client.send_file(chat, photo, caption=text, reply_to=reply_to)
+                media = getattr(sent, "media", None)
+                if media is not None:
+                    if len(self._photo_cache) > 500:
+                        self._photo_cache.clear()
+                    self._photo_cache[user.id] = (time.monotonic(), media)
+                return
+            except RPCError as e:
+                log.debug("send photo failed: %s", getattr(e, "message", e))
+        try:
+            await event.reply(text, link_preview=False)
+        except RPCError as e:
+            log.warning("reply failed: %s", getattr(e, "message", e))
+
+    # ---- locks
+    async def c_lock(self, event: Any, arg: str, lock: bool) -> None:
+        if not arg:
+            if self.plausible(event, arg):
+                actor = await self.gate(event, None, arg)
+                if actor:
+                    await self.say(event, "اكتب اسم القفل. مثال: قفل الروابط")
+            return
+        actor = None
+        chat = event.chat_id
+        key = LOCK_ALIAS.get(arg)
+        if key is None:
+            customs = await self.db.customs_of(chat)
+            if any((k, arg) in customs for k in ("reply", "command")):
+                key = "c:" + arg
+            else:
+                return
+        actor = await self.gate(event, None, "")
+        if not actor:
+            return
+        if key == "warn":
+            await self.db.set_group(chat, autowarn=not lock)
+            await self.say(event, "تم تعطيل نظام التحذير التلقائي." if lock
+                           else "تم تفعيل نظام التحذير التلقائي.")
+            return
+        g = await self.db.group(chat)
+        locks = list(g["locks"])
+        if lock and key not in locks:
+            locks.append(key)
+        elif not lock and key in locks:
+            locks.remove(key)
+        await self.db.set_group(chat, locks=locks)
+        name = LOCK_NAME_AR.get(key, arg)
+        await self.say(event, ("تم قفل %s." if lock else "تم فتح %s.") % esc(name))
+
+    async def c_enable(self, event: Any, arg: str, enable: bool) -> None:
+        if LOCK_ALIAS.get(arg) != "warn":
+            return
+        actor = await self.gate(event, None, "")
+        if not actor:
+            return
+        await self.db.set_group(event.chat_id, autowarn=enable)
+        await self.say(event, "تم تفعيل نظام التحذير التلقائي." if enable
+                       else "تم تعطيل نظام التحذير التلقائي.")
+
+    # ---- banned words
+    async def c_addword(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, None, arg)
+        if not actor:
+            return
+        if not arg:
+            await self.say(event, "اكتب: اضف كلمة + الكلمة.")
+            return
+        if len(arg) > 60:
+            await self.say(event, "الكلمة طويلة جداً.")
+            return
+        g = await self.db.group(event.chat_id)
+        words = list(g["banned_words"])
+        if arg in words:
+            await self.say(event, "الكلمة موجودة مسبقاً.")
+            return
+        if len(words) >= 500:
+            await self.say(event, "وصلت للحد الأقصى من الكلمات.")
+            return
+        words.append(arg)
+        await self.db.set_group(event.chat_id, banned_words=words)
+        await self.say(event, "تمت إضافة الكلمة.")
+
+    async def c_delword(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, None, arg)
+        if not actor:
+            return
+        g = await self.db.group(event.chat_id)
+        words = list(g["banned_words"])
+        if arg not in words:
+            await self.say(event, "الكلمة غير موجودة.")
+            return
+        words.remove(arg)
+        await self.db.set_group(event.chat_id, banned_words=words)
+        await self.say(event, "تم حذف الكلمة.")
+
+    async def c_words(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, None, arg)
+        if not actor:
+            return
+        g = await self.db.group(event.chat_id)
+        if not g["banned_words"]:
+            await self.say(event, "لا توجد كلمات ممنوعة.")
+            return
+        lines = ["<b>الكلمات الممنوعة:</b>"] + ["• " + esc(w) for w in g["banned_words"]]
+        await self.say(event, join_limited(lines))
+
+    # ---- messages
+    async def c_delete(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, "delete_messages", arg)
+        if not actor:
+            return
+        msg = event.message
+        if msg.is_reply:
+            ids = [msg.reply_to_msg_id, msg.id]
+        elif arg.isdigit() and int(arg) > 0:
+            n = min(int(arg), 100)
+            ids = list(range(max(1, msg.id - n), msg.id + 1))
+        else:
+            await self.say(event, "رد على رسالة أو اكتب: مسح 10")
+            return
+        await self.client.delete_messages(event.chat_id, ids)
+
+    async def c_pin(self, event: Any, arg: str, pin: bool) -> None:
+        actor = await self.gate(event, "pin_messages", arg)
+        if not actor:
+            return
+        msg = event.message
+        if pin:
+            if not msg.is_reply:
+                await self.say(event, "رد على الرسالة المراد تثبيتها.")
+                return
+            await self.client.pin_message(event.chat_id, msg.reply_to_msg_id)
+            await self.say(event, "تم تثبيت الرسالة.")
+        else:
+            if msg.is_reply:
+                await self.client.unpin_message(event.chat_id, msg.reply_to_msg_id)
+                await self.say(event, "تم إلغاء تثبيت الرسالة.")
+            else:
+                await self.client.unpin_message(event.chat_id)
+                await self.say(event, "تم إلغاء تثبيت جميع الرسائل.")
+
+    # ---- settings commands
+    async def c_rule(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, None, arg)
+        if not actor:
+            return
+        m = re.match(r"^(\d{1,2})\s+(\S+)$", arg)
+        act = ACTION_FROM_AR.get(m.group(2)) if m else None
+        if not m or act is None or not (1 <= int(m.group(1)) <= 10):
+            await self.say(event, "مثال: عقوبة 3 كتم\nالإجراءات: كتم، تقييد، طرد، حظر، بدون")
+            return
+        g = await self.db.group(event.chat_id)
+        rules = dict(g["warn_rules"])
+        if act == "none":
+            rules.pop(str(int(m.group(1))), None)
+        else:
+            rules[str(int(m.group(1)))] = act
+        await self.db.set_group(event.chat_id, warn_rules=rules)
+        await self.say(event, "تم تحديث العقوبة.")
+
+    async def c_setspam(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, None, arg)
+        if not actor:
+            return
+        m = re.match(r"^(\d+)\s+(\d+)$", arg)
+        if not m:
+            await self.say(event, "مثال: ضبط التكرار 6 5\n(عدد الرسائل ثم الثواني)")
+            return
+        c, s = int(m.group(1)), int(m.group(2))
+        c = min(max(c, BOUNDS["spam_count"][0]), BOUNDS["spam_count"][1])
+        s = min(max(s, BOUNDS["spam_seconds"][0]), BOUNDS["spam_seconds"][1])
+        await self.db.set_group(event.chat_id, spam_count=c, spam_seconds=s)
+        await self.say(event, "تم الضبط: %d رسائل خلال %d ثواني." % (c, s))
+
+    async def c_setmute(self, event: Any, arg: str) -> None:
+        actor = await self.gate(event, None, arg)
+        if not actor:
+            return
+        if not arg.isdigit():
+            await self.say(event, "مثال: ضبط الكتم 60 (بالدقائق)")
+            return
+        lo, hi = BOUNDS["mute_minutes"]
+        v = min(max(int(arg), lo), hi)
+        await self.db.set_group(event.chat_id, mute_minutes=v)
+        await self.say(event, "تم الضبط: مدة الكتم %d دقيقة." % v)
+
+    # ---- inline callbacks
+    async def cb_is_admin(self, event: Any) -> bool:
+        try:
+            peer = await event.get_input_sender()
+        except Exception:
+            peer = event.sender_id
+        inf = await self.perms.info(event.chat_id, peer, event.sender_id)
+        return inf.is_admin
+
+    @staticmethod
+    async def _edit(event: Any, text: str, rows: List[List[Any]]) -> None:
+        try:
+            await event.edit(text, buttons=rows, link_preview=False)
+        except RPCError as e:
+            if "MESSAGE_NOT_MODIFIED" not in (getattr(e, "message", "") or "").upper():
+                log.debug("edit failed: %s", getattr(e, "message", e))
+
+    async def on_callback(self, event: Any) -> None:
+        try:
+            data = (event.data or b"").decode("utf-8", "ignore")
+            if event.chat_id is None or event.is_private or data == "noop":
+                await event.answer()
+                return
+            parts = data.split(":")
+            if data == "m:main":
+                text, rows = self.menu.main()
+                await self._edit(event, text, rows)
+            elif len(parts) == 3 and parts[0] == "m" and parts[1] == "s":
+                idx = int(parts[2])
+                if not 0 <= idx < len(SECTIONS):
+                    await event.answer()
+                    return
+                if SECTIONS[idx][2] and not await self.cb_is_admin(event):
+                    await event.answer("هذا القسم للمشرفين فقط.", alert=True)
+                    return
+                text, rows = await self.menu.section(idx, event.chat_id)
+                await self._edit(event, text, rows)
+            elif parts[0] == "st" and len(parts) >= 3:
+                if not await self.cb_is_admin(event):
+                    await event.answer("للمشرفين فقط.", alert=True)
+                    return
+                await self.menu.apply_setting(parts, event.chat_id)
+                idx = [s[0] for s in SECTIONS].index("settings")
+                text, rows = await self.menu.section(idx, event.chat_id)
+                await self._edit(event, text, rows)
+            await event.answer()
+        except FloodWaitError:
+            pass
+        except Exception:
+            log.exception("on_callback failed")
+            try:
+                await event.answer()
+            except Exception:
+                pass
+
+
+# ============================================================================
+# Health server (Hugging Face Spaces needs an open port) & main
+# ============================================================================
+
+async def health_handler(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+    try:
+        await asyncio.wait_for(reader.read(1024), timeout=5)
+        body = b"Bot is running"
+        writer.write(
+            b"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n"
+            b"Content-Length: %d\r\nConnection: close\r\n\r\n" % len(body) + body
+        )
+        await writer.drain()
+    except Exception:
+        pass
+    finally:
+        try:
+            writer.close()
+        except Exception:
+            pass
+
+
+async def janitor(bot: Bot) -> None:
+    while True:
+        await asyncio.sleep(300)
+        try:
+            bot.protection.flood.purge()
+            now = time.time()
+            for k in [k for k, p in bot.customs.pending.items() if p["exp"] < now]:
+                bot.customs.pending.pop(k, None)
+        except Exception:
+            log.debug("janitor error", exc_info=True)
+
+
+def require_env() -> Tuple[int, str, str, str]:
+    names = ("API_ID", "API_HASH", "BOT_TOKEN", "MONGO_URI")
+    missing = [n for n in names if not os.environ.get(n, "").strip()]
+    if missing:
+        print("Missing environment variables: " + ", ".join(missing), file=sys.stderr)
+        sys.exit(1)
+    try:
+        api_id = int(os.environ["API_ID"].strip())
+    except ValueError:
+        print("API_ID must be an integer.", file=sys.stderr)
+        sys.exit(1)
+    return (api_id, os.environ["API_HASH"].strip(),
+            os.environ["BOT_TOKEN"].strip(), os.environ["MONGO_URI"].strip())
+
+
+async def main() -> None:
+    print("Starting bot...", flush=True)
+    api_id, api_hash, bot_token, mongo_uri = require_env()
+
+    port = int(os.environ.get("PORT", "7860"))
+    server = await asyncio.start_server(health_handler, "0.0.0.0", port)
+    log.info("Health server listening on port %d", port)
+
+    db = Database(mongo_uri)
+    while True:
+        try:
+            await db.init()
+            break
+        except Exception as e:
+            log.error("MongoDB connection failed (%s). Retrying in 10s...", type(e).__name__)
+            await asyncio.sleep(10)
+    log.info("MongoDB connected")
+
+    client = TelegramClient(
+        StringSession(), api_id, api_hash,
+        flood_sleep_threshold=60, connection_retries=-1, retry_delay=2,
+    )
+    client.parse_mode = "html"
+    bot = Bot(client, db)
+    bot.register()
+
+    while True:
+        try:
+            await client.start(bot_token=bot_token)
+            break
+        except FloodWaitError as e:
+            log.warning("FloodWait on login: sleeping %ds", e.seconds)
+            await asyncio.sleep(e.seconds + 1)
+        except Exception as e:
+            log.error("Login failed (%s). Retrying in 10s...", type(e).__name__)
+            await asyncio.sleep(10)
+
+    bot.me = await client.get_me()
+    bot.perms.me_id = bot.me.id
+    log.info("Bot started as @%s", bot.me.username)
+
+    task = asyncio.create_task(janitor(bot))
+    try:
+        while True:  # never exit: keep the container alive and reconnect if needed
+            try:
+                await client.run_until_disconnected()
+                log.warning("Client disconnected; reconnecting in 5s")
+            except Exception:
+                log.exception("Connection loop error; reconnecting in 5s")
+            await asyncio.sleep(5)
+            try:
+                if not client.is_connected():
+                    await client.connect()
+            except Exception:
+                log.exception("Reconnect failed")
+    finally:
+        task.cancel()
+        server.close()
+
+
+if __name__ == "__main__":
+    try:
+        if uvloop is not None and hasattr(uvloop, "run"):
+            uvloop.run(main())
+        else:
+            asyncio.run(main())
+    except KeyboardInterrupt:
+        pass