fix(repeater): 持久化兜底不可以 ban 反查

Author: TogetsuDo

src/features/corpus/community_source.py

@@ -161,6 +161,9 @@ async def replace_answers(self, keywords: str, answers: list[Answer], clear_time
     async def append_ban(self, keywords: str, ban: Ban) -> None:
         return None
 
+    async def find_ban_reply_target(self, group_id: int, reply_message: str) -> tuple[str, str] | None:
+        return None
+
     async def _post_contribute(self, body: dict[str, Any]) -> None:
         if not self._api_bases:
             return

src/features/corpus/composite_repo.py

@@ -319,3 +319,9 @@ async def replace_answers(self, keywords: str, answers: list[Answer], clear_time
 
     async def append_ban(self, keywords: str, ban: Ban) -> None:
         await self._local.append_ban(keywords, ban)
+
+    async def find_ban_reply_target(self, group_id: int, reply_message: str) -> tuple[str, str] | None:
+        find_target = getattr(self._local, "find_ban_reply_target", None)
+        if not callable(find_target):
+            return None
+        return await find_target(group_id, reply_message)

src/foundation/db/repository.py

@@ -77,6 +77,10 @@ async def append_ban(self, keywords: str, ban: Ban) -> None:
         """
         ...
 
+    async def find_ban_reply_target(self, group_id: int, reply_message: str) -> tuple[str, str] | None:
+        """按群号与 reply 原文精确反查 (pre_keywords, reply_keywords)。"""
+        ...
+
 
 class ContextRepositoryExistenceMixin:
     """为已实现 `find_by_keywords` 的仓储提供 `context_exists_by_keywords` 默认实现。"""

src/foundation/db/repository_impl.py

@@ -128,6 +128,22 @@ async def append_ban(self, keywords: str, ban: Ban) -> None:
             {"$push": {"ban": ban.model_dump(by_alias=True)}},
         )
 
+    async def find_ban_reply_target(self, group_id: int, reply_message: str) -> tuple[str, str] | None:
+        collection = Context.get_pymongo_collection()
+        pipeline = [
+            {"$match": {"answers": {"$elemMatch": {"group_id": int(group_id), "messages": str(reply_message)}}}},
+            {"$unwind": "$answers"},
+            {"$match": {"answers.group_id": int(group_id), "answers.messages": str(reply_message)}},
+            {"$sort": {"answers.time": -1}},
+            {"$limit": 1},
+            {"$project": {"_id": 0, "keywords": 1, "reply_keywords": "$answers.keywords"}},
+        ]
+        docs = await collection.aggregate(pipeline).to_list(length=1)
+        if not docs:
+            return None
+        doc = docs[0]
+        return str(doc.get("keywords") or ""), str(doc.get("reply_keywords") or "")
+
 
 class MongoMessageRepository:
     """MongoDB 版 MessageRepository 实现"""

src/foundation/db/repository_pg.py

@@ -1133,6 +1133,25 @@ async def append_ban(self, keywords: str, ban: Ban) -> None:
             await session.commit()
         await clear_reply_query_snapshot_cache(keywords)
 
+    async def find_ban_reply_target(self, group_id: int, reply_message: str) -> tuple[str, str] | None:
+        async with get_session(read_only=True) as session:
+            result = await session.execute(
+                select(ContextRow.keywords, ContextAnswerRow.keywords)
+                .join(ContextAnswerRow, ContextAnswerRow.context_id == ContextRow.id)
+                .join(ContextAnswerMessageRow, ContextAnswerMessageRow.answer_id == ContextAnswerRow.id)
+                .where(
+                    ContextAnswerRow.group_id == int(group_id),
+                    ContextAnswerMessageRow.message == _s(reply_message),
+                )
+                .order_by(ContextAnswerRow.time.desc(), ContextAnswerMessageRow.id.desc())
+                .limit(1)
+            )
+            row = result.one_or_none()
+            if row is None:
+                return None
+            pre_keywords, reply_keywords = row
+            return str(pre_keywords), str(reply_keywords)
+
 
 def row_to_message(row: MessageRow) -> Message:
     from src.foundation.db.modules import Message

src/plugins/dream/ban_handlers.py

@@ -6,10 +6,11 @@
 from nonebot.adapters import Bot  # noqa: TC002
 from nonebot.adapters.onebot.v11 import GroupMessageEvent, GroupRecallNoticeEvent, Message
 from nonebot.exception import ActionFailed
-from nonebot.rule import Rule, keyword, to_me
+from nonebot.rule import Rule
 from nonebot.typing import T_State  # noqa: TC002
 
 from src.features.cmd_perm import group_message_permission_for_command
+from src.shared.reply_command_rule import event_has_reply_target, event_targets_self, extract_reply_id_from_raw_message
 from src.shared.utils.array2cqcode import try_convert_to_cqcode
 
 from .ban_ack_state import DREAM_BAN_ACK_SENT_STATE_KEY
@@ -19,11 +20,52 @@
 
 
 async def is_reply_for_ban(event: GroupMessageEvent) -> bool:
-    return bool(event.reply)
+    return event_has_reply_target(event)
+
+
+async def is_dream_ban_trigger(event: GroupMessageEvent) -> bool:
+    if "不可以" not in event.get_plaintext():
+        return False
+    if not await is_reply_for_ban(event):
+        return False
+    return event_targets_self(event)
+
+
+def extract_dream_ban_reply_raw_from_message(message: Message | str) -> str:
+    if isinstance(message, str):
+        return message
+
+    raw_message = ""
+    for item in message:
+        raw_reply = str(item)
+        raw_message += re.sub(r"(\[CQ\:.+)(?:,url=*)(\])", r"\1\2", raw_reply)
+    if not raw_message.strip():
+        raw_message = message.extract_plain_text()
+    return raw_message
+
+
+async def resolve_dream_ban_reply_raw(bot: Bot, event: GroupMessageEvent) -> str:
+    if event.reply and getattr(event.reply, "message", None):
+        return extract_dream_ban_reply_raw_from_message(event.reply.message)
+
+    reply_id = extract_reply_id_from_raw_message(event.raw_message)
+    if reply_id is None:
+        return ""
+
+    try:
+        msg = await bot.get_msg(message_id=reply_id)
+    except ActionFailed:
+        logger.warning(
+            f"bot [{event.self_id}] dream ban cleanup get_msg failed in group [{event.group_id}] "
+            f"for reply_id [{reply_id}]"
+        )
+        return ""
+
+    return extract_dream_ban_reply_raw_from_message(Message(msg["message"]))
 
 
 dream_ban_cleanup_msg = on_message(
-    rule=to_me() & keyword("不可以") & Rule(is_reply_for_ban),
+    rule=Rule(is_dream_ban_trigger),
     priority=4,
     block=False,
     permission=group_message_permission_for_command("dream.ban_cleanup"),
@@ -32,16 +74,15 @@ async def is_reply_for_ban(event: GroupMessageEvent) -> bool:
 
 @dream_ban_cleanup_msg.handle()
 async def _(_bot: Bot, event: GroupMessageEvent, state: T_State):
-    if "[CQ:reply," not in try_convert_to_cqcode(event.raw_message):
+    raw_message = await resolve_dream_ban_reply_raw(_bot, event)
+    if not raw_message.strip():
         return
-    raw_message = ""
-    for item in event.reply.message:  # type: ignore
-        raw_reply = str(item)
-        raw_message += re.sub(r"(\[CQ\:.+)(?:,url=*)(\])", r"\1\2", raw_reply)
     reply_plain = ""
     try:
         if event.reply and getattr(event.reply, "message", None):
             reply_plain = event.reply.message.extract_plain_text()
+        elif raw_message:
+            reply_plain = Message(raw_message).extract_plain_text()
     except Exception:
         pass
     n = await delete_dream_messages_from_ban_reply(

src/plugins/ingress_gate/__init__.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import re
 
 from nonebot import get_driver, logger
 from nonebot.adapters.onebot.v11 import GroupMessageEvent
@@ -80,6 +81,14 @@ def group_at_qq_ids(event: GroupMessageEvent) -> frozenset[int]:
             out.add(int(qq))
         except (TypeError, ValueError):
             continue
+    if out:
+        return frozenset(out)
+    raw_message = event.raw_message or ""
+    for match in re.finditer(r"\[(?:CQ:)?at(?:,qq=|:qq=)(\d+)", raw_message):
+        try:
+            out.add(int(match.group(1)))
+        except (TypeError, ValueError):
+            continue
     return frozenset(out)
 
 

src/plugins/repeater/__init__.py

@@ -8,7 +8,7 @@
 from nonebot.adapters.onebot.v11 import GroupMessageEvent, GroupRecallNoticeEvent, Message, MessageSegment, permission
 from nonebot.exception import ActionFailed
 from nonebot.plugin import PluginMetadata
-from nonebot.rule import Rule, keyword, to_me
+from nonebot.rule import Rule
 from nonebot.typing import T_State
 from nonebot_plugin_apscheduler import scheduler
 
@@ -25,6 +25,7 @@
 from src.foundation.config import BotConfig
 from src.platform.observability import SlowPathTimer, slow_path_threshold_ms
 from src.plugins.dream.ban_ack_state import DREAM_BAN_ACK_SENT_STATE_KEY
+from src.shared.reply_command_rule import event_has_reply_target, event_targets_self, extract_reply_id_from_raw_message
 from src.shared.utils.array2cqcode import try_convert_to_cqcode
 from src.shared.utils.media_cache import get_image, insert_image
 
@@ -260,11 +261,49 @@ async def _(bot: Bot, event: GroupMessageEvent):
 
 
 async def is_reply(event: GroupMessageEvent) -> bool:
-    return bool(event.reply)
+    return event_has_reply_target(event)
+
+
+async def is_ban_reply_trigger(event: GroupMessageEvent) -> bool:
+    if "不可以" not in event.get_plaintext():
+        return False
+    if not await is_reply(event):
+        return False
+    return event_targets_self(event)
+
+
+def extract_ban_reply_raw_from_message(message: Message | str) -> str:
+    if isinstance(message, str):
+        return message
+
+    raw_message = ""
+    for item in message:
+        raw_reply = str(item)
+        raw_message += re.sub(r"(\[CQ\:.+)(?:,url=*)(\])", r"\1\2", raw_reply)
+    if not raw_message.strip():
+        raw_message = message.extract_plain_text()
+    return raw_message
+
+
+async def resolve_ban_reply_raw(bot: Bot, event: GroupMessageEvent) -> str:
+    if event.reply and getattr(event.reply, "message", None):
+        return extract_ban_reply_raw_from_message(event.reply.message)
+
+    reply_id = extract_reply_id_from_raw_message(event.raw_message)
+    if reply_id is None:
+        return ""
+
+    try:
+        msg = await bot.get_msg(message_id=reply_id)
+    except ActionFailed:
+        logger.warning(f"bot [{event.self_id}] failed to get replied msg [{reply_id}] in group [{event.group_id}]")
+        return ""
+
+    return extract_ban_reply_raw_from_message(Message(msg["message"]))
 
 
 ban_msg = on_message(
-    rule=to_me() & keyword("不可以") & Rule(is_reply),
+    rule=Rule(is_ban_reply_trigger),
     priority=5,
     block=True,
     permission=group_message_permission_for_command("repeater.ban"),
@@ -273,21 +312,18 @@ async def is_reply(event: GroupMessageEvent) -> bool:
 
 @ban_msg.handle()
 async def _(bot: Bot, event: GroupMessageEvent, state: T_State):
-    if not event.reply:
+    raw_message = await resolve_ban_reply_raw(bot, event)
+    if not raw_message.strip():
+        logger.info(f"bot [{event.self_id}] ban skipped (empty reply target) in group [{event.group_id}]")
         return
 
-    raw_message = ""
-    for item in event.reply.message:  # type: ignore
-        raw_reply = str(item)
-        # 去掉图片消息中的 url, subType 等字段
-        raw_message += re.sub(r"(\[CQ\:.+)(?:,url=*)(\])", r"\1\2", raw_reply)
-
     logger.info(f"bot [{event.self_id}] ready to ban [{raw_message}] in group [{event.group_id}]")
 
-    try:
-        await bot.delete_msg(message_id=event.reply.message_id)  # type: ignore
-    except ActionFailed:
-        logger.warning(f"bot [{event.self_id}] failed to delete [{raw_message}] in group [{event.group_id}]")
+    if event.reply:
+        try:
+            await bot.delete_msg(message_id=event.reply.message_id)  # type: ignore
+        except ActionFailed:
+            logger.warning(f"bot [{event.self_id}] failed to delete [{raw_message}] in group [{event.group_id}]")
 
     banned = await Chat.ban(event.group_id, event.self_id, raw_message, str(event.user_id))
     if banned:
@@ -355,8 +391,14 @@ async def message_is_ban(bot: Bot, event: GroupMessageEvent, state: T_State) ->
     return event.get_plaintext().strip() == "不可以发这个"
 
 
+async def is_ban_latest_trigger(bot: Bot, event: GroupMessageEvent, state: T_State) -> bool:
+    if not await message_is_ban(bot, event, state):
+        return False
+    return event_targets_self(event)
+
+
 ban_msg_latest = on_message(
-    rule=to_me() & Rule(message_is_ban),
+    rule=Rule(is_ban_latest_trigger),
     priority=5,
     block=True,
     permission=group_message_permission_for_command("repeater.ban_latest"),

src/plugins/repeater/ban_manager.py

@@ -2,6 +2,8 @@
 import time
 from collections import defaultdict
 
+from nonebot import logger
+
 from src.foundation.db import Ban, Context, make_blacklist_repository
 from src.foundation.db.context_repo_access import context_repo
 
@@ -62,34 +64,57 @@ def iter_ban_bot_ids(group_id: int, bot_id: int, reply_dict: dict) -> list[int]:
                 bot_ids.append(bid)
         return bot_ids
 
+    @staticmethod
+    async def find_ban_reply_fallback(group_id: int, ban_raw_message: str) -> dict | None:
+        if not ban_raw_message.strip():
+            return None
+        find_target = getattr(context_repo, "find_ban_reply_target", None)
+        if not callable(find_target):
+            return None
+        try:
+            found = await find_target(group_id, ban_raw_message)
+        except RuntimeError as exc:
+            logger.debug("repeater ban fallback skipped for group {}: {}", group_id, exc)
+            return None
+        if not found:
+            return None
+        pre_keywords, reply_keywords = found
+        return {
+            "pre_keywords": pre_keywords,
+            "reply_keywords": reply_keywords,
+        }
+
     @staticmethod
     async def ban(group_id: int, bot_id: int, ban_raw_message: str, reason: str, reply_dict: dict) -> bool:
         """
         禁止以后回复这句话，仅对该群有效果
         """
+        ban_reply = None
         for candidate_bot_id in BanManager.iter_ban_bot_ids(group_id, bot_id, reply_dict):
             ban_reply = BanManager.find_ban_reply(group_id, candidate_bot_id, ban_raw_message, reply_dict)
-            if not ban_reply:
-                continue
-
-            pre_keywords = ban_reply["pre_keywords"]
-            keywords = ban_reply["reply_keywords"]
+            if ban_reply:
+                break
+        if not ban_reply:
+            ban_reply = await BanManager.find_ban_reply_fallback(group_id, ban_raw_message)
+        if not ban_reply:
+            return False
 
-            # 通过 append_ban 细粒度 API 原子追加，避免整文档读-改-写。
-            # 当 Context(keywords=pre_keywords) 不存在时为 no-op（Mongo update_one matched=0）。
-            ban_reason = Ban(keywords=keywords, group_id=group_id, reason=reason, time=int(time.time()))
-            await context_repo.append_ban(pre_keywords, ban_reason)
+        pre_keywords = ban_reply["pre_keywords"]
+        keywords = ban_reply["reply_keywords"]
 
-            if keywords in BanManager._blacklist_answer_reserve[group_id]:
-                BanManager._blacklist_answer[group_id].add(keywords)
-                if keywords in BanManager._blacklist_answer_reserve[BanManager.BLACKLIST_FLAG]:
-                    BanManager._blacklist_answer[BanManager.BLACKLIST_FLAG].add(keywords)
-            else:
-                BanManager._blacklist_answer_reserve[group_id].add(keywords)
+        # 通过 append_ban 细粒度 API 原子追加，避免整文档读-改-写。
+        # 当 Context(keywords=pre_keywords) 不存在时为 no-op（Mongo update_one matched=0）。
+        ban_reason = Ban(keywords=keywords, group_id=group_id, reason=reason, time=int(time.time()))
+        await context_repo.append_ban(pre_keywords, ban_reason)
 
-            return True
+        if keywords in BanManager._blacklist_answer_reserve[group_id]:
+            BanManager._blacklist_answer[group_id].add(keywords)
+            if keywords in BanManager._blacklist_answer_reserve[BanManager.BLACKLIST_FLAG]:
+                BanManager._blacklist_answer[BanManager.BLACKLIST_FLAG].add(keywords)
+        else:
+            BanManager._blacklist_answer_reserve[group_id].add(keywords)
 
-        return False
+        return True
 
     @staticmethod
     async def find_ban_keywords(context: Context | None, group_id) -> set: