onboarding: never let a network blip trigger a leave + blocklist

Same three fixes as the private tree, plus the two wiring gaps that made them
worse here.

The core problem: has_rights collapsed every exception into "no rights", and at
the 600s slot that answer went straight to leave + blocklist. probe_rights is
now tri-state (True/False/None); only a confirmed False may act. An unreadable
answer requeues the same slot 60s later, up to 3 times, then gives up without
leaving. The nag's send_message no longer treats a timeout as "muted/removed" -
only Forbidden and the chat-is-gone BadRequests do, and that path leaves without
blocklisting. Error-derived cache negatives now live 20s instead of 300s, so a
blip can no longer silence a group for five minutes.

Also here:
- /groups (list + unblock) was private-only, and unblock() was dead code in this
repo. A wrong entry was only undoable by hand-editing bot.db on the VPS.
- ADMIN_USER_ID was claimed by whoever sent the first /start after a restart.
On a public bot that is a stranger, and it re-opened on every deploy. It now
comes from the environment only; unset means nobody holds it. The private tree
removed this a while back and the fix was never ported.
- Blocklist entries expire after 7 days, the no-rights reply is throttled to
once per 10 min per chat, TEXTS lookup moved out of the try, and
restricted -> kicked now cancels pending nags.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.env.example

@@ -28,6 +28,13 @@ AI_FALLBACK_MODEL=
 # Optional; the fallback text model is reused for images when this is empty.
 AI_FALLBACK_VISION_MODEL=
 
+# ── Ownership ─────────────────────────────────────────────
+# Your Telegram numeric user ID. Unlocks /groups (view and clear the blocklist
+# of groups the bot left over missing rights). Leave empty and nobody has it —
+# there is deliberately no "first person to /start becomes the admin" fallback.
+# Get yours from @userinfobot.
+ADMIN_USER_ID=
+
 # ── Storage ───────────────────────────────────────────────
 DB_PATH=/data/bot.db
 

bot.py

@@ -116,8 +116,10 @@ async def _group_cmd_allowed(update, context):
 
 
 async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    if not config.ADMIN_USER_ID:
-        config.ADMIN_USER_ID = update.effective_user.id
+    # Deliberately no "first caller becomes super-admin" here. This bot is public,
+    # so that grab went to whoever happened to /start first after each restart,
+    # and it silently re-opened on every deploy. Set ADMIN_USER_ID explicitly;
+    # unset means the super-admin commands are unavailable to everyone.
     if update.effective_chat.type == "private":
         context.user_data["history"] = []
         intent, reply = await ai_text(
@@ -159,6 +161,47 @@ async def cmd_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
         )
 
 
+async def cmd_groups(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Super-admin: inspect and clear the group blocklist.
+
+    Entries expire on their own after onboarding.BLOCK_DAYS, but a wrong one
+    should not need a week or a hand-edited database to undo.
+    /groups — list, /groups unblock <chat_id> — clear one.
+    """
+    if not update.effective_user or not is_bot_admin(update.effective_user.id):
+        return
+    args = context.args or []
+    if args and args[0] == "unblock":
+        if len(args) < 2:
+            await update.message.reply_text("Usage: /groups unblock <chat_id>")
+            return
+        try:
+            cid = int(args[1])
+        except ValueError:
+            await update.message.reply_text("chat_id must be a number")
+            return
+        await onboarding.unblock(cid)
+        await update.message.reply_text("Unblocked: " + str(cid))
+        return
+    from modules.db import shared_db
+    async with shared_db() as db:
+        cur = await db.execute(
+            "SELECT chat_id, title, reason, blocked_at FROM group_blocklist "
+            "ORDER BY blocked_at DESC LIMIT 20")
+        rows = await cur.fetchall()
+    if not rows:
+        await update.message.reply_text("Blocklist is empty")
+        return
+    lines = ["Blocked groups (" + str(len(rows)) + ", expire after "
+             + str(onboarding.BLOCK_DAYS) + "d):"]
+    for cid, title, reason, at in rows:
+        lines.append(str(cid) + "  " + (title or "?")[:20] + "  " + str(reason)
+                     + "  " + str(at)[:16])
+    lines.append("")
+    lines.append("Clear one: /groups unblock <chat_id>")
+    await update.message.reply_text("\n".join(lines))
+
+
 async def cmd_ban(update: Update, context: ContextTypes.DEFAULT_TYPE):
     if update.effective_chat.type == "private" or not update.message.reply_to_message:
         return
@@ -397,14 +440,20 @@ async def handle_group_message(update: Update, context: ContextTypes.DEFAULT_TYP
     # 447 "detected spam but no permission" lines from one unknown group in 24h).
     # The rights nag runs on a timer in modules/onboarding and gives up at 10 min.
     if not await onboarding.has_rights(context, chat_id):
+        # Say so once in a while so someone fixes it, but not on every mention —
+        # "make the bot talk" is the same free drain in miniature, and legacy
+        # rights-less groups never go through the nag flow at all.
         if wants_reply:
-            try:
-                await msg.reply_text(
-                    "I don't have admin rights yet (Delete Messages + Ban Users), "
-                    "so I can't do anything here. Ask an admin to grant them."
-                )
-            except Exception:
-                pass
+            k = "norights_cd_" + str(chat_id)
+            if _time.time() - context.bot_data.get(k, 0) >= 600:
+                context.bot_data[k] = _time.time()
+                try:
+                    await msg.reply_text(
+                        "I don't have admin rights yet (Delete Messages + Ban Users), "
+                        "so I can't do anything here. Ask an admin to grant them."
+                    )
+                except Exception:
+                    pass
         return
 
     # A message posted under a chat's identity (anonymous admin, channel identity)
@@ -682,6 +731,12 @@ async def handle_my_chat_member(update: Update, context: ContextTypes.DEFAULT_TY
     # This event also fires when our rights are edited, so drop the cache or we
     # would keep using the stale answer until the TTL expires.
     onboarding.forget_rights(chat_id)
+    # Stop nagging the moment we are out, unconditionally. Not inside the branch
+    # below: restricted -> kicked does not satisfy its `old` test, which would
+    # orphan the nags. They would then keep posting into a chat we already left,
+    # fail, and that failure would be read as "we can never speak here".
+    if new in ("left", "kicked"):
+        onboarding.cancel(context, chat_id)
 
     if old in ("left", "kicked") and new in ("member", "administrator"):
         # Channels are not supported: the anti-spam filter is ChatType.GROUPS
@@ -725,8 +780,7 @@ async def handle_my_chat_member(update: Update, context: ContextTypes.DEFAULT_TY
             [InlineKeyboardButton("Decline", callback_data="tos_decline_" + str(chat_id))]
         ])
         await context.bot.send_message(chat_id, TOS_TEXT, reply_markup=keyboard)
-    elif old in ("member", "administrator") and new in ("left", "kicked"):
-        onboarding.cancel(context, chat_id)
+    elif new in ("left", "kicked"):
         onboarding.forget_rights(chat_id)
         await delete_tos(chat_id)
 
@@ -841,6 +895,7 @@ def main():
     # anywhere else an edit would run the command or the answer a second time.
     for cmd, fn in [
         ("start", cmd_start), ("help", cmd_help), ("ban", cmd_ban),
+        ("groups", cmd_groups),
     ]:
         app.add_handler(CommandHandler(cmd, fn, filters=filters.UpdateType.MESSAGE))
 

config.py

@@ -54,5 +54,10 @@ JUDGE_CAPTION_LIMIT = int(os.environ.get("JUDGE_CAPTION_LIMIT", "900"))
 # only — admins and private chats are never limited.
 GROUP_CMD_COOLDOWN = int(os.environ.get("GROUP_CMD_COOLDOWN", "60"))
 
-# Admin user ID (auto-detected from first /start)
-ADMIN_USER_ID = None
+# Super-admin Telegram user ID, for /groups. Must be set explicitly: this used to
+# be claimed by whoever sent the first /start after a restart, which on a public
+# bot means a stranger, re-opened on every deploy. Unset = nobody has it.
+try:
+    ADMIN_USER_ID = int(os.environ.get("ADMIN_USER_ID", "") or 0) or None
+except ValueError:
+    ADMIN_USER_ID = None

modules/onboarding.py

@@ -13,13 +13,23 @@ Three layers:
   3. Still nothing at 10 minutes: explain, leave, and blocklist the chat, so a
      re-invite is refused instantly instead of restarting the whole cycle
 
-The blocklist is per chat_id; an owner who wants the bot back can have the
-super-admin clear it.
+"Couldn't find out" is not "no rights" — that is the central rule here. A
+getChatMember timeout, a Telegram 5xx or a flood-wait all raise, and treating
+every raise as a negative means one network blip can make the bot leave a fully
+authorised group and blocklist it, irreversibly. So probe_rights is tri-state:
+True / False / None, and only a confirmed False may trigger a leave.
+
+Blocklist entries expire after BLOCK_DAYS. An attacker has to redo the whole
+setup every week for a payoff of five messages, while an honest mistake heals
+itself without anyone editing the database by hand. A super-admin can also clear
+one instantly with /groups unblock <chat_id>.
 """
 
 import logging
 import time
 
+from telegram.error import BadRequest, Forbidden
+
 from modules.db import shared_db
 
 logger = logging.getLogger(__name__)
@@ -28,11 +38,23 @@ logger = logging.getLogger(__name__)
 REMIND_AT = (60, 120, 180, 300, 600)
 GIVE_UP_AFTER = REMIND_AT[-1]
 
-# Do we hold enforcement rights in this chat: chat_id -> (has_rights, checked_at)
+# When the rights lookup itself fails: how long to wait, how many times to retry.
+# No leaving happens while retrying — an unknown answer is not evidence.
+RETRY_AFTER = 60
+MAX_RETRIES = 3
+
+# How long a blocklist entry stays in force.
+BLOCK_DAYS = 7
+
+# Do we hold enforcement rights in this chat: chat_id -> (has_rights, checked_at, ttl)
 # Calling getChatMember per message is expensive, and rights changes arrive via
 # my_chat_member anyway; the cache only covers the case where that event is
 # missed, so the TTL can be generous.
+# A False derived from a failed lookup is cached only briefly (_UNKNOWN_TTL) —
+# otherwise one blip silences the whole group for five minutes, during which every
+# message skips judging and nothing ever arrives to clear the cache.
 _RIGHTS_TTL = 300
+_UNKNOWN_TTL = 20
 _rights_cache = {}
 
 
@@ -49,7 +71,11 @@ async def ensure_tables():
 async def is_blocked(chat_id):
     try:
         async with shared_db() as db:
-            cur = await db.execute("SELECT 1 FROM group_blocklist WHERE chat_id=?", (chat_id,))
+            cur = await db.execute(
+                "SELECT 1 FROM group_blocklist WHERE chat_id=? "
+                "AND blocked_at > datetime('now', ?)",
+                (chat_id, "-" + str(BLOCK_DAYS) + " days")
+            )
             return await cur.fetchone() is not None
     except Exception as e:
         logger.warning("blocklist lookup failed (allowing): " + str(e))
@@ -77,26 +103,42 @@ def forget_rights(chat_id):
     _rights_cache.pop(chat_id, None)
 
 
-def note_rights(chat_id, has_rights):
-    _rights_cache[chat_id] = (bool(has_rights), time.time())
+def note_rights(chat_id, has_rights, ttl=_RIGHTS_TTL):
+    _rights_cache[chat_id] = (bool(has_rights), time.time(), ttl)
 
 
-async def has_rights(context, chat_id, use_cache=True):
-    """Can we delete messages AND ban users here. Both, not either."""
-    if use_cache:
-        hit = _rights_cache.get(chat_id)
-        if hit and (time.time() - hit[1]) < _RIGHTS_TTL:
-            return hit[0]
+async def probe_rights(context, chat_id):
+    """Tri-state: True (have them) / False (confirmed not) / None (couldn't tell).
+
+    None must never collapse into False. Anything irreversible — leaving,
+    blocklisting — may only act on a confirmed False. Writes no cache; the caller
+    decides how to record the answer.
+    """
     try:
         me = await context.bot.get_chat_member(chat_id, context.bot.id)
-        ok = (me.status == "administrator"
-              and bool(getattr(me, "can_delete_messages", False))
-              and bool(getattr(me, "can_restrict_members", False)))
     except Exception as e:
-        # Treat an unknown answer as "no rights": better to judge nothing than
-        # to burn calls in a chat we were never authorised in.
         logger.warning("own-rights lookup failed chat=" + str(chat_id) + ": " + str(e))
-        ok = False
+        return None
+    return (me.status == "administrator"
+            and bool(getattr(me, "can_delete_messages", False))
+            and bool(getattr(me, "can_restrict_members", False)))
+
+
+async def has_rights(context, chat_id, use_cache=True):
+    """Can we delete messages AND ban users here. Both, not either.
+
+    For the message path: an unknown answer counts as False (better to judge
+    nothing than to burn calls in a chat we were never authorised in), but it is
+    cached only briefly. Use probe_rights for anything that leads to a leave.
+    """
+    if use_cache:
+        hit = _rights_cache.get(chat_id)
+        if hit and (time.time() - hit[1]) < hit[2]:
+            return hit[0]
+    ok = await probe_rights(context, chat_id)
+    if ok is None:
+        note_rights(chat_id, False, _UNKNOWN_TTL)
+        return False
     note_rights(chat_id, ok)
     return ok
 
@@ -133,6 +175,20 @@ def schedule(context, chat_id, title=""):
     return True
 
 
+def _requeue(context, chat_id, title, at, tries):
+    """Couldn't read rights for this slot — redo it in a minute, advance nothing."""
+    jq = getattr(context, "job_queue", None)
+    if not jq:
+        return False
+    jq.run_once(
+        _nag,
+        RETRY_AFTER,
+        data={"chat_id": chat_id, "title": title, "at": at, "tries": tries},
+        name=_job_name(chat_id),
+    )
+    return True
+
+
 TEXTS = {
     60:  "I don't have admin rights yet, so I can't delete ads or ban anyone.\n"
          "Tap the group name -> Administrators -> Add Admin -> pick me -> "
@@ -141,32 +197,81 @@ TEXTS = {
     180: "Third reminder: still not authorised.",
     300: "⚠️ Without rights I will leave this group in 5 minutes.",
 }
+GENERIC = ("I don't have admin rights yet (Delete Messages + Ban Users), so I "
+           "can't do anything here.\nTap the group name -> Administrators -> "
+           "Add Admin -> pick me -> enable both.")
 GOODBYE = ("No admin rights after 10 minutes, so I'm leaving.\n"
            "Without Delete Messages and Ban Users I can't do anything here, and "
            "staying would just waste resources.\n\n"
            "Grant the rights first, then invite me again whenever you like.")
 
 
+def _is_fatal_send_error(e):
+    """Is this "we can never speak here" or "the network hiccuped"?
+
+    Only the former may lead to a leave. Forbidden means kicked/muted/blocked and
+    is definitive; among BadRequests only the chat-is-gone family is. Everything
+    else (timeouts, 5xx, flood-wait) is treated as transient so the remaining
+    nags still get their chance.
+    """
+    if isinstance(e, Forbidden):
+        return True
+    if isinstance(e, BadRequest):
+        t = str(e).lower()
+        return ("chat not found" in t or "chat_id is empty" in t
+                or "group chat was deactivated" in t or "chat was upgraded" in t)
+    return False
+
+
 async def _nag(context):
     d = context.job.data
     chat_id, title, at = d["chat_id"], d.get("title", ""), d["at"]
+    tries = d.get("tries", 0)
+
+    ok = await probe_rights(context, chat_id)
+
+    if ok is None:
+        # Unknown is not a negative. Never leave on this — retry the same slot.
+        if tries < MAX_RETRIES:
+            logger.warning("rights lookup failed, retrying in " + str(RETRY_AFTER)
+                           + "s chat=" + str(chat_id) + " at=" + str(at)
+                           + " tries=" + str(tries + 1))
+            _requeue(context, chat_id, title, at, tries + 1)
+        else:
+            # Repeatedly unanswerable: either a long outage or the chat is gone.
+            # Bow out quietly — no leave, no blocklist. A rights-less chat costs
+            # nothing on the message path anyway.
+            logger.warning("rights lookup failed " + str(MAX_RETRIES)
+                           + "x, giving up on nags (not leaving) chat=" + str(chat_id))
+            cancel(context, chat_id)
+        return
 
-    if await has_rights(context, chat_id, use_cache=False):
+    if ok:
+        note_rights(chat_id, True)
         cancel(context, chat_id)
         logger.info("rights granted, stopping nags for chat=" + str(chat_id))
         return
 
+    note_rights(chat_id, False)
+
     if at < GIVE_UP_AFTER:
+        text = TEXTS.get(at, GENERIC)
         try:
-            await context.bot.send_message(chat_id, TEXTS[at])
+            await context.bot.send_message(chat_id, text)
         except Exception as e:
-            # Can't even speak here (muted/removed) — no point continuing.
-            logger.warning("nag failed chat=" + str(chat_id) + ": " + str(e) + ", giving up")
-            cancel(context, chat_id)
-            await _leave(context, chat_id, title, "cannot_send")
+            if _is_fatal_send_error(e):
+                # We genuinely cannot speak here (kicked/muted) — nagging is moot.
+                logger.warning("nag undeliverable chat=" + str(chat_id) + ": "
+                               + str(e) + ", leaving")
+                cancel(context, chat_id)
+                await _leave(context, chat_id, title, "cannot_send", blocklist=False)
+            else:
+                # Transient — do nothing, the later slots still run.
+                logger.warning("nag send failed (transient) chat=" + str(chat_id)
+                               + ": " + str(e))
         return
 
-    # Final slot: leave and blocklist.
+    # Final slot: confirmed no rights, so leave and blocklist.
     try:
         await context.bot.send_message(chat_id, GOODBYE)
     except Exception:
@@ -175,11 +280,15 @@ async def _nag(context):
     await _leave(context, chat_id, title, "no_admin_rights")
 
 
-async def _leave(context, chat_id, title, reason):
-    try:
-        await block(chat_id, title, reason)
-    except Exception as e:
-        logger.warning("blocklist write failed chat=" + str(chat_id) + ": " + str(e))
+async def _leave(context, chat_id, title, reason, blocklist=True):
+    """Leave. blocklist=False is for "they kicked or muted us" — that was their
+    call, and holding it against the chat would block a re-invite they are
+    perfectly entitled to make."""
+    if blocklist:
+        try:
+            await block(chat_id, title, reason)
+        except Exception as e:
+            logger.warning("blocklist write failed chat=" + str(chat_id) + ": " + str(e))
     try:
         await context.bot.leave_chat(chat_id)
         logger.info("left unauthorised chat=" + str(chat_id) + " reason=" + reason)