成语接龙接入 LLM 和 MarkDown、LaTeX 接入

Merge pull request '让豆包水印使用相对大小' (#47 ) from feature/doubao-watermark into master
Reviewed-on: #47
2025-11-09 23:12:04 +08:00 · 2025-11-07 21:17:16 +08:00 · 2025-11-07 21:17:09 +08:00 · 2025-11-07 21:15:19 +08:00 · 2025-11-07 19:18:41 +08:00 · 2025-11-07 19:18:24 +08:00
64 changed files with 3801 additions and 432 deletions
--- a/.drone.yml
+++ b/.drone.yml
@ -38,6 +38,17 @@ steps:
        path: /var/run/docker.sock
    commands:
      - docker run --rm gitea.service.jazzwhom.top/mttu-developers/konabot:nightly-${DRONE_COMMIT_SHA} python scripts/test_plugin_load.py
+  - name: 发送构建结果到 ntfy
+    image: parrazam/drone-ntfy
+    when:
+      status: [success, failure]
+    settings:
+      url: https://ntfy.service.jazzwhom.top
+      topic: drone_ci
+      tags:
+        - drone-ci
+      token:
+        from_secret: NTFY_TOKEN

 volumes:
  - name: docker-socket
@ -74,6 +85,17 @@ steps:
    volumes:
      - name: docker-socket
        path: /var/run/docker.sock
+  - name: 发送构建结果到 ntfy
+    image: parrazam/drone-ntfy
+    when:
+      status: [success, failure]
+    settings:
+      url: https://ntfy.service.jazzwhom.top
+      topic: drone_ci
+      tags:
+        - drone-ci
+      token:
+        from_secret: NTFY_TOKEN

 volumes:
  - name: docker-socket
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -0,0 +1,3 @@
+{
+    "python.REPL.enableREPLSmartSend": false
+}
--- a/28
+++ b/28
@ -1,22 +1,32 @@
-# copied from https://www.martinrichards.me/post/python_poetry_docker/
 FROM python:3.13-slim AS base

 ENV VIRTUAL_ENV=/app/.venv \
-    PATH="/app/.venv/bin:$PATH"
+    PATH="/app/.venv/bin:$PATH" \
+    PLAYWRIGHT_BROWSERS_PATH=0

+# 安装所有都需要的底层依赖
 RUN apt-get update && \
    apt-get install -y --no-install-recommends \
-    libfontconfig1 \
-    libgl1 \
-    libegl1 \
-    libglvnd0 \
-    mesa-vulkan-drivers \
+    libfontconfig1 libgl1 libegl1 libglvnd0 mesa-vulkan-drivers at-spi2-common fontconfig \
+    libasound2-data libavahi-client3 libavahi-common-data libavahi-common3 libdatrie1 \
+    libfontenc1 libfribidi0 libgraphite2-3 libharfbuzz0b libice6 libpixman-1-0 \
+    libsm6 libthai-data libthai0 libunwind8 libxaw7 libxcb-render0 libxfont2 libxi6 \
+    libxkbfile1 libxmu6 libxpm4 libxrender1 libxt6t64 x11-common x11-xkb-utils \
+    xfonts-encodings xfonts-utils xkb-data xserver-common libnspr4 libatk1.0-0t64 \
+    libatk-bridge2.0-0t64 libatspi2.0-0t64 libxcomposite1 libxdamage1 libxfixes3 \
+    libxkbcommon0 libasound2t64 libnss3 fonts-noto-cjk fonts-noto-cjk-extra \
+    fonts-noto-color-emoji \
    && rm -rf /var/lib/apt/lists/*



 FROM base AS builder

+# 安装构建依赖
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential cmake git \
+    && rm -rf /var/lib/apt/lists/*
+
 ENV POETRY_NO_INTERACTION=1 \
    POETRY_VIRTUALENVS_IN_PROJECT=1 \
    POETRY_VIRTUALENVS_CREATE=1 \
@ -24,7 +34,7 @@ ENV POETRY_NO_INTERACTION=1 \

 WORKDIR /app

-RUN pip install poetry
+RUN pip install --no-cache-dir poetry

 COPY pyproject.toml poetry.lock ./
 RUN python -m poetry install --no-root && rm -rf $POETRY_CACHE_DIR
@ -37,6 +47,8 @@ COPY --from=builder ${VIRTUAL_ENV} ${VIRTUAL_ENV}

 WORKDIR /app

+RUN python -m playwright install chromium
+
 COPY bot.py pyproject.toml .env.prod .env.test ./
 COPY assets ./assets
 COPY scripts ./scripts
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# 此方 bot！
+# konabot

 在 MTTU 内部使用的 bot 一只。

@ -63,12 +63,20 @@ code .

 配置 `ENABLE_CONSOLE=false`

+#### 配置并支持 LLM（大语言模型）
+
+详见[LLM 配置文档](/docs/LLM.md)。
+
+#### 配置 konabot-web 以支持更高级的图片渲染
+
+详见[konabot-web 配置文档](/docs/konabot-web.md)
+
 ### 运行

 使用命令行手动启动 Bot：

 ```bash
-poetry run watchfiles bot.main konabot
+poetry run watchfiles bot.main . --filter scripts.watch_filter.filter
 ```

 如果你不希望自动重载，只是想运行 Bot，可以直接运行：
--- a/assets/img/ac/ac.png
+++ b/assets/img/ac/ac.png
--- a/assets/img/ac/broken_ac.png
+++ b/assets/img/ac/broken_ac.png
--- a/assets/img/ac/frozen_ac.png
+++ b/assets/img/ac/frozen_ac.png
--- a/assets/img/dog/haha_dog.jpg
+++ b/assets/img/dog/haha_dog.jpg
--- a/assets/img/meme/doubao.png
+++ b/assets/img/meme/doubao.png
--- a/assets/img/meme/kiosay.jpg
+++ b/assets/img/meme/kiosay.jpg
--- a/assets/img/other/boom.jpg
+++ b/assets/img/other/boom.jpg
--- a/assets/webpage/ac/assets/background.png
+++ b/assets/webpage/ac/assets/background.png
--- a/assets/webpage/ac/index.html
+++ b/assets/webpage/ac/index.html
@ -0,0 +1,76 @@
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>空调炸炸排行榜</title>
+    </head>
+    <body>
+        <div class="box">
+            <div class="text">位居全球第 <span id="ranking" class="ranking">200</span>！</div>
+            <div class="text-2">您的群总共坏了 <span id="number" class="number">200</span> 台空调</div>
+            <img class="background" src="./assets/background.png" alt="空调炸炸排行榜">
+        </div>
+    </body>
+    <style>
+        .box {
+            position: relative;
+            width: 1024px;
+        }
+        .number {
+            font-size: 2em;
+            color: #ffdd00;
+            text-shadow: 3px 3px 6px rgba(0, 0, 0, 0.7);
+            font-weight: bold;
+            font-stretch: 50%;
+            max-width: 520px;
+            word-wrap: break-word;
+            line-height: 0.8em;
+        }
+        .background {
+            width: 1024px;
+        }
+        .text {
+            position: absolute;
+            top: 125px;
+            width: 100%;
+            font-size: 72px;
+            color: white;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.7);
+            font-weight: bolder;
+            display: flex;
+            align-items: baseline;
+            justify-content: center;
+        }
+        .text-2 {
+            position: absolute;
+            top: 50px;
+            width: 100%;
+            font-size: 48px;
+            color: white;
+            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.7);
+            font-weight: bolder;
+            display: flex;
+            align-items: baseline;
+            justify-content: center;
+        }
+        .ranking {
+            font-size: 2em;
+            color: #ff0000;
+            -webkit-text-stroke: #ffffff 2px;
+            text-shadow: 3px 3px 6px rgba(0, 0, 0, 0.7);
+            font-weight: bold;
+            font-stretch: 50%;
+        }
+    </style>
+    <script>
+        // 从 URL 参数中获取 number 的值
+        const urlParams = new URLSearchParams(window.location.search);
+        const number = urlParams.get('number');
+        // 将 number 显示在页面上
+        document.getElementById('number').textContent = number;
+        // 从 URL 参数中获取 ranking 的值
+        const ranking = urlParams.get('ranking');
+        // 将 ranking 显示在页面上
+        document.getElementById('ranking').textContent = ranking;
+    </script>
+</html>
--- a/docs/LLM.md
+++ b/docs/LLM.md
@ -0,0 +1,65 @@
+# 大语言模型平台接入
+
+为实现更多神秘小功能，此方 Bot 需要接入 AI。如果你需要参与开发或测试涉及 AI 的相关功能，麻烦请根据下面的文档继续操作。
+
+## 配置项目接入 AI
+
+AI 相关的配置文件在 `data/config/llm.json` 文件中。示例格式如下，这也将是到时候在云端的配置文件格式（给出的模型都会有）：
+
+```json
+{
+  "llms": {
+    "Qwen2.5-7B-Instruct": {
+      "base_url": "https://api.siliconflow.cn/v1",
+      "api_key": "sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
+      "model_name": "Qwen/Qwen2.5-7B-Instruct"
+    },
+    "qwen3-max": {
+      "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
+      "api_key": "sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
+      "model_name": "qwen3-max"
+    }
+  },
+  "default_llm": "Qwen2.5-7B-Instruct"
+}
+```
+
+其中，形如 `qwen3-max` 的名称，是你在程序中调用 LLM 使用的键名。若不给出，则会默认使用配置文件中指定的默认模型。
+
+```python
+from konabot.common.llm import get_llm
+
+llm = get_llm()               # 获得的是 Qwen2.5-7B-Instruct 模型
+llm = get_llm("qwen3-max")    # 获得的是 qwen3-max 模型
+
+message = await llm.chat([
+  { "role": "system", "content": "你是一只猫娘" },
+  { "role": "user", "content": "晚上好呀！" },
+], timeout=None, max_tokens=16384)
+# 获得了的是 openai.types.chat.ChatCompletionMessage 对象
+
+print(f"AI 返回值：{message.content}")    # 注意 content 可能为 None，需要做空值检测
+
+client = llm.get_openai_client()    # 获得的是一个 OpenAI Client 对象，可以做更多操作
+                                    # 例如，调用 Embedding 模型来做知识库向量化等工作
+```
+
+## 本项目使用的模型清单
+
+为了便利大家使用，我在这里给出该项目将会使用的模型清单，请根据你的开发需求注册并选择你最喜欢的模型。如果需要接入新的模型，或者使用到文档之外的模型，欢迎在这里给出！
+
+### 硅基流动 Qwen/Qwen2.5-7B-Instruct
+
+一个 7B 大小的 AI 模型。其性能不太能指望，但是它小，而且比较快，可以做一些轻量的操作。
+
+该模型是免费的，但是也需要你注册[硅基流动](https://cloud.siliconflow.cn/me/models)账号，并生成 `api_key` 添加到配置文件中。
+
+### 通义千问 qwen3-max
+
+贵但是很先进的最新模型，其能力可以信赖。但是不要拿它做大量工作哦！
+
+在[百炼大模型平台](https://bailian.console.aliyun.com/)注册账号并申请 `api_key`，新用户会赠送 1M tokens，足够做测试了。
+
+## 安全须知
+
+请注意提防 AI 越狱等情况。
--- a/docs/konabot-web.md
+++ b/docs/konabot-web.md
@ -0,0 +1,18 @@
+# konabot-web 配置文档
+
+本文档教你配置一个此方 Bot 的 Web 服务器。
+
+## 安装并运行 konabot-web
+
+按照 [konabot-web README](https://gitea.service.jazzwhom.top/mttu-developers/konabot-web) 安装并运行 konabot-web 实例。
+
+## 指定 konabot-web 实例地址
+
+如果你的 Web 服务器的端口不是 5173，或者你有特殊的网络结构，你需要手动设置 konabot-web。编辑 `.env` 文件：
+
+```
+MODULE_WEB_RENDER_WEBURL=http://web-server:port
+MODULE_WEB_RENDER_INSTANCE=http://konabot-server:port
+```
+
+替换 web-server 为你的前端服务器地址，konabot-server 为后端服务器地址，port 为端口号。
--- a/konabot/common/data_man.py
+++ b/konabot/common/data_man.py
@ -19,12 +19,12 @@ class DataManager(Generic[T]):
        if not self.fp.exists():
            return self.cls()
        try:
-            return self.cls.model_validate_json(self.fp.read_text())
+            return self.cls.model_validate_json(self.fp.read_text("utf-8"))
        except ValidationError:
            return self.cls()

    def save(self, data: T):
-        self.fp.write_text(data.model_dump_json())
+        self.fp.write_text(data.model_dump_json(), "utf-8")

    @asynccontextmanager
    async def get_data(self):
--- a/konabot/common/llm/init.py
+++ b/konabot/common/llm/init.py
@ -0,0 +1,64 @@
+from typing import Any
+import openai
+
+from loguru import logger
+from openai.types.chat import ChatCompletion, ChatCompletionMessage, ChatCompletionMessageParam
+from pydantic import BaseModel, Field
+
+from konabot.common.path import CONFIG_PATH
+
+LLM_CONFIG_PATH = CONFIG_PATH / 'llm.json'
+
+if not LLM_CONFIG_PATH.exists():
+    LLM_CONFIG_PATH.write_text("{}")
+
+
+class LLMInfo(BaseModel):
+    base_url: str
+    api_key: str
+    model_name: str
+
+    def get_openai_client(self):
+        return openai.AsyncClient(
+            api_key=self.api_key,
+            base_url=self.base_url,
+        )
+
+    async def chat(
+        self,
+        messages: list[ChatCompletionMessageParam],
+        timeout: float | None = 30.0,
+        max_tokens: int | None = None,
+        **kwargs: Any,
+    ) -> ChatCompletionMessage:
+        logger.info(f"调用 LLM: BASE_URL={self.base_url} MODEL_NAME={self.model_name}")
+        completion: ChatCompletion = await self.get_openai_client().chat.completions.create(
+            messages=messages,
+            model=self.model_name,
+            max_tokens=max_tokens,
+            timeout=timeout,
+            stream=False,
+            **kwargs,
+        )
+        choice = completion.choices[0]
+        logger.info(
+            f"调用 LLM 完成: BASE_URL={self.base_url} MODEL_NAME={self.model_name} REASON={choice.finish_reason}"
+        )
+        return choice.message
+
+
+class LLMConfig(BaseModel):
+    llms: dict[str, LLMInfo] = Field(default_factory=dict)
+    default_llm: str = "Qwen2.5-7B-Instruct"
+
+
+llm_config = LLMConfig.model_validate_json(LLM_CONFIG_PATH.read_text())
+
+
+def get_llm(llm_model: str | None = None):
+    if llm_model is None:
+        llm_model = llm_config.default_llm
+    if llm_model not in llm_config.llms:
+        raise NotImplementedError("LLM 未配置，该功能无法使用")
+    return llm_config.llms[llm_model]
+
--- a/konabot/common/longtask.py
+++ b/konabot/common/longtask.py
@ -51,13 +51,20 @@ class LongTaskTarget(BaseModel):
    target_id: str
    "沟通对象的 ID"

-    async def send_message(self, msg: UniMessage, at: bool = True) -> bool:
+    @property
+    def is_private_chat(self):
+        return self.channel_id.startswith(QQ_PRIVATE_CHAT_CHANNEL_PREFIX)
+
+    async def send_message(self, msg: UniMessage | str, at: bool = True) -> bool:
        try:
            bot = nonebot.get_bot(self.self_id)
        except KeyError:
            logger.warning(f"试图访问了不存在的 Bot。ID={self.self_id}")
            return False

+        if isinstance(msg, str):
+            msg = UniMessage.text(msg)
+
        if self.platform == "qq":
            if not isinstance(bot, OBBot):
                logger.warning(
@ -66,7 +73,7 @@ class LongTaskTarget(BaseModel):
                    } BOT_CLASS={bot.__class__.__name__}"
                )
                return False
-            if self.channel_id.startswith(QQ_PRIVATE_CHAT_CHANNEL_PREFIX):
+            if self.channel_id.startswith(QQ_PRIVATE_CHAT_CHANNEL_PREFIX) or not self.channel_id.strip():
                # 私聊模式
                await bot.send_private_msg(
                    user_id=int(self.target_id),
@ -119,18 +126,18 @@ class LongTask(BaseModel):
    target: LongTaskTarget
    callback: str
    deadline: datetime.datetime
-    canceled: bool = False

    _aio_task: asynkio.Task | None = None

    async def run(self):
        now = datetime.datetime.now()
-        if self.deadline < now and not self.canceled:
+        if self.deadline < now:
            await self._run_task()
            return
        await asynkio.sleep((self.deadline - now).total_seconds())
-        if self.canceled:
-            return
+        async with longtask_data() as data:
+            if self.uuid not in data.to_handle[self.callback]:
+                return
        await self._run_task()

    async def _run_task(self):
@ -140,11 +147,7 @@ class LongTask(BaseModel):
                f"Callback {self.callback} 未曾被注册，但是被期待调用，已忽略"
            )
            async with longtask_data() as datafile:
-                datafile.to_handle[self.callback] = [
-                    t
-                    for t in datafile.to_handle.get(self.callback, [])
-                    if t.uuid != self.uuid
-                ]
+                del datafile.to_handle[self.callback][self.uuid]
                datafile.unhandled.setdefault(self.callback, []).append(self)

            return
@ -155,9 +158,7 @@ class LongTask(BaseModel):
        except Exception as e:
            logger.exception(e)
        async with longtask_data() as datafile:
-            datafile.to_handle[self.callback] = [
-                t for t in datafile.to_handle[self.callback] if t.uuid != self.uuid
-            ]
+            del datafile.to_handle[self.callback][self.uuid]
            if not success:
                datafile.unhandled.setdefault(self.callback, []).append(self)
                logger.info(
@ -181,7 +182,7 @@ class LongTask(BaseModel):


 class LongTaskModuleData(BaseModel):
-    to_handle: dict[str, list[LongTask]]
+    to_handle: dict[str, dict[str, LongTask]]
    unhandled: dict[str, list[LongTask]]


@ -239,7 +240,7 @@ def handle_long_task(callback_id: str):

 def _load_longtask_data() -> LongTaskModuleData:
    try:
-        txt = LONGTASK_DATA_DIR.read_text()
+        txt = LONGTASK_DATA_DIR.read_text("utf-8")
        return LongTaskModuleData.model_validate_json(txt)
    except (FileNotFoundError, ValidationError) as e:
        logger.info(f"取得 LongTask 数据时出现问题：{e}")
@ -250,7 +251,7 @@ def _load_longtask_data() -> LongTaskModuleData:


 def _save_longtask_data(data: LongTaskModuleData):
-    LONGTASK_DATA_DIR.write_text(data.model_dump_json())
+    LONGTASK_DATA_DIR.write_text(data.model_dump_json(), "utf-8")


@asynccontextmanager
@ -279,7 +280,7 @@ async def create_longtask(
    await task.start()

    async with longtask_data() as d:
-        d.to_handle.setdefault(handler, []).append(task)
+        d.to_handle.setdefault(handler, {})[task.uuid] = task

    return task

@ -290,7 +291,7 @@ async def init_longtask():

    async with longtask_data() as data:
        for v in data.to_handle.values():
-            for t in v:
+            for t in v.values():
                await t.start()
                counter += 1
                req.add(t.callback)
--- a/konabot/common/nb/extract_image.py
+++ b/konabot/common/nb/extract_image.py
@ -8,22 +8,38 @@ import nonebot
 from nonebot.matcher import Matcher
 from nonebot.adapters import Bot, Event, Message
 from nonebot.adapters.discord import Bot as DiscordBot
+from nonebot.adapters.discord import MessageEvent as DiscordMessageEvent
+from nonebot.adapters.discord.config import Config as DiscordConfig
 from nonebot.adapters.onebot.v11 import Bot as OnebotV11Bot
 from nonebot.adapters.onebot.v11 import Message as OnebotV11Message
 from nonebot.adapters.onebot.v11 import MessageEvent as OnebotV11MessageEvent
 import nonebot.params
 from nonebot_plugin_alconna import Image, RefNode, Reply, UniMessage
 from PIL import UnidentifiedImageError
+from pydantic import BaseModel
 from returns.result import Failure, Result, Success

-from konabot.common.nb.exc import BotExceptionMessage
+from konabot.common.path import ASSETS_PATH


-async def download_image_bytes(url: str) -> Result[bytes, str]:
+discordConfig = nonebot.get_plugin_config(DiscordConfig)
+
+
+class ExtractImageConfig(BaseModel):
+    module_extract_image_no_download: bool = False
+    "要不要算了，不下载了，直接爆炸算了，适用于一些比较奇怪的网络环境，无法从协议端下载文件"
+
+
+module_config = nonebot.get_plugin_config(ExtractImageConfig)
+
+
+async def download_image_bytes(url: str, proxy: str | None = None) -> Result[bytes, str]:
    # if "/matcha/cache/" in url:
    #     url = url.replace('127.0.0.1', '10.126.126.101')
+    if module_config.module_extract_image_no_download:
+        return Success((ASSETS_PATH / "img" / "other" / "boom.jpg").read_bytes())
    logger.debug(f"开始从 {url} 下载图片")
-    async with httpx.AsyncClient() as c:
+    async with httpx.AsyncClient(proxy=proxy) as c:
        try:
            response = await c.get(url)
        except (httpx.ConnectError, httpx.RemoteProtocolError) as e:
@ -123,6 +139,14 @@ async def extract_image_from_message(
        logger.debug('获取图片的路径 Fallback 到 QQ 模块')
        return await extract_image_from_qq_message(msg, evt, bot, allow_reply)

+    if isinstance(evt, DiscordMessageEvent):
+        logger.debug('获取图片的路径方式走 Discord')
+        for a in evt.attachments:
+            if "image/" not in a.content_type:
+                continue
+            url = a.proxy_url
+            return (await download_image_bytes(url, discordConfig.discord_proxy)).bind(bytes_to_pil)
+
    for seg in UniMessage.of(msg, bot):
        logger.info(seg)
        if isinstance(seg, Image):
--- a/konabot/common/nb/qq_broadcast.py
+++ b/konabot/common/nb/qq_broadcast.py
@ -0,0 +1,33 @@
+from typing import Any, cast
+
+import nonebot
+from nonebot.adapters.onebot.v11 import Bot as OBBot
+from nonebot_plugin_alconna import UniMessage
+
+
+async def qq_broadcast(groups: list[str], msg: UniMessage[Any] | str):
+    if isinstance(msg, str):
+        msg = UniMessage.text(msg)
+    bots: dict[str, OBBot] = {}
+
+    # group_id -> bot_id
+    availabilities: dict[str, str] = {}
+
+    for bot_id, bot in nonebot.get_bots().items():
+        if not isinstance(bot, OBBot):
+            continue
+        bots[bot_id] = bot
+        gl = await bot.get_group_list()
+        for g in gl:
+            gid = str(g.get("group_id", -1))
+            if gid in groups:
+                availabilities[gid] = bot_id
+
+    for group in groups:
+        if group in availabilities:
+            bot = bots[availabilities[group]]
+            await bot.send_group_msg(
+                group_id=int(group),
+                message=cast(Any, await msg.export(bot)),
+                auto_escape=False,
+            )
--- a/konabot/common/path.py
+++ b/konabot/common/path.py
@ -6,6 +6,7 @@ FONTS_PATH = ASSETS_PATH / "fonts"
 SRC_PATH = Path(__file__).resolve().parent.parent
 DATA_PATH = SRC_PATH.parent / "data"
 LOG_PATH = DATA_PATH / "logs"
+CONFIG_PATH = DATA_PATH / "config"

 DOCS_PATH = SRC_PATH / "docs"
 DOCS_PATH_MAN1 = DOCS_PATH / "user"
@ -19,3 +20,5 @@ if not DATA_PATH.exists():
 if not LOG_PATH.exists():
    LOG_PATH.mkdir()

+CONFIG_PATH.mkdir(exist_ok=True)
+
--- a/konabot/common/username.py
+++ b/konabot/common/username.py
@ -0,0 +1,54 @@
+import re
+import nonebot
+
+from nonebot.adapters.onebot.v11 import Bot as OBBot
+
+
+class UsernameManager:
+    grouped_data: dict[int, dict[int, str]]
+    individual_data: dict[int, str]
+
+    def __init__(self) -> None:
+        self.grouped_data = {}
+        self.individual_data = {}
+
+    async def update(self):
+        for bot in nonebot.get_bots().values():
+            if isinstance(bot, OBBot):
+                for user in await bot.get_friend_list():
+                    uid = user["user_id"]
+                    nickname = user["nickname"]
+                    self.individual_data[uid] = nickname
+                for group in await bot.get_group_list():
+                    gid = group["group_id"]
+                    for member in await bot.get_group_member_list(group_id=gid):
+                        uid = member["user_id"]
+                        card = member.get("card", "")
+                        nickname = member.get("nickname", "")
+                        if card:
+                            self.grouped_data.setdefault(gid, {})[uid] = card
+                        if nickname:
+                            self.individual_data[uid] = nickname
+
+    def get(self, qqid: int, groupid: int | None = None) -> str:
+        if groupid is not None and groupid in self.grouped_data:
+            n = self.grouped_data[groupid].get(qqid)
+            if n is not None:
+                return n
+        if qqid in self.individual_data:
+            return self.individual_data[qqid]
+        return str(qqid)
+
+
+manager = UsernameManager()
+
+def get_username(qqid: int | str, group: int | str | None = None):
+    if isinstance(group, str):
+        group = None if not re.match(r"^\d+$", group) else int(group)
+    if isinstance(qqid, str):
+        if re.match(r"^\d+$", qqid):
+            qqid = int(qqid)
+        else:
+            return qqid
+    return manager.get(qqid, group)
+
--- a/konabot/common/utils/to_async.py
+++ b/konabot/common/utils/to_async.py
@ -0,0 +1,17 @@
+import asyncio
+import functools
+
+from typing import Awaitable, Callable, ParamSpec, TypeVar
+
+
+TA = ParamSpec("TA")
+T = TypeVar("T")
+
+
+def make_async(func: Callable[TA, T]) -> Callable[TA, Awaitable[T]]:
+    @functools.wraps(func, assigned=("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"))
+    async def wrapper(*args: TA.args, **kwargs: TA.kwargs):
+        return await asyncio.to_thread(func, *args, **kwargs)
+
+    return wrapper
+
--- a/konabot/common/web_render/init.py
+++ b/konabot/common/web_render/init.py
@ -0,0 +1,9 @@
+from .config import web_render_config
+from .core import WebRenderer as WebRenderer
+from .core import WebRendererInstance as WebRendererInstance
+
+
+def konaweb(sub_url: str):
+    sub_url = '/' + sub_url.removeprefix('/')
+    return web_render_config.module_web_render_weburl.removesuffix('/') + sub_url
+
--- a/konabot/common/web_render/config.py
+++ b/konabot/common/web_render/config.py
@ -0,0 +1,19 @@
+import nonebot
+
+from pydantic import BaseModel
+
+class Config(BaseModel):
+    module_web_render_weburl: str = "localhost:5173"
+    module_web_render_instance: str = ""
+
+    def get_instance_baseurl(self):
+        if self.module_web_render_instance:
+            return self.module_web_render_instance.removesuffix('/')
+        config = nonebot.get_driver().config
+        ip = str(config.host)
+        if ip == "0.0.0.0":
+            ip = "127.0.0.1"
+        port = config.port
+        return f'http://{ip}:{port}'
+
+web_render_config = nonebot.get_plugin_config(Config)
--- a/konabot/common/web_render/core.py
+++ b/konabot/common/web_render/core.py
@ -0,0 +1,281 @@
+import asyncio
+import queue
+from typing import Any, Callable, Coroutine
+from loguru import logger
+from playwright.async_api import (
+    Page,
+    Playwright,
+    async_playwright,
+    Browser,
+    BrowserContext,
+)
+
+
+PageFunction = Callable[[Page], Coroutine[Any, Any, Any]]
+
+
+class WebRenderer:
+    browser_pool: queue.Queue["WebRendererInstance"] = queue.Queue()
+    context_pool: dict[int, BrowserContext] = {}  # 长期挂载的浏览器上下文池
+    page_pool: dict[str, Page] = {}  # 长期挂载的页面池
+
+    @classmethod
+    async def get_browser_instance(cls) -> "WebRendererInstance":
+        if cls.browser_pool.empty():
+            instance = await WebRendererInstance.create()
+            cls.browser_pool.put(instance)
+        instance = cls.browser_pool.get()
+        cls.browser_pool.put(instance)
+        return instance
+
+    @classmethod
+    async def get_browser_context(cls) -> BrowserContext:
+        instance = await cls.get_browser_instance()
+        if id(instance) not in cls.context_pool:
+            context = await instance.browser.new_context()
+            cls.context_pool[id(instance)] = context
+            logger.debug(
+                f"Created new persistent browser context for WebRendererInstance {id(instance)}"
+            )
+        return cls.context_pool[id(instance)]
+
+    @classmethod
+    async def render(
+        cls,
+        url: str,
+        target: str,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
+        """
+        访问指定URL并返回截图
+
+        :param url: 目标URL
+        :param target: 渲染目标，如 ".box"、"#main" 等CSS选择器
+        :param timeout: 页面加载超时时间，单位秒
+        :param params: URL键值对参数
+        :param other_function: 其他自定义操作函数，接受page参数
+        :return: 截图的字节数据
+
+        """
+        instance = await cls.get_browser_instance()
+        logger.debug(
+            f"Using WebRendererInstance {id(instance)} to render {url} targeting {target}"
+        )
+        return await instance.render(
+            url, target, params=params, other_function=other_function, timeout=timeout
+        )
+
+    @classmethod
+    async def render_persistent_page(
+        cls,
+        page_id: str,
+        url: str,
+        target: str,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
+        """
+        使用长期挂载的页面访问指定URL并返回截图
+
+        :param page_id: 页面唯一标识符
+        :param url: 目标URL
+        :param target: 渲染目标，如 ".box"、"#main" 等CSS选择器
+        :param timeout: 页面加载超时时间，单位秒
+        :param params: URL键值对参数
+        :param other_function: 其他自定义操作函数，接受page参数
+        :return: 截图的字节数据
+
+        """
+        logger.debug(
+            f"Requesting persistent render for page_id {page_id} at {url} targeting {target} with timeout {timeout}"
+        )
+        instance = await cls.get_browser_instance()
+        if page_id not in cls.page_pool:
+            context = await cls.get_browser_context()
+            page = await context.new_page()
+            cls.page_pool[page_id] = page
+            logger.debug(
+                f"Created new persistent page for page_id {page_id} using WebRendererInstance {id(instance)}"
+            )
+        page = cls.page_pool[page_id]
+        return await instance.render_with_page(
+            page,
+            url,
+            target,
+            params=params,
+            other_function=other_function,
+            timeout=timeout,
+        )
+
+    @classmethod
+    async def render_file(
+        cls,
+        file_path: str,
+        target: str,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
+        """
+        访问指定本地文件URL并返回截图
+
+        :param file_path: 目标文件路径
+        :param target: 渲染目标，如 ".box"、"#main" 等CSS选择器
+        :param timeout: 页面加载超时时间，单位秒
+        :param params: URL键值对参数
+        :param other_function: 其他自定义操作函数，接受page参数
+        :return: 截图的字节数据
+
+        """
+        instance = await cls.get_browser_instance()
+        logger.debug(
+            f"Using WebRendererInstance {id(instance)} to render file {file_path} targeting {target}"
+        )
+        return await instance.render_file(
+            file_path,
+            target,
+            params=params,
+            other_function=other_function,
+            timeout=timeout,
+        )
+
+    @classmethod
+    async def close_persistent_page(cls, page_id: str) -> None:
+        """
+        关闭并移除长期挂载的页面
+
+        :param page_id: 页面唯一标识符
+        """
+        if page_id in cls.page_pool:
+            page = cls.page_pool[page_id]
+            await page.close()
+            del cls.page_pool[page_id]
+            logger.debug(f"Closed and removed persistent page for page_id {page_id}")
+
+
+class WebRendererInstance:
+    def __init__(self):
+        self._playwright: Playwright | None = None
+        self._browser: Browser | None = None
+        self.lock = asyncio.Lock()
+
+    @property
+    def playwright(self) -> Playwright:
+        assert self._playwright is not None
+        return self._playwright
+
+    @property
+    def browser(self) -> Browser:
+        assert self._browser is not None
+        return self._browser
+
+    async def init(self):
+        self._playwright = await async_playwright().start()
+        self._browser = await self.playwright.chromium.launch(headless=True)
+
+    @classmethod
+    async def create(cls) -> "WebRendererInstance":
+        instance = cls()
+        await instance.init()
+        return instance
+
+    async def render(
+        self,
+        url: str,
+        target: str,
+        index: int = 0,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
+        """
+        访问指定URL并返回截图
+
+        :param url: 目标URL
+        :param target: 渲染目标，如 ".box"、"#main" 等CSS选择器
+        :param timeout: 页面加载超时时间，单位秒
+        :param index: 如果目标是一个列表，指定要截图的元素索引
+        :param params: URL键值对参数
+        :param other_function: 其他自定义操作函数，接受page参数
+        :return: 截图的字节数据
+
+        """
+        async with self.lock:
+            context = await self.browser.new_context()
+            page = await context.new_page()
+            screenshot = await self.inner_render(
+                page, url, target, index, params, other_function, timeout
+            )
+            await page.close()
+            await context.close()
+            return screenshot
+
+    async def render_with_page(
+        self,
+        page: Page,
+        url: str,
+        target: str,
+        index: int = 0,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
+        async with self.lock:
+            screenshot = await self.inner_render(
+                page, url, target, index, params, other_function, timeout
+            )
+            return screenshot
+
+    async def render_file(
+        self,
+        file_path: str,
+        target: str,
+        index: int = 0,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
+        file_path = "file:///" + str(file_path).replace("\\", "/")
+        return await self.render(
+            file_path, target, index, params, other_function, timeout
+        )
+
+    async def inner_render(
+        self,
+        page: Page,
+        url: str,
+        target: str,
+        index: int = 0,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
+        logger.debug(f"Navigating to {url} with timeout {timeout}")
+        url_with_params = url + (
+            "?" + "&".join(f"{k}={v}" for k, v in params.items()) if params else ""
+        )
+        await page.goto(url_with_params, timeout=timeout * 1000, wait_until="load")
+        logger.debug("Page loaded successfully")
+        # 等待目标元素出现
+        await page.wait_for_selector(target, timeout=timeout * 1000)
+        logger.debug(f"Target element '{target}' found, taking screenshot")
+        if other_function:
+            await other_function(page)
+        elements = await page.query_selector_all(target)
+        if not elements:
+            logger.warning(f"Target element '{target}' not found on the page.")
+            elements = await page.query_selector_all('body')
+        if index >= len(elements):
+            logger.warning(f"Index {index} out of range for elements matching '{target}'")
+            index = 0
+        element = elements[index]
+        screenshot = await element.screenshot()
+        logger.debug("Screenshot taken successfully")
+        return screenshot
+
+    async def close(self):
+        await self.browser.close()
+        await self.playwright.stop()
--- a/konabot/common/web_render/host_images.py
+++ b/konabot/common/web_render/host_images.py
@ -0,0 +1,66 @@
+import asyncio
+import tempfile
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import cast
+
+from fastapi import HTTPException
+from fastapi.responses import FileResponse
+import nanoid
+import nonebot
+
+from nonebot.drivers.fastapi import Driver as FastAPIDriver
+
+from .config import web_render_config
+
+app = cast(FastAPIDriver, nonebot.get_driver()).asgi
+
+hosted_tempdirs: dict[str, Path] = {}
+hosted_tempdirs_lock = asyncio.Lock()
+
+
+@dataclass
+class TempDir:
+    path: Path
+    url_base: str
+
+    def url_of(self, file: Path):
+        assert file.is_relative_to(self.path)
+        relative_path = file.relative_to(self.path)
+        url_path_segment = str(relative_path).replace("\\", "/")
+        return f"{self.url_base}/{url_path_segment}"
+
+
+@asynccontextmanager
+async def host_tempdir():
+    with tempfile.TemporaryDirectory() as tempdir:
+        fp = Path(tempdir)
+        nid = nanoid.generate(size=10)
+        async with hosted_tempdirs_lock:
+            hosted_tempdirs[nid] = fp
+        yield TempDir(
+            path=fp,
+            url_base=f"{web_render_config.get_instance_baseurl()}/tempdir/{nid}",
+        )
+        async with hosted_tempdirs_lock:
+            del hosted_tempdirs[nid]
+
+
+@app.get("/tempdir/{nid}/{file_path:path}")
+async def _(nid: str, file_path: str):
+    async with hosted_tempdirs_lock:
+        base_path = hosted_tempdirs.get(nid)
+    if base_path is None:
+        raise HTTPException(404)
+    full_path = base_path / file_path
+    try:
+        if not full_path.resolve().is_relative_to(base_path.resolve()):
+             raise HTTPException(status_code=403, detail="Access denied.")
+    except Exception:
+        raise HTTPException(status_code=403, detail="Access denied.")
+    if not full_path.is_file():
+        raise HTTPException(status_code=404, detail="File not found.")
+
+    return FileResponse(full_path.resolve())
+
--- a/konabot/docs/concepts/中间答案.txt
+++ b/konabot/docs/concepts/中间答案.txt
@ -0,0 +1,11 @@
+关于「中间答案」或者「提示」：
+
+在 KonaPH 中，当有人发送「提交答案 答案」时，会检查答案是否符合你设置的中间答案的 pattern。这个 pattern 可以有两种方式：
+
+- 纯文本的完整匹配：你设置的 pattern 如果和提交的答案完全相等，则会触发提示。
+- regex 匹配：你设置的 pattern 如果以斜杠（/）开头和结尾，就会检查提交的答案是否匹配正则表达式。注意 ^ 和 $ 符号的使用。
+    - 例如：/^commit$/ 会匹配 commit，不会匹配 acommit、Commit 等。
+    - 而如果是 /commit/，则会匹配 commit、acommit，而不会匹配 Commit。
+    - 无法使用 Javascript 的字符串声明模式，例如，/case_insensitive/i 就不会被视作一个正则表达式。
+
+一个提示是提示，还是中间答案，取决于它是否有 checkpoint 标记。如果有 checkpoint 标记，则会提示用户「你回答了一个中间答案」，并且这个中间答案的回答会在排行榜中显示。
--- a/konabot/docs/lib/占位.md
+++ b/konabot/docs/lib/占位.md
--- a/konabot/docs/sys/konaph.txt
+++ b/konabot/docs/sys/konaph.txt
@ -0,0 +1,4 @@
+指令介绍
+    konaph - KonaBot 的 PuzzleHunt 管理工具
+
+详细介绍请直接输入 konaph 获取使用指引（该指令权限仅对部分人开放。如果你有权限的话才有响应。建议在此方 BOT 私聊使用该指令。）
--- a/konabot/docs/sys/怪话过滤.txt
+++ b/konabot/docs/sys/怪话过滤.txt
@ -1,9 +0,0 @@
-指令介绍
-    怪话过滤 - 去除含有关键词的怪话
-
-使用方法
-    `怪话过滤 说的道理`
-        去除所有含有“说的道理”的怪话
-
-另见
-    怪话(1)
--- a/konabot/docs/user/ntfy.txt
+++ b/konabot/docs/user/ntfy.txt
@ -0,0 +1,15 @@
+指令介绍
+    ntfy - 配置使用 ntfy 来更好地为你通知此方 BOT 代办
+
+指令示例
+    `ntfy 创建`
+        创建一个随机的 ntfy 订阅主题来提醒代办，此方 Bot 将会给你使用指引。你可以前往 https://ntfy.sh/ 官网下载 ntfy APP，或者使用网页版 ntfy。
+
+    `ntfy 创建 kagami-notice`
+        创建一个名字含有 kagami-notice 的 ntfy 订阅主题
+
+    `ntfy 删除`
+        清除并不再使用 ntfy 向你通知
+
+另见
+    提醒我(1) 查询提醒(1) 删除提醒(1)
--- a/konabot/docs/user/删除提醒.txt
+++ b/konabot/docs/user/删除提醒.txt
@ -0,0 +1,8 @@
+指令介绍
+    删除提醒 - 删除在`查询提醒(1)`中查到的提醒
+
+指令示例
+    `删除提醒 1` 在查询提醒后，删除编号为 1 的提醒
+
+另见
+    提醒我(1) 查询提醒(1) ntfy(1)
--- a/konabot/docs/user/怪话.txt
+++ b/konabot/docs/user/怪话.txt
@ -1,12 +0,0 @@
-指令介绍
-    说点怪话/说些怪话 - 让 BOT 学群友胡言乱语
-
-适用范围
-    为保证安全，只有少数授权的群聊可以使用该指令
-
-使用方法
-    `说点怪话 今天吃什么`
-        期待 Bot 会回答你什么吧
-
-    `说些怪话 明天不想上体育课`
-        Bot 会回复你三句怪话
--- a/konabot/docs/user/提醒我.txt
+++ b/konabot/docs/user/提醒我.txt
@ -0,0 +1,15 @@
+指令介绍
+    提醒我 - 在指定的时间提醒人事项的工具
+
+使用示例
+    `下午五点提醒我吃饭`
+        创建一个下午五点的提醒，提醒你吃饭
+
+    `两分钟后提醒我睡觉`
+        创建一个相对于现在推迟 2 分钟的提醒，提醒你睡觉
+
+    `2026年4月25日20点整提醒我生日快乐`
+        创建一个指定日期和时间的提醒
+
+另见
+    查询提醒(1) 删除提醒(1) ntfy(1)
--- a/konabot/docs/user/查询提醒.txt
+++ b/konabot/docs/user/查询提醒.txt
@ -0,0 +1,9 @@
+指令介绍
+    查询提醒 - 查询已经创建的提醒
+
+指令格式
+    `查询提醒` 查询提醒
+    `查询提醒 2` 查询第二页提醒
+
+另见
+    提醒我(1) 删除提醒(1) ntfy(1)
--- a/konabot/plugins/air_conditioner/init.py
+++ b/konabot/plugins/air_conditioner/init.py
@ -0,0 +1,162 @@
+from io import BytesIO
+from typing import Optional, Union
+import cv2
+from nonebot.adapters import Event as BaseEvent
+from nonebot.adapters.console.event import MessageEvent as ConsoleMessageEvent
+from nonebot.adapters.discord.event import MessageEvent as DiscordMessageEvent
+from nonebot_plugin_alconna import Alconna, AlconnaMatcher, Args, UniMessage, on_alconna
+from PIL import Image
+import numpy as np
+from konabot.common.longtask import DepLongTaskTarget
+from konabot.common.path import ASSETS_PATH
+from konabot.common.web_render import WebRenderer
+from konabot.plugins.air_conditioner.ac import AirConditioner, CrashType, generate_ac_image, wiggle_transform
+
+import random
+import math
+
+def get_ac(id: str) -> AirConditioner:
+    ac = AirConditioner.air_conditioners.get(id)
+    if ac is None:
+        ac = AirConditioner(id)
+    return ac
+
+async def send_ac_image(event: type[AlconnaMatcher], ac: AirConditioner):
+    if(ac.burnt == True):
+        # 打开坏掉的空调图片
+        with open(ASSETS_PATH / "img" / "ac" / "broken_ac.png", "rb") as f:
+            # 将其转为 GIF 格式发送
+            output = BytesIO()
+            Image.open(f).save(output, format="GIF")
+            output.seek(0)
+            await event.send(await UniMessage().image(raw=output).export())
+        return
+    if(ac.frozen == True):
+        # 打开坏掉的空调图片
+        with open(ASSETS_PATH / "img" / "ac" / "frozen_ac.png", "rb") as f:
+            # 将其转为 GIF 格式发送
+            output = BytesIO()
+            Image.open(f).save(output, format="GIF")
+            output.seek(0)
+            await event.send(await UniMessage().image(raw=output).export())
+        return
+    ac_image = await generate_ac_image(ac)
+    await event.send(await UniMessage().image(raw=ac_image).export())
+
+evt = on_alconna(Alconna(
+    "群空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "开空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    ac.on = True
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "关空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    ac.on = False
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "空调升温",
+    Args["temp?", Optional[Union[int, float]]]  # 可选参数，升温的度数，默认为1
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget, temp: Optional[Union[int, float]] = 1):
+    if temp <= 0:
+        return
+    id = target.channel_id
+    ac = get_ac(id)
+    if not ac.on or ac.burnt == True or ac.frozen == True:
+        await send_ac_image(evt, ac)
+        return
+    ac.temperature += temp
+    if ac.temperature > 40:
+        # 根据温度随机出是否爆炸，40度开始，呈指数增长
+        possibility = -math.e ** ((40-ac.temperature) / 50) + 1
+        if random.random() < possibility:
+            # 打开爆炸图片
+            with open(ASSETS_PATH / "img" / "other" / "boom.jpg", "rb") as f:
+                output = BytesIO()
+                # 爆炸抖动
+                frames = wiggle_transform(np.array(Image.open(f)), intensity=5)
+                pil_frames = [Image.fromarray(frame) for frame in frames]
+                pil_frames[0].save(output, format="GIF", save_all=True, append_images=pil_frames[1:], loop=0, duration=35, disposal=2)
+                output.seek(0)
+                await evt.send(await UniMessage().image(raw=output).export())
+            ac.broke_ac(CrashType.BURNT)
+            await evt.send("太热啦，空调炸了！")
+            return
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "空调降温",
+    Args["temp?", Optional[Union[int, float]]]  # 可选参数，降温的度数，默认为1
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget, temp: Optional[Union[int, float]] = 1):
+    if temp <= 0:
+        return
+    id = target.channel_id
+    ac = get_ac(id)
+    if not ac.on or ac.burnt == True or ac.frozen == True:
+        await send_ac_image(evt, ac)
+        return
+    ac.temperature -= temp
+    if ac.temperature < 0:
+        # 根据温度随机出是否冻结，0度开始，呈指数增长
+        possibility = -math.e ** (ac.temperature / 50) + 1
+        if random.random() < possibility:
+            ac.broke_ac(CrashType.FROZEN)
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "换空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    ac.change_ac()
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "空调炸炸排行榜",
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    number, ranking = ac.get_crashes_and_ranking()
+    params = {
+        "number": number,
+        "ranking": ranking
+    }
+    image = await WebRenderer.render_file(
+        file_path=ASSETS_PATH / "webpage" / "ac" / "index.html",
+        target=".box",
+        params=params
+    )
+    await evt.send(await UniMessage().image(raw=image).export())
--- a/konabot/plugins/air_conditioner/ac.py
+++ b/konabot/plugins/air_conditioner/ac.py
@ -0,0 +1,288 @@
+from enum import Enum
+from io import BytesIO
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from konabot.common.path import ASSETS_PATH, FONTS_PATH
+from konabot.common.path import DATA_PATH
+import json
+
+class CrashType(Enum):
+    BURNT = 0
+    FROZEN = 1
+
+class AirConditioner:
+    air_conditioners: dict[str, "AirConditioner"] = {}
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+        self.on = False
+        self.temperature = 24  # 默认温度
+        self.burnt = False
+        self.frozen = False
+        AirConditioner.air_conditioners[id] = self
+
+    def change_ac(self):
+        self.burnt = False
+        self.frozen = False
+        self.on = False
+        self.temperature = 24  # 重置为默认温度
+
+    def broke_ac(self, crash_type: CrashType):
+        '''
+        让空调坏掉，并保存数据
+
+        :param crash_type: CrashType 枚举，表示空调坏掉的类型
+        '''
+        match crash_type:
+            case CrashType.BURNT:
+                self.burnt = True
+            case CrashType.FROZEN:
+                self.frozen = True
+        self.save_crash_data(crash_type)
+
+    def save_crash_data(self, crash_type: CrashType):
+        '''
+        如果空调爆炸了，就往本地的 ac_crash_data.json 里该 id 的记录加一
+        '''
+        data_file = DATA_PATH / "ac_crash_data.json"
+        crash_data = {}
+        if data_file.exists():
+            with open(data_file, "r", encoding="utf-8") as f:
+                crash_data = json.load(f)
+        if self.id not in crash_data:
+            crash_data[self.id] = {"burnt": 0, "frozen": 0}
+        match crash_type:
+            case CrashType.BURNT:
+                crash_data[self.id]["burnt"] += 1
+            case CrashType.FROZEN:
+                crash_data[self.id]["frozen"] += 1
+        with open(data_file, "w", encoding="utf-8") as f:
+            json.dump(crash_data, f, ensure_ascii=False, indent=4)
+
+    def get_crashes_and_ranking(self) -> tuple[int, int]:
+        '''
+        获取该群在全国空调损坏的数量与排行榜的位置
+        '''
+        data_file = DATA_PATH / "ac_crash_data.json"
+        if not data_file.exists():
+            return 0, 1
+        with open(data_file, "r", encoding="utf-8") as f:
+            crash_data = json.load(f)
+        ranking_list = []
+        for gid, record in crash_data.items():
+            total = record.get("burnt", 0) + record.get("frozen", 0)
+            ranking_list.append((gid, total))
+        ranking_list.sort(key=lambda x: x[1], reverse=True)
+        total_crashes = crash_data.get(self.id, {}).get("burnt", 0) + crash_data.get(self.id, {}).get("frozen", 0)
+        rank = 1
+        for gid, total in ranking_list:
+            if gid == self.id:
+                break
+            rank += 1
+        return total_crashes, rank
+
+def text_to_transparent_image(text, font_size=40, padding=0, text_color=(0, 0, 0)):
+    """
+    将文本转换为带透明背景的图像，图像大小刚好包含文本
+    """
+    # 创建临时图像来计算文本尺寸
+    temp_image = Image.new('RGB', (1, 1), (255, 255, 255))
+    temp_draw = ImageDraw.Draw(temp_image)
+    
+    font = ImageFont.truetype(FONTS_PATH / "montserrat.otf", font_size)
+    
+    # 获取文本边界框
+    bbox = temp_draw.textbbox((0, 0), text, font=font)
+    text_width = bbox[2] - bbox[0]
+    text_height = bbox[3] - bbox[1]
+    
+    # 计算图像大小（文本大小 + 内边距）
+    image_width = int(text_width + 2 * padding)
+    image_height = int(text_height + 2 * padding)
+    
+    # 创建RGBA模式的空白图像（带透明通道）
+    image = Image.new('RGBA', (image_width, image_height), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+    
+    # 绘制文本（考虑内边距）
+    x = padding - bbox[0]  # 调整起始位置
+    y = padding - bbox[1]
+    
+    # 设置文本颜色（带透明度）
+    if len(text_color) == 3:
+        text_color = text_color + (255,)  # 添加完全不透明的alpha值
+    
+    draw.text((x, y), text, fill=text_color, font=font)
+    
+    # 转换为OpenCV格式（BGRA）
+    image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGBA2BGRA)
+    return image_cv
+
+def perspective_transform(image, target, corners):
+    """
+    对图像进行透视变换（保持透明通道）
+    target: 画布
+    corners: 四个角点的坐标，顺序为 [左上, 右上, 右下, 左下]
+    """
+    height, width = image.shape[:2]
+    
+    # 源点（原始图像的四个角）
+    src_points = np.array([
+        [0, 0],           # 左上
+        [width-1, 0],     # 右上
+        [width-1, height-1], # 右下
+        [0, height-1]     # 左下
+    ], dtype=np.float32)
+    
+    # 目标点（变换后的四个角）
+    dst_points = np.array(corners, dtype=np.float32)
+    
+    # 计算透视变换矩阵
+    matrix = cv2.getPerspectiveTransform(src_points, dst_points)
+    
+    # 获取画布大小
+    target_height, target_width = target.shape[:2]
+
+    # 应用透视变换（保持所有通道，包括alpha）
+    transformed = cv2.warpPerspective(image, matrix, (target_width, target_height), flags=cv2.INTER_LINEAR)
+
+    return transformed, matrix
+
+def blend_with_transparency(background, foreground, position):
+    """
+    将带透明通道的前景图像合成到背景图像上
+    position: 前景图像在背景图像上的位置 (x, y)
+    """
+    bg = background.copy()
+    
+    # 如果背景没有alpha通道，添加一个
+    if bg.shape[2] == 3:
+        bg = cv2.cvtColor(bg, cv2.COLOR_BGR2BGRA)
+        bg[:, :, 3] = 255  # 完全不透明
+    
+    x, y = position
+    fg_height, fg_width = foreground.shape[:2]
+    bg_height, bg_width = bg.shape[:2]
+    
+    # 确保位置在图像范围内
+    x = max(0, min(x, bg_width - fg_width))
+    y = max(0, min(y, bg_height - fg_height))
+    
+    # 提取前景的alpha通道并归一化
+    alpha_foreground = foreground[:, :, 3] / 255.0
+    
+    # 对于每个颜色通道进行合成
+    for c in range(3):
+        bg_region = bg[y:y+fg_height, x:x+fg_width, c]
+        fg_region = foreground[:, :, c]
+        
+        # alpha混合公式
+        bg[y:y+fg_height, x:x+fg_width, c] = (
+            alpha_foreground * fg_region + 
+            (1 - alpha_foreground) * bg_region
+        )
+    
+    # 更新背景的alpha通道（如果需要）
+    bg_alpha_region = bg[y:y+fg_height, x:x+fg_width, 3]
+    bg[y:y+fg_height, x:x+fg_width, 3] = np.maximum(bg_alpha_region, foreground[:, :, 3])
+    
+    return bg
+
+def precise_blend_with_perspective(background, foreground, corners):
+    """
+    精确合成：根据四个角点将前景图像透视合成到背景上
+    """
+    # 创建与背景相同大小的空白图像
+    bg_height, bg_width = background.shape[:2]
+    
+    # 如果背景没有alpha通道，转换为BGRA
+    if background.shape[2] == 3:
+        background_bgra = cv2.cvtColor(background, cv2.COLOR_BGR2BGRA)
+    else:
+        background_bgra = background.copy()
+    
+    # 创建与背景相同大小的前景图层
+    foreground_layer = np.zeros((bg_height, bg_width, 4), dtype=np.uint8)
+    
+    # 计算前景图像在背景中的边界框
+    min_x = int(min(corners[:, 0]))
+    max_x = int(max(corners[:, 0]))
+    min_y = int(min(corners[:, 1]))
+    max_y = int(max(corners[:, 1]))
+    
+    # 将变换后的前景图像放置到对应位置
+    fg_height, fg_width = foreground.shape[:2]
+    if min_y + fg_height <= bg_height and min_x + fg_width <= bg_width:
+        foreground_layer[min_y:min_y+fg_height, min_x:min_x+fg_width] = foreground
+    
+    # 创建掩码（只在前景有内容的地方合成）
+    mask = (foreground_layer[:, :, 3] > 0)
+    
+    # 合成图像
+    result = background_bgra.copy()
+    for c in range(3):
+        result[:, :, c][mask] = foreground_layer[:, :, c][mask]
+    result[:, :, 3][mask] = foreground_layer[:, :, 3][mask]
+    
+    return result
+
+def wiggle_transform(image, intensity=2) -> list[np.ndarray]:
+    '''
+    返回一组图像振动的帧组，模拟空调运作时的抖动效果
+    '''
+    frames = []
+    height, width = image.shape[:2]
+    shifts = [(-intensity, 0), (intensity, 0), (0, -intensity), (0, intensity), (0, 0)]
+    for dx, dy in shifts:
+        M = np.float32([[1, 0, dx], [0, 1, dy]])
+        shifted = cv2.warpAffine(image, M, (width, height))
+        frames.append(shifted)
+    return frames
+
+async def generate_ac_image(ac: AirConditioner) -> BytesIO:
+    # 找到空调底图
+    ac_image = cv2.imread(str(ASSETS_PATH / "img" / "ac" / "ac.png"), cv2.IMREAD_UNCHANGED)
+
+    if not ac.on:
+        # 空调关闭状态，直接返回底图
+        pil_final = Image.fromarray(ac_image)
+        output = BytesIO()
+        pil_final.save(output, format="GIF")
+        return output
+
+    # 根据生成温度文本图像
+    text = f"{round(ac.temperature, 1)}°C"
+    text_image = text_to_transparent_image(
+        text, 
+        font_size=60, 
+        text_color=(0, 0, 0)  # 黑色文字
+    )
+
+    # 获取长宽比
+    height, width = text_image.shape[:2]
+    aspect_ratio = width / height
+
+    # 定义3D变换的四个角点（透视效果）
+    # 顺序: [左上, 右上, 右下, 左下]
+    corners = np.array([
+        [123, 45],    # 左上
+        [284, 101],   # 右上
+        [290, 140],   # 右下
+        [119, 100]    # 左下
+    ], dtype=np.float32)
+    
+    # 对文本图像进行3D变换（保持透明通道）
+    transformed_text, transform_matrix = perspective_transform(text_image, ac_image, corners)
+
+    final_image_simple = blend_with_transparency(ac_image, transformed_text, (0, 0))
+
+    intensity = max(2, abs(int(ac.temperature) - 24) // 2)
+
+    frames = wiggle_transform(final_image_simple, intensity=intensity)
+    pil_frames = [Image.fromarray(frame) for frame in frames]
+    output = BytesIO()
+    pil_frames[0].save(output, format="GIF", save_all=True, append_images=pil_frames[1:], loop=0, duration=50, disposal=2)
+    return output
--- a/konabot/plugins/fortune/init.py
+++ b/konabot/plugins/fortune/init.py
@ -1,68 +0,0 @@
-import asyncio
-from nonebot import get_plugin_config, on_command, on_message
-from nonebot.adapters import Bot
-from nonebot.adapters.onebot.v11.event import GroupMessageEvent
-from nonebot_plugin_alconna import Alconna, Args, UniMessage, UniMsg, on_alconna
-from pydantic import BaseModel
-
-from konabot.common.nb.is_admin import is_admin
-from konabot.common.path import DATA_PATH
-
-from .random_text_record import RandomTextManager
-
-
-class FortuneConfig(BaseModel):
-    plugin_fortune_collect_groups: list[int] = []
-
-
-fortune_wtf = RandomTextManager(DATA_PATH / "fortune_wtf.txt")
-fortune_insert_lock = asyncio.Lock()
-fortune_config = get_plugin_config(FortuneConfig)
-
-
-async def is_collect_target(evt: GroupMessageEvent) -> bool:
-    if evt.group_id not in fortune_config.plugin_fortune_collect_groups:
-        return False
-    return True
-
-
-evt_collector = on_message(rule=is_collect_target)
-
-@evt_collector.handle()
-async def _(msg: UniMsg):
-    txt = msg.extract_plain_text()
-    if len(txt) > 50 or not txt.strip():
-        return
-    if txt.startswith("说点怪话") or txt.startswith("说些怪话") or txt.startswith("怪话过滤"):
-        return
-    async with fortune_insert_lock:
-        fortune_wtf.insert(txt)
-
-
-cmd_guaihua = on_command("说点怪话", rule=is_collect_target)
-
-@cmd_guaihua.handle()
-async def _(bot: Bot):
-    await cmd_guaihua.send(await UniMessage().text(fortune_wtf.choice()).export(bot))
-
-
-cmd_guaihuas = on_command("说些怪话", rule=is_collect_target)
-
-@cmd_guaihuas.handle()
-async def _(bot: Bot):
-    for _ in range(3):
-        await cmd_guaihuas.send(await UniMessage().text(fortune_wtf.choice()).export(bot))
-        await asyncio.sleep(1)
-
-
-cmd_filter_guaihua = on_alconna(Alconna(
-    "怪话过滤",
-    Args["keyword", str],
-), rule=is_admin)
-
-@cmd_filter_guaihua.handle()
-async def _(keyword: str, bot: Bot):
-    async with fortune_insert_lock:
-        c = fortune_wtf.filter_out(keyword)
-    await cmd_filter_guaihua.send(await UniMessage().text(f"删除了 {c} 条怪话").export(bot))
-
--- a/konabot/plugins/fortune/random_text_record.py
+++ b/konabot/plugins/fortune/random_text_record.py
@ -1,70 +0,0 @@
-import base64
-import random
-import time
-
-from pathlib import Path
-
-
-class RandomTextManager:
-    _cache: list[tuple[float, str]]
-
-    def __init__(self, fp: Path) -> None:
-        self.fp = fp
-        self._cache = []
-        if not self.fp.exists():
-            self.fp.touch()
-        else:
-            self.load()
-
-    def load(self):
-        self._cache = []
-        with self.fp.open("r") as f:
-            for line in f.readlines():
-                if not line.strip():
-                    continue
-                if "|" not in line:
-                    continue
-                ts, cn = line.split("|")
-                try:
-                    ts = float(ts)
-                except Exception:
-                    continue
-                self._cache.append((ts, base64.b64decode(cn).decode("utf-8")))
-
-    def save(self):
-        lines = [
-            str(ts) + "|" + base64.b64encode(cn.encode("utf-8")).decode()
-            for ts, cn in self._cache
-        ]
-        with self.fp.open("w") as f:
-            f.writelines(lines)
-
-    def insert(self, text: str, timestamp: float | None = None):
-        if timestamp is None:
-            timestamp = time.time()
-        with self.fp.open("a") as f:
-            f.write(str(timestamp) + "|" + base64.b64encode(text.encode("utf-8")).decode() + "\n")
-        self._cache.append((timestamp, text))
-
-    def choice(self, now: float | None = None):
-        contents: list[str] = []
-        weights: list[float] = []
-
-        if now is None:
-            now = time.time()
-
-        for ts, cn in self._cache:
-            contents.append(cn)
-            weights.append((abs(now - ts) + 0.01) ** (-1))
-
-        return random.choices(contents, weights)[0]
-
-    def filter_out(self, keyword: str):
-        len1 = len(self._cache)
-        self._cache = [
-            (ts, cn) for ts, cn in self._cache
-            if keyword not in cn
-        ]
-        self.save()
-        return len1 - len(self._cache)
-
--- a/konabot/plugins/hanzi/init.py
+++ b/konabot/plugins/hanzi/init.py
@ -0,0 +1,217 @@
+import random
+from typing import Optional
+import opencc
+
+from nonebot import on_message
+from nonebot.adapters import Event as BaseEvent
+from nonebot.adapters.discord.event import MessageEvent as DiscordMessageEvent
+from nonebot_plugin_alconna import (
+    Alconna,
+    Args,
+    UniMessage,
+    UniMsg,
+    on_alconna,
+)
+
+convert_type = ["简","簡","繁","正","港","日"]
+
+compiled_str = "|".join([f"{a}{mid}{b}" for mid in ["转","轉","転"] for a in convert_type for b in convert_type if a != b])
+
+def hanzi_to_abbr(hanzi: str) -> str:
+    mapping = {
+        "简": "s",
+        "簡": "s",
+        "繁": "t",
+        "正": "t",
+        "港": "hk",
+        "日": "jp",
+    }
+    return mapping.get(hanzi, "")
+
+def check_valid_convert_type(convert_type: str) -> bool:
+    avaliable_set = ["s2t","t2s","s2tw","tw2s","s2hk","hk2s","s2twp","tw2sp","t2tw","hk2t","t2hk","t2jp","jp2t","tw2t"]
+    if convert_type in avaliable_set:
+        return True
+    return False
+
+def convert(source, src_abbr, dst_abbr):
+    convert_type_key = f"{src_abbr}2{dst_abbr}"
+    if not check_valid_convert_type(convert_type_key):
+        # 先转为繁体，再转为目标
+        converter = opencc.OpenCC(f"{src_abbr}2t.json")
+        source = converter.convert(source)
+        src_abbr = "t"
+    converter = opencc.OpenCC(f"{src_abbr}2{dst_abbr}.json")
+    converted = converter.convert(source)
+    return converted
+
+evt = on_alconna(
+    Alconna(
+        f"re:({compiled_str})",
+        Args["source?", str],
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=True,
+)
+
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent, source: Optional[str] = None):
+    if isinstance(event, DiscordMessageEvent):
+        content = event.get_message().extract_plain_text()
+    else:
+        content = event.get_message().extract_plain_text()
+
+    prefix = content.split()[0]
+    to_convert = ""
+    # 如果回复了消息，则转换回复的内容
+    if(source is None):
+        if event.reply:
+            to_convert = event.reply.message.extract_plain_text()
+            if not to_convert:
+                return
+        else:
+            return
+    else:
+        to_convert = source
+    parts = []
+    if "转" in prefix:
+        parts = prefix.split("转")
+    elif "轉" in prefix:
+        parts = prefix.split("轉")
+    elif "転" in prefix:
+        parts = prefix.split("転")
+    if len(parts) != 2:
+        notice = "转换格式错误，请使用“简转繁”、“繁转简”等格式。"
+        await evt.send(await UniMessage().text(notice).export())
+        return
+    src, dst = parts
+    src_abbr = hanzi_to_abbr(src)
+    dst_abbr = hanzi_to_abbr(dst)
+    if not src_abbr or not dst_abbr:
+        notice = "不支持的转换类型，请使用“简”、“繁”、“正”、“港”、“日”等。"
+        if src_abbr:
+            notice = convert(notice, "s", src_abbr)
+        await evt.send(await UniMessage().text(notice).export())
+        return
+    
+    converted = convert(to_convert, src_abbr, dst_abbr)
+
+    converted_prefix = convert("转换结果", "s", dst_abbr)
+
+    await evt.send(await UniMessage().text(f"{converted_prefix}：{converted}").export())
+
+shuo = ["说","說"]
+
+full_name_type = ["简体","簡體","繁體","繁体","正體","正体","港話","港话","日文"]
+
+combined_list = [f"{a}{b}" for a in shuo for b in full_name_type]
+
+compiled_str_2 = "|".join(combined_list)
+
+evt = on_alconna(
+    Alconna(
+        f"re:({compiled_str_2})",
+        Args["source?", str]
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=True,
+)
+
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent, source: Optional[str] = None):
+    if isinstance(event, DiscordMessageEvent):
+        content = event.get_message().extract_plain_text()
+    else:
+        content = event.get_message().extract_plain_text()
+
+    prefix = content.split()[0]
+    to_convert = ""
+    # 如果回复了消息，则转换回复的内容
+    if(source is None):
+        if event.reply:
+            to_convert = event.reply.message.extract_plain_text()
+            if not to_convert:
+                return
+        else:
+            return
+    else:
+        to_convert = source
+    # 获取目标转换类型
+    dst = ""
+    match prefix:
+        case "说简体" | "說簡體" | "说簡體" | "說简体":
+            dst = "简"
+        case "說繁體" | "说繁体" | "說繁体" | "说繁體":
+            dst = "繁"
+        case "說正體" | "说正体" | "說正体" | "说正體":
+            dst = "正"
+        case "說港話" | "说港话" | "說港话" | "说港話":
+            dst = "港"
+        case "說日文" | "说日文":
+            dst = "日"
+    dst_abbr = hanzi_to_abbr(dst)
+    if not dst_abbr:
+        notice = "不支持的转换类型，请使用“简体”、“繁體”、“正體”、“港話”、“日文”等。"
+        await evt.send(await UniMessage().text(notice).export())
+        return
+    # 循环，将源语言一次次转换为目标语言
+    current_text = to_convert
+    for src_abbr in ["s","hk","jp","tw","t"]:
+        if src_abbr != dst_abbr:
+            current_text = convert(current_text, src_abbr, dst_abbr)
+
+    converted_prefix = convert("转换结果", "s", dst_abbr)
+
+    await evt.send(await UniMessage().text(f"{converted_prefix}：{current_text}").export())
+
+def random_char(char: str) -> str:
+    dst_abbr = random.choice(["s","t","hk","jp","tw"])
+    for src_abbr in ["s","hk","jp","tw","t"]:
+        if src_abbr != dst_abbr:
+            char = convert(char, src_abbr, dst_abbr)
+    return char
+
+def random_string(text: str) -> str:
+    final_text = ""
+    for char in text:
+        final_text += random_char(char)
+    return final_text
+
+random_match = ["混乱字形","混亂字形","乱数字形","亂數字形","ランダム字形"]
+
+evt = on_alconna(
+    Alconna(
+        f"re:({'|'.join(random_match)})",
+        Args["source?", str]
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=True,
+)
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent, source: Optional[str] = None):
+    if isinstance(event, DiscordMessageEvent):
+        content = event.get_message().extract_plain_text()
+    else:
+        content = event.get_message().extract_plain_text()
+
+    prefix = content.split()[0]
+    to_convert = ""
+    # 如果回复了消息，则转换回复的内容
+    if(source is None):
+        if event.reply:
+            to_convert = event.reply.message.extract_plain_text()
+            if not to_convert:
+                return
+        else:
+            return
+    else:
+        to_convert = source
+
+    final_text = ""
+    final_text = random_string(to_convert)
+    converted_prefix = convert(random_string("转换结果"), "s", "s")
+
+    await evt.send(await UniMessage().text(f"{converted_prefix}：{final_text}").export())
--- a/konabot/plugins/idiomgame/init.py
+++ b/konabot/plugins/idiomgame/init.py
@ -21,16 +21,19 @@ from nonebot_plugin_alconna import (
 from konabot.common.longtask import DepLongTaskTarget
 from konabot.common.path import ASSETS_PATH

-DATA_FILE_PATH = (
-    Path(__file__).parent.parent.parent.parent / "data" / "idiom_banned.json"
-)
+from konabot.common.llm import get_llm

+DATA_DIR = Path(__file__).parent.parent.parent.parent / "data"
+
+DATA_FILE_PATH = (
+    DATA_DIR / "idiom_banned.json"
+)

 def load_banned_ids() -> list[str]:
    if not DATA_FILE_PATH.exists():
        return []
    try:
-        return json.loads(DATA_FILE_PATH.read_text())
+        return json.loads(DATA_FILE_PATH.read_text("utf-8"))
    except Exception as e:
        logger.warning(f"在解析成语接龙封禁文件时遇到问题：{e}")
        return []
@ -45,14 +48,14 @@ def add_banned_id(group_id: str):
    banned_ids = load_banned_ids()
    if group_id not in banned_ids:
        banned_ids.append(group_id)
-        DATA_FILE_PATH.write_text(json.dumps(banned_ids, ensure_ascii=False, indent=4))
+        DATA_FILE_PATH.write_text(json.dumps(banned_ids, ensure_ascii=False, indent=4), "utf-8")


 def remove_banned_id(group_id: str):
    banned_ids = load_banned_ids()
    if group_id in banned_ids:
        banned_ids.remove(group_id)
-        DATA_FILE_PATH.write_text(json.dumps(banned_ids, ensure_ascii=False, indent=4))
+        DATA_FILE_PATH.write_text(json.dumps(banned_ids, ensure_ascii=False, indent=4), "utf-8")


 class TryStartState(Enum):
@ -69,11 +72,33 @@ class TryStopState(Enum):
 class TryVerifyState(Enum):
    VERIFIED = 0
    VERIFIED_AND_REAL = 1
-    NOT_IDIOM = 2
-    WRONG_FIRST_CHAR = 3
-    VERIFIED_BUT_NO_NEXT = 4
-    VERIFIED_GAME_END = 5
+    ALREADY_USED = 2
+    NOT_IDIOM = 3
+    WRONG_FIRST_CHAR = 4
+    BUT_NO_NEXT = 5
+    GAME_END = 6

+class IdiomGameLLM:
+    @classmethod
+    async def verify_idiom_with_llm(cls, idiom: str) -> bool:
+        if len(idiom) != 4:
+            return False
+        llm = get_llm()
+        system_prompt = "请判断用户的输入是否为一个合理的成语，或者这四个字在中文环境下是否说得通。如果是请回答「T」，否则回答「F」。请注意，即使这个词不是成语，如果说得通（也就是能念起来很通顺），你也该输出「T」。请不要包含任何解释，也不要包含任何标点符号。"
+        message = await llm.chat([{"role": "system", "content": system_prompt}, {"role": "user", "content": idiom}])
+        answer = message.content
+        logger.info(f"LLM 对成语 {idiom} 的判断结果是 {answer}")
+        if answer == "T":
+            await cls.storage_idiom(idiom)
+        return answer == "T"
+    
+    @classmethod
+    async def storage_idiom(cls, idiom: str):
+        # 将 idiom 存入本地文件以备后续分析
+        with open(DATA_DIR / "idiom_llm_storage.txt", "a", encoding="utf-8") as f:
+            f.write(idiom + "\n")
+        IdiomGame.append_into_word_list(idiom)
+        

 class IdiomGame:
    ALL_WORDS = []  # 所有四字词语
@ -96,12 +121,25 @@ class IdiomGame:
        self.all_buff_score = 0
        self.lock = asynkio.Lock()
        self.remain_rounds = 0  # 剩余回合数
+        self.already_idioms: dict[str, int] = {} # 已经使用过的成语和使用过的次数
+        self.idiom_history: list[list[str]] = [] # 成语使用历史记录，多个数组以存储不同成语链
        IdiomGame.INSTANCE_LIST[group_id] = self

+    @classmethod
+    def append_into_word_list(cls, word: str):
+        '''
+        将一个新词加入到词语列表中
+        '''
+        if word not in cls.ALL_WORDS:
+            cls.ALL_WORDS.append(word)
+            if word[0] not in cls.IDIOM_FIRST_CHAR:
+                cls.IDIOM_FIRST_CHAR[word[0]] = []
+            cls.IDIOM_FIRST_CHAR[word[0]].append(word)
+
    def be_able_to_play(self) -> bool:
        if self.last_play_date != datetime.date.today():
            self.last_play_date = datetime.date.today()
-            self.remain_playing_times = 1
+            self.remain_playing_times = 3
        if self.remain_playing_times > 0:
            self.remain_playing_times -= 1
            return True
@ -115,6 +153,8 @@ class IdiomGame:
        self.last_char = self.last_idiom[-1]
        if not self.is_nextable(self.last_char):
            self.choose_start_idiom()
+        else:
+            self.add_history_idiom(self.last_idiom, new_chain=True)
        return self.last_idiom

    @classmethod
@ -148,6 +188,9 @@ class IdiomGame:
    def clear_score_board(self):
        self.score_board = {}
        self.last_char = ""
+        self.all_buff_score = 0
+        self.already_idioms = {}
+        self.idiom_history = []

    def get_score_board(self) -> dict:
        return self.score_board
@ -169,6 +212,8 @@ class IdiomGame:
        self.last_char = self.last_idiom[-1]
        if not self.is_nextable(self.last_char):
            self._skip_idiom_async()
+        else:
+            self.add_history_idiom(self.last_idiom, new_chain=True)
        return self.last_idiom

    async def try_verify_idiom(self, idiom: str, user_id: str) -> TryVerifyState:
@ -176,7 +221,7 @@ class IdiomGame:
        用户发送成语
        """
        async with self.lock:
-            state = self._verify_idiom(idiom, user_id)
+            state = await self._verify_idiom(idiom, user_id)
        return state

    def is_nextable(self, last_char: str) -> bool:
@ -184,36 +229,77 @@ class IdiomGame:
        判断是否有成语可以接
        """
        return last_char in IdiomGame.AVALIABLE_IDIOM_FIRST_CHAR
+    
+    def add_already_idiom(self, idiom: str):
+        if idiom in self.already_idioms:
+            self.already_idioms[idiom] += 1
+        else:
+            self.already_idioms[idiom] = 1

-    def _verify_idiom(self, idiom: str, user_id: str) -> TryVerifyState:
+    def get_already_used_num(self, idiom: str) -> int:
+        if idiom in self.already_idioms:
+            return self.already_idioms[idiom]
+        return 0
+        
+    def add_history_idiom(self, idiom: str, new_chain: bool = False):
+        if new_chain or len(self.idiom_history) == 0:
+            self.idiom_history.append([idiom])
+        else:
+            self.idiom_history[-1].append(idiom)
+
+    def display_history(self) -> list[str]:
+        result = []
+        for chain in self.idiom_history:
+            result.append(" -> ".join(chain))
+        return result
+
+    async def _verify_idiom(self, idiom: str, user_id: str) -> list[TryVerifyState]:
+        state = []
        # 新成语的首字应与上一条成语的尾字相同
        if idiom[0] != self.last_char:
-            return TryVerifyState.WRONG_FIRST_CHAR
+            state.append(TryVerifyState.WRONG_FIRST_CHAR)
+            return state
        if idiom not in IdiomGame.ALL_IDIOMS and idiom not in IdiomGame.ALL_WORDS:
-            self.add_score(user_id, -0.1)
-            return TryVerifyState.NOT_IDIOM
+            logger.info(f"用户 {user_id} 发送了未知词语 {idiom}，正在使用 LLM 进行验证")
+            try:
+                if not await IdiomGameLLM.verify_idiom_with_llm(idiom):
+                    self.add_score(user_id, -0.1)
+                    state.append(TryVerifyState.NOT_IDIOM)
+                    return state
+            except Exception as e:
+                logger.error(f"LLM 验证成语 {idiom} 时出现错误：{e}")
+                self.add_score(user_id, -0.1)
+                state.append(TryVerifyState.NOT_IDIOM)
+                return state
+        # 成语合法，更新状态
+        self.add_history_idiom(idiom)
+        score_k = 0.5 ** self.get_already_used_num(idiom) # 每被使用过一次，得分减半
+        if(score_k != 1):
+            state.append(TryVerifyState.ALREADY_USED)
+        self.add_already_idiom(idiom)
+        state.append(TryVerifyState.VERIFIED)
        self.last_idiom = idiom
        self.last_char = idiom[-1]
-        self.add_score(user_id, 1)
+        self.add_score(user_id, 1 * score_k) # 先加 1 分
        if idiom in IdiomGame.ALL_IDIOMS:
-            self.add_score(user_id, 4) # 再加 4 分
+            state.append(TryVerifyState.VERIFIED_AND_REAL)
+            self.add_score(user_id, 4 * score_k) # 再加 4 分
        self.remain_rounds -= 1
        if self.remain_rounds <= 0:
            self.now_playing = False
-            return TryVerifyState.VERIFIED_GAME_END
+            state.append(TryVerifyState.GAME_END)
        if not self.is_nextable(self.last_char):
            # 没有成语可以接了，自动跳过
            self._skip_idiom_async()
-            return TryVerifyState.VERIFIED_BUT_NO_NEXT
-        if idiom in IdiomGame.ALL_IDIOMS:
-            return TryVerifyState.VERIFIED_AND_REAL # 真实成语
-        return TryVerifyState.VERIFIED
+            self.add_buff_score(-100)
+            state.append(TryVerifyState.BUT_NO_NEXT)
+        return state

    def get_user_score(self, user_id: str) -> float:
        if user_id not in self.score_board:
            return 0
        # 避免浮点数精度问题导致过长
-        handled_score = round(self.score_board[user_id]["score"], 1)
+        handled_score = round(self.score_board[user_id]["score"] + self.all_buff_score, 1)
        return handled_score

    def add_score(self, user_id: str, score: int):
@ -233,9 +319,9 @@ class IdiomGame:
    @classmethod
    def random_idiom_starting_with(cls, first_char: str) -> Optional[str]:
        cls.init_lexicon()
-        if first_char not in cls.IDIOM_FIRST_CHAR:
+        if first_char not in cls.AVALIABLE_IDIOM_FIRST_CHAR:
            return None
-        return secrets.choice(cls.IDIOM_FIRST_CHAR[first_char])
+        return secrets.choice(cls.AVALIABLE_IDIOM_FIRST_CHAR[first_char])

    @classmethod
    def init_lexicon(cls):
@ -249,7 +335,10 @@ class IdiomGame:

        # 词语大表
        with open(ASSETS_PATH / "lexicon" / "ci.json", "r", encoding="utf-8") as f:
-            cls.ALL_WORDS = json.load(f)
+            jsonData = json.load(f)
+            cls.ALL_WORDS = [item["ci"] for item in jsonData]
+            logger.debug(f"Loaded {len(cls.ALL_WORDS)} words from ci.json")
+            logger.debug(f"Sample words: {cls.ALL_WORDS[:5]}")

        COMMON_WORDS = []
        # 读取 COMMON 词语大表
@ -258,6 +347,8 @@ class IdiomGame:
                word = line.strip()
                if len(word) == 4:
                    COMMON_WORDS.append(word)
+        logger.debug(f"Loaded {len(COMMON_WORDS)} common words from common.txt")
+        logger.debug(f"Sample common words: {COMMON_WORDS[:5]}")

        # 读取 THUOCL 成语库
        with open(
@ -265,7 +356,9 @@ class IdiomGame:
            "r",
            encoding="utf-8",
        ) as f:
-            THUOCL_IDIOMS = [line.split(" ")[0].strip() for line in f]
+            THUOCL_IDIOMS = [line.split(" ")[0].split("\t")[0].strip() for line in f]
+            logger.debug(f"Loaded {len(THUOCL_IDIOMS)} idioms from THUOCL_chengyu.txt")
+            logger.debug(f"Sample idioms: {THUOCL_IDIOMS[:5]}")

        # 读取 THUOCL 剩下的所有 txt 文件，只保留四字词
        THUOCL_WORDS = []
@ -279,9 +372,21 @@ class IdiomGame:
                    encoding="utf-8",
                ) as f:
                    for line in f:
-                        word = line.lstrip().split(" ")[0].strip()
+                        word = line.lstrip().split(" ")[0].split("\t")[0].strip()
                        if len(word) == 4:
                            THUOCL_WORDS.append(word)
+        logger.debug(f"Loaded {len(THUOCL_WORDS)} words from THUOCL txt files")
+        logger.debug(f"Sample words: {THUOCL_WORDS[:5]}")
+
+        # 读取本地的 idiom_llm_storage.txt 文件，补充词语表
+        LOCAL_LLM_WORDS = []
+        if (DATA_DIR / "idiom_llm_storage.txt").exists():
+            with open(DATA_DIR / "idiom_llm_storage.txt", "r", encoding="utf-8") as f:
+                for line in f:
+                    word = line.strip()
+                    if len(word) == 4:
+                        LOCAL_LLM_WORDS.append(word)
+        logger.debug(f"Loaded additional {len(LOCAL_LLM_WORDS)} words from idiom_llm_storage.txt")

        # 只有成语的大表
        cls.ALL_IDIOMS = [idiom["word"] for idiom in ALL_IDIOMS_INFOS] + THUOCL_IDIOMS
@ -292,6 +397,7 @@ class IdiomGame:
            [word for word in cls.ALL_WORDS if len(word) == 4]
            + THUOCL_WORDS
            + COMMON_WORDS
+            + LOCAL_LLM_WORDS
        )
        cls.ALL_WORDS = list(set(cls.ALL_WORDS))  # 去重

@ -388,7 +494,7 @@ async def end_game(event: BaseEvent, group_id: str):
    result_text = UniMessage().text("游戏结束！\n最终得分榜：\n")
    score_board = instance.get_score_board()
    if len(score_board) == 0:
-        result_text += "无人得分！"
+        result_text += "无人得分！\n"
    else:
        # 按分数排序，名字用 at 的方式
        sorted_score = sorted(
@ -400,6 +506,13 @@ async def end_game(event: BaseEvent, group_id: str):
                + UniMessage().at(user_id)
                + f": {round(info['score'] + instance.get_all_buff_score(), 1)} 分\n"
            )
+    if len(instance.idiom_history) == 0:
+        result_text += "\n本局没有任何接龙记录。"
+    else:
+        result_text += "\n你们的接龙记录是：\n"
+        history_lines = instance.display_history()
+        for line in history_lines:
+            result_text += line + "\n"
    await evt.send(await result_text.export())
    instance.clear_score_board()

@ -441,6 +554,10 @@ async def _(target: DepLongTaskTarget):
    if not instance or not instance.get_playing_state():
        return
    avaliable_idiom = IdiomGame.random_idiom_starting_with(instance.get_last_char())
+    # 发送哈哈狗图片
+    with open(ASSETS_PATH / "img" / "dog" / "haha_dog.jpg", "rb") as f:
+        img_data = f.read()
+    await evt.send(await UniMessage().image(raw=img_data).export())
    await evt.send(await UniMessage().text(f"你们太菜了，全部扣100分！明明还可以接「{avaliable_idiom}」的！").export())
    idiom = await instance.skip_idiom(-100)
    await evt.send(
@ -472,9 +589,9 @@ async def _(event: BaseEvent, msg: UniMsg, target: DepLongTaskTarget):
    user_idiom = msg.extract_plain_text().strip()
    user_id, user_name = get_user_info(event)
    state = await instance.try_verify_idiom(user_idiom, user_id)
-    if state == TryVerifyState.WRONG_FIRST_CHAR:
+    if TryVerifyState.WRONG_FIRST_CHAR in state:
        return
-    if state == TryVerifyState.NOT_IDIOM:
+    if TryVerifyState.NOT_IDIOM in state:
        await evt.send(
            await UniMessage()
            .at(user_id)
@ -482,25 +599,44 @@ async def _(event: BaseEvent, msg: UniMsg, target: DepLongTaskTarget):
            .export()
        )
        return
-    if state == TryVerifyState.VERIFIED:
-        await evt.send(
-            await UniMessage()
-            .at(user_id)
-            .text(f" 接上了，喜提 1 分！你有 {instance.get_user_score(user_id)} 分！")
-            .export()
-        )
-    elif state == TryVerifyState.VERIFIED_AND_REAL:
-        await evt.send(
-            await UniMessage()
-            .at(user_id)
-            .text(f" 接上了，这是个真实成语，喜提 5 分！你有 {instance.get_user_score(user_id)} 分！")
-            .export()
-        )
-    if state == TryVerifyState.VERIFIED_GAME_END:
+    already_used_num = instance.get_already_used_num(user_idiom)
+    if TryVerifyState.VERIFIED_AND_REAL in state:
+        score = 5 * (0.5 ** (already_used_num - 1))
+        if already_used_num > 1:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，这是个被重复用过的成语，喜提 {score} 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
+        else:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，这是个真实成语，喜提 5 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
+    elif TryVerifyState.VERIFIED in state:
+        score = 1 * (0.5 ** (already_used_num - 1))
+        if already_used_num > 1:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，但重复了，喜提 {score} 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
+        else:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，喜提 1 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
+    if TryVerifyState.GAME_END in state:
        await evt.send(await UniMessage().text("全部回合结束！").export())
        await end_game(event, group_id)
        return
-    if state == TryVerifyState.VERIFIED_BUT_NO_NEXT:
+    if TryVerifyState.BUT_NO_NEXT in state:
        await evt.send(
            await UniMessage()
            .text("但是，这是条死路！你们全部都要扣 100 分！")
--- a/konabot/plugins/kona_ph/init.py
+++ b/konabot/plugins/kona_ph/init.py
@ -0,0 +1,135 @@
+import datetime
+import re
+from math import ceil
+
+from loguru import logger
+from nonebot import on_message
+from nonebot_plugin_alconna import (Alconna, Args, UniMessage, UniMsg,
+                                    on_alconna)
+from nonebot_plugin_apscheduler import scheduler
+
+from konabot.common.longtask import DepLongTaskTarget
+from konabot.common.nb.qq_broadcast import qq_broadcast
+from konabot.plugins.kona_ph.core.message import (get_daily_report,
+                                                  get_daily_report_v2,
+                                                  get_puzzle_description,
+                                                  get_submission_message)
+from konabot.plugins.kona_ph.core.storage import get_today_date
+from konabot.plugins.kona_ph.manager import (PUZZLE_PAGE_SIZE, config,
+                                             create_admin_commands,
+                                             puzzle_manager)
+
+create_admin_commands()
+
+
+async def is_play_group(target: DepLongTaskTarget):
+    if target.is_private_chat:
+        return True
+    if target.channel_id in config.plugin_puzzle_playgroup:
+        return True
+    return False
+
+
+cmd_submit = on_message(rule=is_play_group)
+
+
+@cmd_submit.handle()
+async def _(msg: UniMsg, target: DepLongTaskTarget):
+    txt = msg.extract_plain_text().strip()
+    if match := re.match(r"^提交(?:答案|题解|[fF]lag)\s*(?P<submission>.+?)\s*$", txt):
+        submission: str = match.group("submission")
+        async with puzzle_manager() as manager:
+            result = manager.submit(target.target_id, submission)
+            if isinstance(result, str):
+                await target.send_message(result)
+            else:
+                await target.send_message(get_submission_message(
+                    daily_puzzle_info=result.info,
+                    submission=result.submission,
+                    puzzle=result.puzzle,
+                ))
+
+
+cmd_query = on_alconna(Alconna(
+    r"re:(?:((?:(?:所以|话)说?)?今天的题目是什么[啊呀哇呢]?(?:\?？)?)|今日谜?题目?)"
+), rule=is_play_group)
+
+@cmd_query.handle()
+async def _(target: DepLongTaskTarget):
+    async with puzzle_manager() as manager:
+        p = manager.get_today_puzzle()
+        if p is None:
+            return await target.send_message("今天无题，改日再来吧！")
+        await target.send_message(get_puzzle_description(p))
+
+
+cmd_query_submission = on_alconna(Alconna(
+    "今日答题情况"
+), rule=is_play_group)
+
+@cmd_query_submission.handle()
+async def _(target: DepLongTaskTarget):
+    gid = None
+    if re.match(r"^\d+$", target.channel_id):
+        gid = int(target.channel_id)
+    async with puzzle_manager() as manager:
+        await target.send_message(get_daily_report_v2(manager, gid))
+
+
+cmd_history = on_alconna(Alconna(
+    "历史题目",
+    Args["page?", int],
+    Args["index_id?", str],
+), rule=is_play_group)
+
+@cmd_history.handle()
+async def _(target: DepLongTaskTarget, index_id: str = "", page: int = 1):
+    async with puzzle_manager() as manager:
+        today = get_today_date()
+        if index_id:
+            index_id = index_id.removeprefix("#")
+            if index_id not in manager.daily_puzzle:
+                return await target.send_message("没有这道题哦")
+            puzzle = manager.puzzle_data[manager.daily_puzzle[index_id].raw_id]
+            msg = get_puzzle_description(
+                puzzle,
+                with_answer=(index_id != manager.daily_puzzle_of_date.get(today, "")),
+            )
+            return await target.send_message(msg)
+        msg = UniMessage.text("====== 历史题目清单 ======\n\n")
+        puzzles = [
+            (manager.puzzle_data[manager.daily_puzzle[i].raw_id], d)
+            for d, i in manager.daily_puzzle_of_date.items()
+        ]
+        puzzles = sorted(puzzles, key=lambda u: u[1], reverse=True)
+        count_pages = ceil(len(puzzles) / PUZZLE_PAGE_SIZE)
+        if page <= 0 or page > count_pages:
+            return await target.send_message(UniMessage.text(
+                f"页数只有 1 ~ {count_pages} 啦！"
+            ))
+        puzzles = puzzles[(page - 1) * PUZZLE_PAGE_SIZE: page * PUZZLE_PAGE_SIZE]
+        for p, d in puzzles:
+            info = manager.daily_puzzle[manager.daily_puzzle_of_date[d]]
+            msg = msg.text(
+                f"- [#{p.index_id}: {len(info.success_users)}/{len(info.tried_users)}]"
+                f" {p.title} ({d})"
+            )
+            msg = msg.text("\n")
+        msg = msg.text(f"\n==== 第 {page} 页，共 {count_pages} 页 ====")
+        await target.send_message(msg)
+
+
+@scheduler.scheduled_job("cron", hour="8")
+async def _():
+    async with puzzle_manager() as manager:
+        yesterday = get_today_date() - datetime.timedelta(days=1)
+        msg2 = get_daily_report(manager, yesterday)
+        if msg2 is not None:
+            await qq_broadcast(config.plugin_puzzle_playgroup, msg2)
+
+        puzzle = manager.get_today_puzzle()
+        if puzzle is not None:
+            logger.info(f"找到了题目 {puzzle.raw_id}，发送")
+            await qq_broadcast(config.plugin_puzzle_playgroup, get_puzzle_description(puzzle))
+        else:
+            logger.info("自动任务：没有找到题目，跳过")
--- a/konabot/plugins/kona_ph/core/init.py
+++ b/konabot/plugins/kona_ph/core/init.py
--- a/konabot/plugins/kona_ph/core/image.py
+++ b/konabot/plugins/kona_ph/core/image.py
@ -0,0 +1,29 @@
+import nanoid
+
+from konabot.common.path import ASSETS_PATH
+from konabot.plugins.kona_ph.core.path import KONAPH_IMAGE_BASE
+
+
+class PuzzleImageManager:
+    def read_puzzle_image(self, img_name: str) -> bytes:
+        fp = KONAPH_IMAGE_BASE / img_name
+        if fp.exists():
+            return fp.read_bytes()
+        return (ASSETS_PATH / "img" / "other" / "boom.jpg").read_bytes()
+
+    def upload_puzzle_image(self, data: bytes, suffix: str = ".png") -> str:
+        id = nanoid.generate(
+            "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz",
+            21,
+        )
+        img_name = f"{id}{suffix}"
+        (KONAPH_IMAGE_BASE / img_name).write_bytes(data)
+        return img_name
+
+    def remove_puzzle_image(self, img_name: str):
+        if img_name:
+            (KONAPH_IMAGE_BASE / img_name).unlink(True)
+
+
+def get_image_manager() -> PuzzleImageManager:
+    return PuzzleImageManager()
--- a/konabot/plugins/kona_ph/core/message.py
+++ b/konabot/plugins/kona_ph/core/message.py
@ -0,0 +1,187 @@
+"""
+生成各种各样的 Message 的函数集合
+"""
+
+
+import datetime
+import functools
+import re
+from typing import Any
+
+from nonebot_plugin_alconna import UniMessage
+
+from konabot.common.username import get_username
+from konabot.plugins.kona_ph.core.image import get_image_manager
+from konabot.plugins.kona_ph.core.storage import (DailyPuzzleInfo, Puzzle,
+                                                  PuzzleManager,
+                                                  PuzzleSubmission)
+
+
+def get_puzzle_description(puzzle: Puzzle, with_answer: bool = False) -> UniMessage[Any]:
+    """
+    获取一个谜题的描述
+    """
+
+    img_manager = get_image_manager()
+
+    result = UniMessage.text(f"[KonaPH#{puzzle.index_id}] {puzzle.title}")
+    result = result.text(f"\n\n{puzzle.content}")
+
+    if puzzle.img_name:
+        result = result.text("\n\n").image(
+            raw=img_manager.read_puzzle_image(puzzle.img_name)
+        )
+
+    result = result.text(f"\n\n出题者：{get_username(puzzle.author_id)}")
+    
+    if with_answer:
+        result = result.text(f"\n\n题目答案：{puzzle.flag}")
+    else:
+        result = result.text("\n\n输入「提交答案 答案」来提交你的解答")
+
+    return result
+
+
+def get_submission_message(
+    puzzle: Puzzle,
+    submission: PuzzleSubmission,
+    daily_puzzle_info: DailyPuzzleInfo | None = None,
+) -> str:
+    """
+    获得提交答案的反馈信息
+    """
+
+    if submission.success:
+        rank = -1
+        if daily_puzzle_info is not None:
+            rank = len(daily_puzzle_info.success_users)
+        return f"🎉 恭喜你答对了！你是今天第 {rank} 个解出来的！"
+    if submission.hint_id >= 0 and (
+        hint := puzzle.hints.get(submission.hint_id)
+    ) is not None:
+        if hint.is_checkpoint:
+            hint_msg = "✨ 恭喜！这是本题的中间答案，加油！"
+        else:
+            hint_msg = "🤔 答错啦！请检查你的答案。"
+        return f"{hint_msg}\n\n提示：{hint.message}"
+    return "❌ 答错啦！请检查你的答案。"
+
+
+def get_daily_report(
+    manager: PuzzleManager,
+    date: datetime.date,
+) -> str | None:
+    """
+    获得某日的提交的报告信息
+    """
+
+    index_id = manager.daily_puzzle_of_date.get(date)
+    if index_id is None:
+        return None
+    info = manager.daily_puzzle[index_id]
+    puzzle = manager.puzzle_data[info.raw_id]
+
+    msg = f"[KonaPH#{puzzle.index_id}] 「{puzzle.title}」解答报告\n\n"
+    if len(info.success_users) == 0:
+        msg += "昨日，无人解出此题 😭😭\n\n"
+    else:
+        msg += f"昨日，共有 {len(info.success_users)} 人解出此题。\n\n"
+        msg += "前五名的解答者：\n\n"
+        us = [(u, d) for u, d in info.success_users.items()]
+        us = sorted(us, key=lambda t: t[1])
+        us = us[:5]
+        for u, _ in us:
+            m = manager.submissions[puzzle.raw_id][u][-1]
+            msg += f"- {get_username(u)} 于 {m.time.strftime('%H:%M')}\n"
+        msg += "\n"
+    msg += f"出题人：{get_username(puzzle.author_id)}"
+    return msg
+
+
+def get_daily_report_v2(manager: PuzzleManager, gid: int | None = None):
+    p = manager.get_today_puzzle()
+    if p is None:
+        return "今天无题"
+    msg = "==== 今日答题情况 ====\n\n"
+
+    subcount = len(functools.reduce(
+        lambda x, y: x + y,
+        manager.submissions.get(p.raw_id, {}).values(),
+        [],
+    ))
+    info = manager.daily_puzzle[p.index_id]
+
+    msg += (
+        f"总体情况：答对 {len(info.success_users)} / "
+        f"参与 {len(info.tried_users)} / "
+        f"提交 {subcount}\n"
+    )
+
+    success_users = sorted(list(info.success_users.items()), key=lambda v: v[1])
+    for u, d in success_users:
+        uname = u
+        if re.match(r"^\d+$", u):
+            uname = get_username(int(u), gid)
+        t = d.strftime("%H:%M")
+        tries = len(manager.submissions[p.raw_id][u])
+        msg += f"\n- {uname} [🎉 {t} 完成 | {tries} 提交]"
+    for u in info.tried_users - set(info.success_users.keys()):
+        uname = u
+        if re.match(r"^\d+$", u):
+            uname = get_username(int(u), gid)
+        tries = len(manager.submissions[p.raw_id][u])
+        checkpoints_touched = len(set((
+            s.hint_id for s in manager.submissions[p.raw_id][u]
+            if (
+                s.hint_id >= 0
+                and s.hint_id in p.hints
+                and p.hints[s.hint_id].is_checkpoint
+            )
+        )))
+        checkpoint_message = ""
+        if checkpoints_touched > 0:
+            checkpoint_message = f" | 🚩 {checkpoints_touched} 记录点"
+        msg += f"\n- {uname} [💦 {tries} 提交{checkpoint_message}]"
+
+    return msg
+
+
+def get_puzzle_info_message(manager: PuzzleManager, puzzle: Puzzle) -> UniMessage[Any]:
+    image_manager = get_image_manager()
+
+    status = "✅ 已准备，待发布" if puzzle.ready and not manager.is_puzzle_published(puzzle.raw_id) else \
+    (f"🟢 已发布: #{puzzle.index_id}" if manager.is_puzzle_published(puzzle.raw_id) else "⚙️ 未准备")
+
+    status_suffix = ""
+    if puzzle.raw_id == manager.puzzle_pinned:
+        status_suffix += " | 📌 已被管理员置顶"
+
+    msg = UniMessage.text(
+        f"--- 谜题信息 ---\n"
+        f"Raw ID: {puzzle.raw_id}\n"
+        f"出题者: {get_username(puzzle.author_id)} | {puzzle.author_id}\n"
+        f"创建时间: {puzzle.created_at.strftime('%Y-%m-%d %H:%M:%S')}\n"
+        f"状态: {status}{status_suffix}\n\n"
+        f"标题: {puzzle.title}\n"
+        f"Flag: {puzzle.flag}\n\n"
+        f"{puzzle.content}"
+    )
+
+    if puzzle.img_name:
+        msg = msg.image(raw=image_manager.read_puzzle_image(puzzle.img_name))
+
+    msg = msg.text(f"\n---------\n使用 `konaph ready {puzzle.raw_id}` 完成编辑")
+
+    return msg
+
+
+def get_puzzle_hint_list(puzzle: Puzzle) -> str:
+    msg = f"==== {puzzle.title} 提示与中间答案 ====\n"
+    if len(puzzle.hints) == 0:
+        msg += "\n你没有添加任何中间答案。"
+        return msg
+    for hint_id, hint in puzzle.hints.items():
+        n = {False: "[提示]", True: "[中间答案]"}[hint.is_checkpoint]
+        msg += f"\n{n}[{hint_id}] {hint.pattern}"
+        msg += f"\n  {hint.message}"
+    return msg
--- a/konabot/plugins/kona_ph/core/path.py
+++ b/konabot/plugins/kona_ph/core/path.py
@ -0,0 +1,9 @@
+from konabot.common.path import DATA_PATH
+
+KONAPH_BASE = DATA_PATH / "KonaPH"
+KONAPH_DATA_JSON = KONAPH_BASE / "data.json"
+KONAPH_IMAGE_BASE = KONAPH_BASE / "imgs"
+
+# 保证所有文件夹存在
+KONAPH_BASE.mkdir(exist_ok=True)
+KONAPH_IMAGE_BASE.mkdir(exist_ok=True)
--- a/konabot/plugins/kona_ph/core/storage.py
+++ b/konabot/plugins/kona_ph/core/storage.py
@ -0,0 +1,259 @@
+import asyncio
+import datetime
+import random
+import re
+from contextlib import asynccontextmanager
+
+import nanoid
+from pydantic import BaseModel, Field, ValidationError
+
+from konabot.plugins.kona_ph.core.path import KONAPH_DATA_JSON
+
+
+class PuzzleHint(BaseModel):
+    pattern: str
+    message: str
+    is_checkpoint: bool
+
+
+class PuzzleSubmission(BaseModel):
+    success: bool
+    flag: str
+    time: datetime.datetime
+    hint_id: int = -1
+
+
+class Puzzle(BaseModel):
+    raw_id: str
+    "用于给出题者管理的 ID"
+
+    index_id: str
+    "展出的 ID，以展出顺序为准"
+
+    title: str
+    content: str
+    img_name: str
+    author_id: str
+    flag: str
+
+    ready: bool = False
+    created_at: datetime.datetime = Field(default_factory=datetime.datetime.now)
+
+    hints: dict[int, PuzzleHint] = Field(default_factory=dict)
+
+    @property
+    def hint_id_max(self) -> int:
+        return max((0, *self.hints.keys()))
+
+    def check_submission(
+        self,
+        submission: str,
+        time: datetime.datetime | None = None,
+    ) -> PuzzleSubmission:
+        if time is None:
+            time = datetime.datetime.now()
+        if submission == self.flag:
+            return PuzzleSubmission(
+                success=True,
+                flag=submission,
+                time=time,
+            )
+        for hint_id, hint in self.hints.items():
+            if hint.pattern.startswith('/') and hint.pattern.endswith('/'):
+                if re.match(hint.pattern.strip('/'), submission):
+                    return PuzzleSubmission(
+                        success=False,
+                        flag=submission,
+                        time=time,
+                        hint_id=hint_id,
+                    )
+            else:
+                if hint.pattern == submission:
+                    return PuzzleSubmission(
+                        success=False,
+                        flag=submission,
+                        time=time,
+                        hint_id=hint_id,
+                    )
+        return PuzzleSubmission(
+            success=False,
+            flag=submission,
+            time=time,
+        )
+
+
+class DailyPuzzleInfo(BaseModel):
+    raw_id: str
+    time: datetime.date
+    tried_users: set[str] = set()
+    success_users: dict[str, datetime.datetime] = {}
+
+
+class PuzzleSubmissionFeedback(BaseModel):
+    submission: PuzzleSubmission
+    puzzle: Puzzle
+    info: DailyPuzzleInfo | None = None
+
+
+def get_today_date() -> datetime.date:
+    now = datetime.datetime.now()
+    if now.hour < 8:
+        now -= datetime.timedelta(days=1)
+    return now.date()
+
+
+class PuzzleManager(BaseModel):
+    puzzle_data: dict[str, Puzzle] = {}
+
+    daily_puzzle: dict[str, DailyPuzzleInfo] = {}
+    daily_puzzle_of_date: dict[datetime.date, str] = {}
+
+    puzzle_pinned: str = ""
+
+    index_id_counter: int = 1
+    submissions: dict[str, dict[str, list[PuzzleSubmission]]] = {}
+    last_checked_date: datetime.date = Field(
+        default_factory=lambda: get_today_date() - datetime.timedelta(days=1)
+    )
+
+    @property
+    def last_publish_date(self):
+        return max(self.daily_puzzle_of_date.keys())
+
+    @property
+    def unpublished_puzzles(self):
+        return set((
+            p.raw_id for p in self.puzzle_data.values()
+            if not self.is_puzzle_published(p.raw_id) and p.ready
+        ))
+
+    @property
+    def unready_puzzles(self):
+        return set((
+            p.raw_id for p in self.puzzle_data.values()
+            if not self.is_puzzle_published(p.raw_id) and not p.ready
+        ))
+
+    @property
+    def published_puzzles(self):
+        return set((
+            p.raw_id for p in self.puzzle_data.values()
+            if self.is_puzzle_published(p.raw_id)
+        ))
+
+    def is_puzzle_published(self, raw_id: str):
+        return raw_id in [i.raw_id for i in self.daily_puzzle.values()]
+
+    def publish_puzzle(self, raw_id: str):
+        assert raw_id in self.puzzle_data
+
+        today = get_today_date()
+
+        p = self.puzzle_data[raw_id]
+        p.index_id = str(self.index_id_counter)
+        p.ready = True
+        self.puzzle_pinned = ""
+        self.last_checked_date = today
+        self.daily_puzzle[p.index_id] = DailyPuzzleInfo(
+            raw_id=raw_id,
+            time=today,
+        )
+        self.daily_puzzle_of_date[today] = p.index_id
+
+        self.index_id_counter += 1
+
+    def admin_pin_puzzle(self, raw_id: str):
+        if raw_id in self.puzzle_data:
+            self.puzzle_pinned = raw_id
+        else:
+            self.puzzle_pinned = ""
+
+    def get_today_puzzle(self, strong: bool = False) -> Puzzle | None:
+        today = get_today_date()
+        if today in self.daily_puzzle_of_date:
+            index_id = self.daily_puzzle_of_date[today]
+            info = self.daily_puzzle[index_id]
+            return self.puzzle_data[info.raw_id]
+        if today == self.last_checked_date and not strong:
+            return
+        self.last_checked_date = today
+        if self.puzzle_pinned and self.puzzle_pinned in self.puzzle_data:
+            d = self.puzzle_pinned
+            self.publish_puzzle(d)
+            self.puzzle_pinned = ""
+            return self.puzzle_data[d]
+        elif len(self.unpublished_puzzles) > 0:
+            d = random.choice(list(self.unpublished_puzzles))
+            self.publish_puzzle(d)
+            return self.puzzle_data[d]
+
+    def get_today_info(self) -> DailyPuzzleInfo | None:
+        p = self.get_today_puzzle()
+        if p is None:
+            return
+        return self.daily_puzzle[p.index_id]
+
+    def submit(self, user: str, flag: str) -> PuzzleSubmissionFeedback | str:
+        p = self.get_today_puzzle()
+        d = self.get_today_info()
+        now = datetime.datetime.now()
+        if p is None or d is None:
+            return "今天没有题哦，改天再来吧！"
+        if user in d.success_users:
+            return "你今天已经答对过啦！不用重复提交哦！"
+        d.tried_users.add(user)
+        result = p.check_submission(flag, now)
+        self.submissions.setdefault(p.raw_id, {}).setdefault(user, []).append(result)
+        if result.success:
+            d.success_users[user] = now
+        return PuzzleSubmissionFeedback(
+            submission=result,
+            puzzle=p,
+            info=d,
+        )
+
+    def admin_create_puzzle(self, user: str):
+        p = Puzzle(
+            raw_id=nanoid.generate(
+                "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz",
+                12,
+            ),
+            index_id="",
+            title="示例标题",
+            content="题目的内容填写内容",
+            img_name="",
+            author_id=user,
+            flag="konaph{this_is_a_flag}",
+            ready=False,
+        )
+        self.puzzle_data[p.raw_id] = p
+        return p
+
+    def get_puzzles_of_user(self, user: str):
+        return sorted([
+            p for p in self.puzzle_data.values()
+            if p.author_id == user
+        ], key=lambda p: p.created_at, reverse=True)
+
+
+lock = asyncio.Lock()
+
+
+def read_data():
+    try:
+        data_raw = KONAPH_DATA_JSON.read_text("utf-8")
+        return PuzzleManager.model_validate_json(data_raw)
+    except (FileNotFoundError, ValidationError):
+        return PuzzleManager()
+
+
+def write_data(data: PuzzleManager):
+    KONAPH_DATA_JSON.write_text(data.model_dump_json(), "utf-8")
+
+
+@asynccontextmanager
+async def puzzle_manager():
+    async with lock:
+        data = read_data()
+        yield data
+        write_data(data)
--- a/konabot/plugins/kona_ph/manager.py
+++ b/konabot/plugins/kona_ph/manager.py
@ -0,0 +1,464 @@
+import datetime
+from math import ceil
+
+from nonebot import get_plugin_config
+from nonebot_plugin_alconna import (Alconna, Args, Image, Option, Query,
+                                    Subcommand, SubcommandResult, UniMessage,
+                                    on_alconna)
+from pydantic import BaseModel
+
+from konabot.common.longtask import DepLongTaskTarget
+from konabot.common.nb.exc import BotExceptionMessage
+from konabot.common.nb.extract_image import download_image_bytes
+from konabot.common.nb.qq_broadcast import qq_broadcast
+from konabot.common.username import get_username
+from konabot.plugins.kona_ph.core.image import get_image_manager
+from konabot.plugins.kona_ph.core.message import (get_puzzle_description, get_puzzle_hint_list,
+                                                  get_puzzle_info_message,
+                                                  get_submission_message)
+from konabot.plugins.kona_ph.core.storage import (Puzzle, PuzzleHint, PuzzleManager,
+                                                  get_today_date,
+                                                  puzzle_manager)
+
+PUZZLE_PAGE_SIZE = 10
+
+
+class PuzzleConfig(BaseModel):
+    plugin_puzzle_manager: list[str] = []
+    plugin_puzzle_admin: list[str] = []
+    plugin_puzzle_playgroup: list[str] = []
+
+
+config = get_plugin_config(PuzzleConfig)
+
+
+def is_puzzle_manager(target: DepLongTaskTarget):
+    return target.target_id in config.plugin_puzzle_manager or is_puzzle_admin(target)
+
+
+def is_puzzle_admin(target: DepLongTaskTarget):
+    return target.target_id in config.plugin_puzzle_admin
+
+
+def check_puzzle(manager: PuzzleManager, target: DepLongTaskTarget, raw_id: str) -> Puzzle:
+    if raw_id not in manager.puzzle_data:
+        raise BotExceptionMessage("没有这个谜题")
+    puzzle = manager.puzzle_data[raw_id]
+    if is_puzzle_admin(target):
+        return puzzle
+    if target.target_id != puzzle.author_id:
+        raise BotExceptionMessage("你没有权限查看或编辑这个谜题")
+    return puzzle
+
+
+def create_admin_commands():
+    cmd_admin = on_alconna(
+        Alconna(
+            "konaph",
+            Subcommand("create", dest="create"),
+            Subcommand("ready", Args["raw_id", str], dest="ready"),
+            Subcommand("unready", Args["raw_id", str], dest="unready"),
+            Subcommand("info", Args["raw_id", str], dest="info"),
+            Subcommand("my", Args["page?", int], dest="my"),
+            Subcommand("all", Option("--ready", alias=["-r"]), Args["page?", int], dest="all"),
+            Subcommand("pin", Args["raw_id?", str], dest="pin"),
+            Subcommand("unpin", dest="unpin"),
+            Subcommand(
+                "modify",
+                Args["raw_id?", str],
+                Option("--title", Args["title", str], alias=["-t"]),
+                Option("--description", Args["description", str], alias=["-d"]),
+                Option("--image", Args["image?", Image], alias=["-i"]),
+                Option("--flag", Args["flag", str], alias=["-f"]),
+                Option("--remove-image"),
+                dest="modify",
+            ),
+            Subcommand("publish", Args["raw_id?", str], dest="publish"),
+            Subcommand("preview", Args["raw_id", str], dest="preview"),
+            Subcommand("get-submits", Args["raw_id", str], dest="get-submits"),
+            Subcommand(
+                "test",
+                Args["raw_id", str],
+                Args["submission", str],
+                dest="test",
+            ),
+            Subcommand(
+                "hint",
+                Subcommand(
+                    "add",
+                    Args["raw_id", str],
+                    Args["pattern", str],
+                    Args["message", str],
+                    dest="add",
+                ),
+                Subcommand(
+                    "list",
+                    Args["raw_id", str],
+                    Args["page?", int],
+                    dest="list",
+                ),
+                Subcommand(
+                    "modify",
+                    Args["raw_id", str],
+                    Args["hint_id", int],
+                    Option("--pattern", Args["pattern", str], alias=["-p"]),
+                    Option("--message", Args["message", str], alias=["-m"]),
+                    Option("--checkpoint", Args["is_checkpoint", bool], alias=["-c"]),
+                    dest="modify",
+                ),
+                Subcommand(
+                    "delete",
+                    Args["raw_id", str],
+                    Args["hint_id", int],
+                    dest="delete",
+                ),
+                dest="hint",
+            ),
+        ),
+        rule=is_puzzle_manager,
+    )
+
+    @cmd_admin.assign("$main")
+    async def _(target: DepLongTaskTarget):
+        msg = UniMessage.text("==== [KonaPH] 指令一览 ====\n\n")
+        msg = msg.text("konaph create - 创建一个新的谜题\n")
+        msg = msg.text("konaph ready <id> - 准备好一道谜题\n")
+        msg = msg.text("konaph unready <id> - 取消准备一道谜题\n")
+        msg = msg.text("konaph info <id> - 查看谜题\n")
+        msg = msg.text("konaph my <page?> - 查看我的谜题列表\n")
+        msg = msg.text("konaph modify - 查看如何修改谜题信息\n")
+        msg = msg.text("konaph preview <id> - 预览一个题目的效果，不会展示答案\n")
+        msg = msg.text("konaph get-submits <id> - 获得题目的提交记录\n")
+        msg = msg.text("konaph test <id> <answer> - 尝试提交一个答案，看回答的效果\n")
+        msg = msg.text("konaph hint - 查看如何编辑题目的中间答案\n")
+
+        if is_puzzle_admin(target):
+            msg = msg.text("konaph all [--ready] <page?> - 查看所有谜题\n")
+            msg = msg.text("konaph pin - 查看当前置顶谜题\n")
+            msg = msg.text("konaph pin <id> - 置顶一个谜题\n")
+            msg = msg.text("konaph unpin - 取消置顶所有谜题\n")
+            msg = msg.text("konaph publish <id?> - 强制发题")
+
+        await target.send_message(msg)
+
+    @cmd_admin.assign("create")
+    async def _(target: DepLongTaskTarget):
+        async with puzzle_manager() as manager:
+            puzzle = manager.admin_create_puzzle(target.target_id)
+        await target.send_message(UniMessage.text(
+            f"✨ 创建好啦！谜题 ID 为 {puzzle.raw_id}\n\n"
+            f"- 输入 `konaph info {puzzle.raw_id}` 获得谜题的信息\n"
+            f"- 输入 `konaph my` 查看你创建的谜题\n"
+            f"- 输入 `konaph modify` 查看更改谜题的方法"
+        ))
+
+    @cmd_admin.assign("ready")
+    async def _(raw_id: str, target: DepLongTaskTarget):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            if p.ready:
+                return await target.send_message(UniMessage.text(
+                    "题目早就准备好啦！"
+                ))
+            p.ready = True
+            await target.send_message(UniMessage.text(
+                f"谜题「{p.title}」已经准备就绪！"
+            ))
+
+    @cmd_admin.assign("unready")
+    async def _(raw_id: str, target: DepLongTaskTarget):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            if not p.ready:
+                return await target.send_message(UniMessage.text(
+                    f"谜题「{p.title}」已经是未取消状态了！"
+                ))
+            if manager.is_puzzle_published(p.raw_id):
+                return await target.send_message(UniMessage.text(
+                    "已发布的谜题不能取消准备状态！"
+                ))
+
+            p.ready = False
+            await target.send_message(UniMessage.text(
+                f"谜题「{p.title}」已经取消准备！"
+            ))
+
+    @cmd_admin.assign("info")
+    async def _(raw_id: str, target: DepLongTaskTarget):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            await target.send_message(get_puzzle_info_message(manager, p))
+
+    @cmd_admin.assign("my")
+    async def _(target: DepLongTaskTarget, page: int = 1):
+        async with puzzle_manager() as manager:
+            puzzles = manager.get_puzzles_of_user(target.target_id)
+            if len(puzzles) == 0:
+                return await target.send_message(UniMessage.text(
+                    "你没有谜题哦，使用 `konaph create` 创建一个吧！"
+                ))
+            count_pages = ceil(len(puzzles) / PUZZLE_PAGE_SIZE)
+            if page <= 0 or page > count_pages:
+                return await target.send_message(UniMessage.text(
+                    f"页数只有 1 ~ {count_pages} 啦！"
+                ))
+            puzzles = puzzles[(page - 1) * PUZZLE_PAGE_SIZE: page * PUZZLE_PAGE_SIZE]
+            message = UniMessage.text("==== 我的谜题 ====\n\n")
+            for p in puzzles:
+                message = message.text("- ")
+                if manager.puzzle_pinned == p.raw_id:
+                    message = message.text("[📌]")
+                if manager.is_puzzle_published(p.raw_id):
+                    message = message.text(f"[✨][#{p.index_id}] ")
+                elif p.ready:
+                    message = message.text("[✅] ")
+                else:
+                    message = message.text("[⚙️] ")
+                message = message.text(f"{p.title} ({p.raw_id})")
+                message = message.text("\n")
+            message = message.text(f"\n==== 第 {page} 页，共 {count_pages} 页 ====")
+            await target.send_message(message)
+
+    @cmd_admin.assign("all")
+    async def _(target: DepLongTaskTarget, ready: Query[bool] = Query("all.ready"), page: int = 1):
+        if not is_puzzle_admin(target):
+            return await target.send_message(UniMessage.text(
+                "你没有权限使用该指令"
+            ))
+        async with puzzle_manager() as manager:
+            puzzles = [*manager.puzzle_data.values()]
+            if ready.available:
+                puzzles = [p for p in puzzles if p.ready]
+            puzzles = sorted(puzzles, key=lambda p: p.created_at, reverse=True)
+            count_pages = ceil(len(puzzles) / PUZZLE_PAGE_SIZE)
+            if page <= 0 or page > count_pages:
+                return await target.send_message(UniMessage.text(
+                    f"页数只有 1 ~ {count_pages} 啦！"
+                ))
+            puzzles = puzzles[(page - 1) * PUZZLE_PAGE_SIZE: page * PUZZLE_PAGE_SIZE]
+            message = UniMessage.text("==== 所有谜题 ====\n\n")
+            for p in puzzles:
+                message = message.text("- ")
+                if p.raw_id == manager.puzzle_pinned:
+                    message = message.text("[📌]")
+                if manager.is_puzzle_published(p.raw_id):
+                    message = message.text(f"[✨][#{p.index_id}] ")
+                elif p.ready:
+                    message = message.text("[✅] ")
+                else:
+                    message = message.text("[⚙️] ")
+                message = message.text(f"{p.title} ({p.raw_id} by {p.author_id})")
+                message = message.text("\n")
+            message = message.text(f"\n==== 第 {page} 页，共 {count_pages} 页 ====")
+            await target.send_message(message)
+
+    @cmd_admin.assign("pin")
+    async def _(target: DepLongTaskTarget, raw_id: str = ""):
+        if not is_puzzle_admin(target):
+            return await target.send_message(UniMessage.text(
+                "你没有权限使用该指令"
+            ))
+
+        async with puzzle_manager() as manager:
+            if raw_id == "":
+                if manager.puzzle_pinned:
+                    return await target.send_message(UniMessage.text(
+                        f"被 Pin 的谜题 ID = {manager.puzzle_pinned}"
+                    ))
+                return await target.send_message("没有置顶谜题")
+            if raw_id not in manager.unpublished_puzzles:
+                return await target.send_message(UniMessage.text(
+                    "这个谜题已经发布了，或者还没准备好，或者不存在"
+                ))
+            manager.admin_pin_puzzle(raw_id)
+            return await target.send_message(f"已置顶谜题 {raw_id}")
+
+    @cmd_admin.assign("unpin")
+    async def _(target: DepLongTaskTarget):
+        if not is_puzzle_admin(target):
+            return await target.send_message(UniMessage.text(
+                "你没有权限使用该指令"
+            ))
+        async with puzzle_manager() as manager:
+            manager.admin_pin_puzzle("")
+            return await target.send_message("已取消所有置顶")
+
+    @cmd_admin.assign("modify")
+    async def _(
+        target: DepLongTaskTarget,
+        raw_id: str = "",
+        title: str | None = None,
+        description: str | None = None,
+        flag: str | None = None,
+        image: Image | None = None,
+        remove_image: Query[bool] = Query("modify.remove-image"),
+    ):
+        if raw_id == "":
+            return await target.send_message(
+                "konaph modify <raw_id> - 修改一个谜题\n\n"
+                "支持的参数：\n"
+                "  --title <str> 标题\n"
+                "  --description <str> 题目详情描述（用直引号包裹以支持多行）\n"
+                "  --flag <str> flag，也就是题目的答案\n"
+                "  --image <图片> 图片\n"
+                "  --remove-image 删除图片"
+            )
+        image_manager = get_image_manager()
+
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            if title is not None:
+                p.title = title
+            if description is not None:
+                p.content = description
+            if flag is not None:
+                p.flag = flag.strip()
+                if flag.strip() != flag:
+                    await target.send_message(
+                        "⚠️ 注意：你输入的 Flag 含有开头或结尾的空格，已经帮你去除"
+                    )
+            if image is not None and image.url is not None:
+                b = await download_image_bytes(image.url)
+                image_manager.remove_puzzle_image(p.img_name)
+                p.img_name = image_manager.upload_puzzle_image(b.unwrap())
+            elif remove_image.available:
+                image_manager.remove_puzzle_image(p.img_name)
+
+            info2 = get_puzzle_info_message(manager, p)
+
+            return await target.send_message("修改好啦！看看效果：\n\n" + info2)
+
+    @cmd_admin.assign("publish")
+    async def _(target: DepLongTaskTarget, raw_id: str | None = None):
+        if not is_puzzle_admin(target):
+            return await target.send_message(UniMessage.text(
+                "你没有权限使用该指令"
+            ))
+        today = get_today_date()
+        async with puzzle_manager() as manager:
+            if today in manager.daily_puzzle_of_date:
+                return await target.send_message("今日已经有题了哦")
+            manager.last_checked_date = today - datetime.timedelta(days=-1)
+            if raw_id is not None:
+                manager.admin_pin_puzzle(raw_id)
+            p = manager.get_today_puzzle(strong=True)
+            if p is None:
+                return await target.send_message("上架失败了orz，可能是没题了")
+            await qq_broadcast(config.plugin_puzzle_playgroup, get_puzzle_description(p))
+            return await target.send_message("Ok!")
+
+    @cmd_admin.assign("preview")
+    async def _(target: DepLongTaskTarget, raw_id: str):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            return await target.send_message(get_puzzle_description(p))
+
+    @cmd_admin.assign("get-submits")
+    async def _(target: DepLongTaskTarget, raw_id: str):
+        async with puzzle_manager() as manager:
+            puzzle = manager.puzzle_data.get(raw_id)
+            if puzzle is None:
+                return await target.send_message("没有这个谜题")
+            if not is_puzzle_admin(target) and target.target_id != puzzle.author_id:
+                return await target.send_message("你没有权限预览这个谜题")
+
+            msg = UniMessage.text(f"==== {puzzle.title} 提交记录 ====\n\n")
+            submits = manager.submissions.get(raw_id, {})
+            for uid, ls in submits.items():
+                s = ', '.join((i.flag for i in ls))
+                msg = msg.text(f"- {get_username(uid)}：{s}\n")
+            return await target.send_message(msg)
+
+    @cmd_admin.assign("test")
+    async def _(target: DepLongTaskTarget, raw_id: str, submission: str):
+        """
+        测试一道谜题的回答，并给出结果
+        """
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            result = p.check_submission(submission)
+            msg = get_submission_message(p, result)
+            return await target.send_message("[测试提交] " + msg)
+
+    @cmd_admin.assign("subcommands.hint")
+    async def _(target: DepLongTaskTarget, subcommands: Query[SubcommandResult] = Query("subcommands.hint")):
+        if len(subcommands.result.subcommands) > 0:
+            return
+        return await target.send_message(
+            UniMessage.text("==== 提示/中间答案编辑器 ====\n\n")
+            .text("- konaph hint list <id>\n  - 查看某道题的所有提示 / 中间答案\n")
+            .text("- konaph hint add <id> <pattern> <hint>\n  - 添加一个提示 / 中间答案\n")
+            .text("- konaph hint modify <id> <hint_id>\n")
+            .text("  - --pattern <pattern>\n    - 更改匹配规则\n")
+            .text("  - --message <message>\n    - 更改提示文本\n")
+            .text("  - --checkpoint [True|False]\n    - 更改是否为中间答案\n")
+            .text("- konaph hint delete <id> <hint_id>\n  - 删除一个提示 / 中间答案\n")
+            .text("\n更多关于 pattern 和中间答案的信息，请见 man：中间答案(7)")
+        )
+
+    @cmd_admin.assign("subcommands.hint.add")
+    async def _(
+        target: DepLongTaskTarget,
+        raw_id: str,
+        pattern: str,
+        message: str,
+    ):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            p.hints[p.hint_id_max + 1] = PuzzleHint(
+                pattern=pattern,
+                message=message,
+                is_checkpoint=False,
+            )
+            await target.send_message("创建成功！\n\n" + get_puzzle_hint_list(p))
+
+    @cmd_admin.assign("subcommands.hint.list")
+    async def _(
+        target: DepLongTaskTarget,
+        raw_id: str,
+    ):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            await target.send_message(get_puzzle_hint_list(p))
+
+    @cmd_admin.assign("subcommands.hint.modify")
+    async def _(
+        target: DepLongTaskTarget,
+        raw_id: str,
+        hint_id: int,
+        pattern: str | None = None,
+        message: str | None = None,
+        is_checkpoint: bool | None = None,
+    ):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            if hint_id not in p.hints:
+                raise BotExceptionMessage(
+                    f"没有这个 hint_id。请使用 konaph hint list {raw_id} 了解 hint 清单"
+                )
+            hint = p.hints[hint_id]
+            if pattern is not None:
+                hint.pattern = pattern
+            if message is not None:
+                hint.message = message
+            if is_checkpoint is not None:
+                hint.is_checkpoint = is_checkpoint
+            await target.send_message("更改成功！\n\n" + get_puzzle_hint_list(p))
+
+    @cmd_admin.assign("subcommands.hint.delete")
+    async def _(
+        target: DepLongTaskTarget,
+        raw_id: str,
+        hint_id: int,
+    ):
+        async with puzzle_manager() as manager:
+            p = check_puzzle(manager, target, raw_id)
+            if hint_id not in p.hints:
+                raise BotExceptionMessage(
+                    f"没有这个 hint_id。请使用 konaph hint list {raw_id} 了解 hint 清单"
+                )
+            del p.hints[hint_id]
+            await target.send_message("删除成功！\n\n" + get_puzzle_hint_list(p))
+
+
+    return cmd_admin
--- a/konabot/plugins/llm_test.py
+++ b/konabot/plugins/llm_test.py
@ -0,0 +1,40 @@
+"""
+肥肠危险注意：本文件仅用于开发环境测试 LLM 模块能否正常工作！
+
+请不要在生产环境启用它！
+"""
+
+import nonebot
+from nonebot_plugin_alconna import Alconna, Args, on_alconna
+from pydantic import BaseModel
+
+from konabot.common.llm import get_llm
+from konabot.common.longtask import DepLongTaskTarget
+
+
+class LLMTestConfig(BaseModel):
+    debug_enable_llm_test: bool = False
+
+
+config = nonebot.get_plugin_config(LLMTestConfig)
+
+
+if config.debug_enable_llm_test:
+    cmd = on_alconna(Alconna(
+        "debug-ask-llm",
+        Args["prompt", str],
+    ))
+
+    @cmd.handle()
+    async def _(prompt: str, target: DepLongTaskTarget):
+        llm = get_llm()
+        msg = await llm.chat(
+            [
+                {"role": "user", "content": prompt}
+            ],
+            timeout=None,
+            max_tokens=1024,
+        )
+        content = msg.content or ""
+        await target.send_message(content)
+
--- a/konabot/plugins/man/init.py
+++ b/konabot/plugins/man/init.py
@ -1,4 +1,3 @@
-from curses.ascii import isdigit
 from pathlib import Path

 import nonebot
@ -40,7 +39,10 @@ async def _(
    doc: str | None,
    event: nonebot.adapters.Event,
 ):
-    if doc is not None and section is None and all(isdigit(c) for c in doc):
+    if doc is not None and section is None and all(
+        ord('0') <= ord(c) <= ord('9')
+        for c in doc
+    ):
        section = int(doc)
        doc = None

@ -75,7 +77,7 @@ async def _(
    else:
        # 查阅模式
        if section is None:
-            section_set = {1}
+            section_set = {1, 7}
        else:
            section_set = {section}
        if 1 in section_set and is_admin(event):
--- a/konabot/plugins/markdown/init.py
+++ b/konabot/plugins/markdown/init.py
@ -0,0 +1,76 @@
+from loguru import logger
+import nonebot
+from nonebot.adapters import Event as BaseEvent
+from nonebot.adapters.discord.event import MessageEvent as DiscordMessageEvent
+from nonebot_plugin_alconna import (
+    UniMessage,
+    UniMsg
+)
+
+from playwright.async_api import ConsoleMessage, Page
+
+from konabot.common.web_render import konaweb
+from konabot.common.web_render.core import WebRenderer
+from konabot.plugins.markdown.core import MarkDownCore
+
+def is_markdown_mentioned(evt: BaseEvent, msg: UniMsg) -> bool:
+    txt = msg.extract_plain_text()
+    if "markdown" not in txt[:10] or "md" not in txt[:3]:
+        return False
+    return True
+
+evt = nonebot.on_message(rule=is_markdown_mentioned)
+
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent):
+    if isinstance(event, DiscordMessageEvent):
+        content = msg.extract_plain_text()
+    else:
+        content = msg.extract_plain_text()
+
+    logger.debug(f"Received markdown command with content: {content}")
+    if "md" in content[:3]:
+        message = content.replace("md", "", 1).strip()
+    else:
+        message = content.replace("markdown", "", 1).strip()
+    # 如果回复了消息，则转换回复的内容
+    if(len(message) == 0):
+        if event.reply:
+            message = event.reply.message.extract_plain_text()
+        else:
+            return
+    logger.debug(f"Markdown content to render: {message}")
+
+    out = await MarkDownCore.render_markdown(message, theme="dark")
+
+    await evt.send(await UniMessage().image(raw=out).export())
+
+
+def is_latex_mentioned(evt: BaseEvent, msg: UniMsg) -> bool:
+    txt = msg.extract_plain_text()
+    if "latex" not in txt[:8]:
+        return False
+    return True
+
+evt = nonebot.on_message(rule=is_latex_mentioned)
+
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent):
+    if isinstance(event, DiscordMessageEvent):
+        content = msg.extract_plain_text()
+    else:
+        content = msg.extract_plain_text()
+
+    logger.debug(f"Received markdown command with content: {content}")
+    message = content.replace("latex", "", 1).strip()
+    # 如果回复了消息，则转换回复的内容
+    if(len(message) == 0):
+        if event.reply:
+            message = event.reply.message.extract_plain_text()
+        else:
+            return
+    logger.debug(f"Latex content to render: {message}")
+
+    out = await MarkDownCore.render_latex(message, theme="dark")
+
+    await evt.send(await UniMessage().image(raw=out).export())
--- a/konabot/plugins/markdown/core.py
+++ b/konabot/plugins/markdown/core.py
@ -0,0 +1,57 @@
+from loguru import logger
+from playwright.async_api import ConsoleMessage, Page
+
+from konabot.common.web_render import konaweb
+from konabot.common.web_render.core import WebRenderer
+
+class MarkDownCore:
+    @staticmethod
+    async def render_markdown(markdown_text: str, theme: str = "dark", params: dict = {}) -> bytes:
+        async def page_function(page: Page):
+            async def on_console(msg: ConsoleMessage):
+                logger.debug(f"WEB CONSOLE {msg.text}")
+
+            await page.emulate_media(color_scheme=theme)
+
+            page.on('console', on_console)
+
+            await page.locator('textarea[name=content]').fill(markdown_text)
+            await page.wait_for_timeout(200)
+            await page.locator('#button').click()
+            await page.wait_for_timeout(200)
+
+        out = await WebRenderer.render(
+            konaweb('markdown'),
+            target='#main',
+            other_function=page_function,
+            params=params
+        )
+
+        return out
+    
+    @staticmethod
+    async def render_latex(text: str, theme: str = "dark") -> bytes:
+        params = {
+            "size": "2em",
+        }
+        async def page_function(page: Page):
+            async def on_console(msg: ConsoleMessage):
+                logger.debug(f"WEB CONSOLE {msg.text}")
+
+            await page.emulate_media(color_scheme=theme)
+
+            page.on('console', on_console)
+
+            await page.locator('textarea[name=content]').fill(f"$$ {text} $$")
+            await page.wait_for_timeout(200)
+            await page.locator('#button').click()
+            await page.wait_for_timeout(200)
+
+        out = await WebRenderer.render(
+            konaweb('latex'),
+            target='#main',
+            other_function=page_function,
+            params=params
+        )
+
+        return out
--- a/konabot/plugins/memepack/init.py
+++ b/konabot/plugins/memepack/init.py
@ -1,6 +1,7 @@
 from io import BytesIO
 from typing import Iterable, cast

+from loguru import logger
 from nonebot import on_message
 from nonebot_plugin_alconna import (
    Alconna,
@ -14,8 +15,12 @@ from nonebot_plugin_alconna import (
    UniMsg,
    on_alconna,
 )
+from playwright.async_api import ConsoleMessage, Page

 from konabot.common.nb.extract_image import PIL_Image, extract_image_from_message
+from konabot.common.web_render import konaweb
+from konabot.common.web_render.core import WebRenderer
+from konabot.common.web_render.host_images import host_tempdir
 from konabot.plugins.memepack.drawing.display import (
    draw_cao_display,
    draw_snaur_display,
@ -24,10 +29,12 @@ from konabot.plugins.memepack.drawing.display import (
 from konabot.plugins.memepack.drawing.saying import (
    draw_cute_ten,
    draw_geimao,
+    draw_kiosay,
    draw_mnk,
    draw_pt,
    draw_suan,
 )
+from konabot.plugins.memepack.drawing.watermark import draw_doubao_watermark

 from nonebot.adapters import Bot, Event

@ -275,3 +282,77 @@ async def _(msg: UniMsg, evt: Event, bot: Bot):
                .export()
            )

+
+kiosay = on_alconna(
+    Alconna(
+        "西多说",
+        Args[
+            "saying",
+            MultiVar(str, "+"),
+            Field(missing_tips=lambda: "你没有写西多说了什么"),
+        ],
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=False,
+    aliases=set(),
+)
+
+
+@kiosay.handle()
+async def _(saying: list[str]):
+    img = await draw_kiosay("\n".join(saying))
+    img_bytes = BytesIO()
+    img.save(img_bytes, format="PNG")
+
+    await kiosay.send(await UniMessage().image(raw=img_bytes).export())
+
+
+quote_cmd = on_alconna(Alconna(
+    "名人名言",
+    Args["quote", str],
+    Args["author", str],
+    Args["image?", Image | None],
+), aliases={"quote"})
+
+@quote_cmd.handle()
+async def _(quote: str, author: str, img: PIL_Image):
+    async with host_tempdir() as tempdir:
+        img_path = tempdir.path / "image.png"
+        img_url = tempdir.url_of(img_path)
+        img.save(img_path)
+
+        async def page_function(page: Page):
+            async def on_console(msg: ConsoleMessage):
+                logger.debug(f"WEB CONSOLE {msg.text}")
+
+            page.on('console', on_console)
+
+            await page.locator('input[name=image]').fill(img_url)
+            await page.locator('input[name=quote]').fill(quote)
+            await page.locator('input[name=author]').fill(author)
+
+            await page.wait_for_timeout(500)
+            await page.wait_for_load_state('networkidle')
+            await page.wait_for_timeout(500)
+
+        out = await WebRenderer.render(
+            konaweb('makequote'),
+            target='#main',
+            other_function=page_function,
+        )
+    await quote_cmd.send(await UniMessage().image(raw=out).export())
+
+
+doubao_cmd = on_alconna(Alconna(
+    "豆包水印",
+    Args["image?", Image | None],
+))
+
+
+@doubao_cmd.handle()
+async def _(img: PIL_Image):
+    result = await draw_doubao_watermark(img)
+    result_bytes = BytesIO()
+    result.save(result_bytes, format="PNG")
+    await doubao_cmd.send(await UniMessage().image(raw=result_bytes).export())
--- a/konabot/plugins/memepack/drawing/saying.py
+++ b/konabot/plugins/memepack/drawing/saying.py
@ -5,6 +5,7 @@ import imagetext_py
 import PIL.Image

 from konabot.common.path import ASSETS_PATH
+from konabot.common.utils.to_async import make_async

 from .base.fonts import HARMONYOS_SANS_SC_BLACK, HARMONYOS_SANS_SC_REGULAR, LXGWWENKAI_REGULAR

@ -14,6 +15,7 @@ mnk_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "mnksay.jpg").convert(
 dasuan_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "dss.png").convert("RGBA")
 suan_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "suanleba.png").convert("RGBA")
 cute_ten_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "tententen.png").convert("RGBA")
+kio_image = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "kiosay.jpg").convert("RGBA")


 def _draw_geimao(saying: str):
@ -29,7 +31,7 @@ def _draw_geimao(saying: str):
            draw_emojis=True,
        )
    return img
-    
+

 async def draw_geimao(saying: str):
    return await asyncio.to_thread(_draw_geimao, saying)
@ -106,3 +108,18 @@ def _draw_cute_ten(saying: str):

 async def draw_cute_ten(saying: str):
    return await asyncio.to_thread(_draw_cute_ten, saying)
+
+
+@make_async
+def draw_kiosay(saying: str):
+    img = kio_image.copy()
+    with imagetext_py.Writer(img) as iw:
+        iw.draw_text_wrapped(
+            saying, 450, 540, 0.5, 0.5, 900, 96, LXGWWENKAI_REGULAR,
+            imagetext_py.Paint.Color(imagetext_py.Color.from_hex("000000FF")),
+            1.0,
+            imagetext_py.TextAlign.Center,
+            draw_emojis=True,
+        )
+    return img
+
--- a/konabot/plugins/memepack/drawing/watermark.py
+++ b/konabot/plugins/memepack/drawing/watermark.py
@ -0,0 +1,20 @@
+import PIL
+import PIL.Image
+
+from konabot.common.path import ASSETS_PATH
+from konabot.common.utils.to_async import make_async
+
+doubao_watermark = PIL.Image.open(ASSETS_PATH / "img" / "meme" / "doubao.png").convert("RGBA")
+
+
+@make_async
+def draw_doubao_watermark(base: PIL.Image.Image) -> PIL.Image.Image:
+    base = base.copy().convert("RGBA")
+    w = base.size[0] / 768 * 140
+    h = base.size[0] / 768 * 40
+    x = base.size[0] / 768 * 160
+    y = base.size[0] / 768 * 60
+    w, h, x, y = map(int, (w, h, x, y))
+    base.alpha_composite(doubao_watermark.resize((w, h)), (base.size[0] - x, base.size[1] - y))
+    return base
+
--- a/konabot/plugins/poll/init.py
+++ b/konabot/plugins/poll/init.py
@ -15,7 +15,7 @@ if not POLL_DATA_FILE.exists():
    POLL_DATA_FILE.write_bytes(POLL_TEMPLATE_FILE.read_bytes())


-poll_list = json.loads(POLL_DATA_FILE.read_text())['poll']
+poll_list = json.loads(POLL_DATA_FILE.read_text("utf-8"))['poll']

 async def createpoll(title,qqid,options):
    polllength = len(poll_list)
@ -53,7 +53,7 @@ def writeback():
    # json.dump({'poll':poll_list},file,ensure_ascii=False,sort_keys=True)
    POLL_DATA_FILE.write_text(json.dumps({
        'poll': poll_list,
-    }, ensure_ascii=False, sort_keys=True))
+    }, ensure_ascii=False, sort_keys=True), "utf-8")

 async def pollvote(polnum,optionnum,qqnum):
    optiond = poll_list[polnum]["polldata"]
--- a/konabot/plugins/roll_dice/roll_dice.py
+++ b/konabot/plugins/roll_dice/roll_dice.py
@ -394,7 +394,8 @@ async def generate_dice_image(number: str) -> BytesIO:
               append_images=images[1:],
               duration=frame_durations,
               format='GIF',
-               loop=1)
+               loop=1,
+               disposal=2)
    output.seek(0)
    # pil_final.save(output, format='PNG')
    return output
--- a/konabot/plugins/auto_accept.py
+++ b/konabot/plugins/auto_accept.py
@ -4,10 +4,13 @@ from typing import cast

 from loguru import logger
 from nonebot import get_bot, on_request
+import nonebot
 from nonebot.adapters.onebot.v11.event import FriendRequestEvent
 from nonebot.adapters.onebot.v11.bot import Bot as OnebotBot
+from nonebot_plugin_apscheduler import scheduler

 from konabot.common.nb.is_admin import cfg as adminConfig
+from konabot.common.username import manager

 add_request = on_request()

@ -23,3 +26,15 @@ async def _(req: FriendRequestEvent):
        await req.approve(bot)
        logger.info(f"已经自动同意 {req.user_id} 的好友请求")

+@scheduler.scheduled_job("cron", minute="*/5")
+async def _():
+    logger.info("尝试更新群成员信息")
+    await manager.update()
+
+driver = nonebot.get_driver()
+
+@driver.on_bot_connect
+async def _():
+    logger.info("有 Bot 连接，5 秒后试着更新群成员信息")
+    await asyncio.sleep(5)
+    await manager.update()
--- a/konabot/plugins/simple_notify/init.py
+++ b/konabot/plugins/simple_notify/init.py
@ -1,25 +1,20 @@
+import aiohttp
 import asyncio as asynkio
-import datetime
+from math import ceil
 from pathlib import Path
-from typing import Any, Literal, cast
+from typing import Any

+import nanoid
 import nonebot
 import ptimeparse
 from loguru import logger
-from nonebot import on_message
+from nonebot import get_plugin_config, on_message
 from nonebot.adapters import Event
-from nonebot.adapters.console import Bot as ConsoleBot
-from nonebot.adapters.console.event import MessageEvent as ConsoleMessageEvent
-from nonebot.adapters.discord import Bot as DiscordBot
-from nonebot.adapters.discord.event import MessageEvent as DiscordMessageEvent
-from nonebot.adapters.onebot.v11 import Bot as OnebotV11Bot
-from nonebot.adapters.onebot.v11.event import (
-    GroupMessageEvent as OnebotV11GroupMessageEvent,
-)
-from nonebot.adapters.onebot.v11.event import MessageEvent as OnebotV11MessageEvent
-from nonebot_plugin_alconna import UniMessage, UniMsg
+from nonebot_plugin_alconna import Alconna, Args, Subcommand, UniMessage, UniMsg, on_alconna
 from pydantic import BaseModel

+from konabot.common.longtask import DepLongTaskTarget, LongTask, create_longtask, handle_long_task, longtask_data
+
 evt = on_message()

 (Path(__file__).parent.parent.parent.parent / "data").mkdir(exist_ok=True)
@ -27,127 +22,55 @@ DATA_FILE_PATH = Path(__file__).parent.parent.parent.parent / "data" / "notify.j
 DATA_FILE_LOCK = asynkio.Lock()

 ASYNK_TASKS: set[asynkio.Task[Any]] = set()
+LONG_TASK_NAME = "TASK_SIMPLE_NOTIFY"
+PAGE_SIZE = 6

-
-class Notify(BaseModel):
-    platform: Literal["console", "qq", "discord"]
-
-    target: str
-    "需要接受通知的个体"
-
-    target_env: str | None
-    "在哪里进行通知，如果是 None 代表私聊通知"
-
-    notify_time: datetime.datetime
-    notify_msg: str
-
-    def get_str(self):
-        return f"{self.target}-{self.target_env}-{self.platform}-{self.notify_time}"
+FMT_STRING = "%Y年%m月%d日 %H:%M:%S"


 class NotifyConfigFile(BaseModel):
    version: int = 2
-    notifies: list[Notify] = []
-    unsent: list[Notify] = []
+    notify_channels: dict[str, str] = {}
+
+
+class NotifyPluginConfig(BaseModel):
+    plugin_notify_enable_ntfy: bool = False
+    plugin_notify_base_url: str = ""
+    plugin_notify_access_token: str = ""
+    plugin_notify_prefix: str = "kona-notice-"
+
+
+config = get_plugin_config(NotifyPluginConfig)
+
+
+async def send_notify_to_ntfy_instance(msg: str, channel: str):
+    if not config.plugin_notify_enable_ntfy:
+        return
+    url = f"{config.plugin_notify_base_url}/{channel}"
+
+    async with aiohttp.ClientSession() as session:
+        session.headers["Authorization"] = f"Bearer {config.plugin_notify_access_token}"
+        session.headers["Title"] = "🔔 此方 BOT 提醒"
+        async with session.post(url, data=msg) as response:
+            logger.info(f"访问 {url} 的结果是 {response.status}")


 def load_notify_config() -> NotifyConfigFile:
    if not DATA_FILE_PATH.exists():
        return NotifyConfigFile()
    try:
-        return NotifyConfigFile.model_validate_json(DATA_FILE_PATH.read_text())
+        return NotifyConfigFile.model_validate_json(DATA_FILE_PATH.read_text("utf-8"))
    except Exception as e:
        logger.warning(f"在解析 Notify 时遇到问题：{e}")
        return NotifyConfigFile()


 def save_notify_config(config: NotifyConfigFile):
-    DATA_FILE_PATH.write_text(config.model_dump_json(indent=4))
-
-
-async def notify_now(notify: Notify):
-    if notify.platform == "console":
-        bot = [b for b in nonebot.get_bots().values() if isinstance(b, ConsoleBot)]
-        if len(bot) != 1:
-            logger.warning(f"提醒未成功发送出去：{nonebot.get_bots()} {notify}")
-            return False
-        bot = bot[0]
-        await bot.send_private_message(notify.target, f"代办通知：{notify.notify_msg}")
-    elif notify.platform == "discord":
-        bot = [b for b in nonebot.get_bots().values() if isinstance(b, DiscordBot)]
-        if len(bot) != 1:
-            logger.warning(f"提醒未成功发送出去：{nonebot.get_bots()} {notify}")
-            return False
-        bot = bot[0]
-        channel = await bot.create_DM(recipient_id=int(notify.target))
-        await bot.send_to(channel.id, f"代办通知：{notify.notify_msg}")
-    elif notify.platform == "qq":
-        bot = [b for b in nonebot.get_bots().values() if isinstance(b, OnebotV11Bot)]
-        if len(bot) != 1:
-            logger.warning(f"提醒未成功发送出去：{nonebot.get_bots()} {notify}")
-            return False
-        bot = bot[0]
-        if notify.target_env is None:
-            await bot.send_private_msg(
-                user_id=int(notify.target),
-                message=cast(
-                    Any,
-                    await UniMessage.text(f"代办通知：{notify.notify_msg}").export(
-                        bot=bot,
-                    ),
-                ),
-            )
-        else:
-            await bot.send_group_msg(
-                group_id=int(notify.target_env),
-                message=cast(
-                    Any,
-                    await UniMessage()
-                    .at(notify.target)
-                    .text(f" 代办通知：{notify.notify_msg}")
-                    .export(bot=bot),
-                ),
-            )
-    else:
-        logger.warning(f"提醒未成功发送出去：{notify}")
-        return False
-    return True
-
-
-def create_notify_task(notify: Notify, fail2remove: bool = True):
-    async def mission():
-        begin_time = datetime.datetime.now()
-        if begin_time < notify.notify_time:
-            try:
-                await asynkio.sleep((notify.notify_time - begin_time).total_seconds())
-            except asynkio.CancelledError:
-                logger.debug(
-                    f"代办提醒被信号中止，任务退出 NOTIFY={notify.notify_msg} TIME={notify.notify_time}"
-                )
-                return
-        else:
-            logger.warning(
-                f"期望在 {notify.notify_time} 在平台 {notify.platform} {notify.target_env}"
-                f" {notify.target} 的代办通知 {notify.notify_msg} 已经超时，将会直接通知！"
-            )
-        res = await notify_now(notify)
-        if fail2remove or res:
-            async with DATA_FILE_LOCK:
-                cfg = load_notify_config()
-                cfg.notifies = [
-                    n for n in cfg.notifies if n.get_str() != notify.get_str()
-                ]
-                if not res:
-                    cfg.unsent.append(notify)
-                save_notify_config(cfg)
-        else:
-            pass
-
-    return asynkio.create_task(mission())
+    DATA_FILE_PATH.write_text(config.model_dump_json(indent=4), "utf-8")


@evt.handle()
-async def _(msg: UniMsg, mEvt: Event):
+async def _(msg: UniMsg, mEvt: Event, target: DepLongTaskTarget):
    if mEvt.get_user_id() in nonebot.get_bots():
        return

@ -160,97 +83,170 @@ async def _(msg: UniMsg, mEvt: Event):
        return

    notify_time, notify_text = segments
-    # target_time = get_target_time(notify_time)
    try:
-        # target_time = ptimeparse.parse(notify_time)
        target_time = ptimeparse.Parser().parse(notify_time)
        logger.info(f"从 {notify_time} 解析出了时间：{target_time}")
    except Exception:
        logger.info(f"无法从 {notify_time} 中解析出时间")
        return
-    # if target_time is None:
-    #     logger.info(f"无法从 {notify_time} 中解析出时间")
-    #     return
    if not notify_text:
        return

-    await DATA_FILE_LOCK.acquire()
-    cfg = load_notify_config()
-
-    if isinstance(mEvt, ConsoleMessageEvent):
-        platform = "console"
-        target = mEvt.get_user_id()
-        target_env = None
-    elif isinstance(mEvt, OnebotV11MessageEvent):
-        platform = "qq"
-        target = mEvt.get_user_id()
-        if isinstance(mEvt, OnebotV11GroupMessageEvent):
-            target_env = str(mEvt.group_id)
-        else:
-            target_env = None
-    elif isinstance(mEvt, DiscordMessageEvent):
-        platform = "discord"
-        target = mEvt.get_user_id()
-        target_env = None
-    else:
-        logger.warning(f"Notify 遇到不支持的平台：{type(mEvt).__name__}")
-        return
-
-    notify = Notify(
-        platform=platform,
-        target=target,
-        target_env=target_env,
-        notify_time=target_time,
-        notify_msg=notify_text,
+    await create_longtask(
+        LONG_TASK_NAME,
+        { "message": notify_text },
+        target,
+        target_time,
    )
-    create_notify_task(notify)

-    cfg.notifies.append(notify)
-    save_notify_config(cfg)
-    DATA_FILE_LOCK.release()
-
-    await evt.send(
-        await UniMessage()
-        .at(mEvt.get_user_id())
-        .text(f" 了解啦！将会在 {notify.notify_time} 提醒你哦~")
-        .export()
+    await target.send_message(
+        UniMessage().text(f"了解啦！将会在 {target_time.strftime(FMT_STRING)} 提醒你哦~")
    )
-    logger.info(f"创建了一条于 {notify.notify_time} 的代办提醒")
+    logger.info(f"创建了一条于 {target_time} 的代办提醒")


 driver = nonebot.get_driver()

-NOTIFIED_FLAG = {
-    "task_added": False,
-}
+
+@handle_long_task("TASK_SIMPLE_NOTIFY")
+async def _(task: LongTask):
+    message = task.data["message"]
+    await task.target.send_message(
+        UniMessage().text(f"代办提醒：{message}")
+    )
+    async with DATA_FILE_LOCK:
+        data = load_notify_config()
+        if (chan := data.notify_channels.get(task.target.target_id)) is not None:
+            await send_notify_to_ntfy_instance(message, chan)
+        save_notify_config(data)


-@driver.on_bot_connect
-async def _():
-    if NOTIFIED_FLAG["task_added"]:
+USER_CHECKOUT_TASK_CACHE: dict[str, dict[str, str]] = {}
+
+
+cmd_check_notify_list = on_alconna(Alconna(
+    "re:(?:我有哪些|查询)(?:提醒|代办)",
+    Args["page", int, 1]
+))
+
+@cmd_check_notify_list.handle()
+async def _(page: int, target: DepLongTaskTarget):
+    if page <= 0:
+        await target.send_message(UniMessage().text("页数应该大于 0 吧"))
        return
+    async with longtask_data() as data:
+        tasks = data.to_handle.get(LONG_TASK_NAME, {}).values()
+        tasks = [t for t in tasks if t.target.target_id == target.target_id]
+        tasks = sorted(tasks, key=lambda t: t.deadline)
+        pages = ceil(len(tasks) / PAGE_SIZE)
+        if page > pages:
+            await target.send_message(UniMessage().text(f"最多也就 {pages} 页啦！"))
+        tasks = tasks[(page - 1) * PAGE_SIZE: page * PAGE_SIZE]

-    NOTIFIED_FLAG["task_added"] = True
+        message = "你可以输入「删除提醒 序号」来删除一个提醒\n====== 代办清单 ======\n\n"

-    DELTA = 2
-    logger.info(f"第一次探测到 Bot 连接，等待 {DELTA} 秒后开始通知")
-    await asynkio.sleep(DELTA)
+        to_cache = {}
+        if len(tasks) == 0:
+            message += "空空如也\n"
+        else:
+            for i, task in enumerate(tasks):
+                to_cache[str(i + 1)] = task.uuid
+                message += f"{i + 1}) {task.data['message']}（{task.deadline.strftime(FMT_STRING)}）\n"

-    await DATA_FILE_LOCK.acquire()
+        message += f"\n==== 第 {page} 页，共 {pages} 页 ===="
+        USER_CHECKOUT_TASK_CACHE[target.target_id] = to_cache

-    # tasks: set[asynkio.Task[Any]] = set()
-    cfg = load_notify_config()
-    if cfg.version == 1:
-        logger.info("将配置文件的版本升级为 2")
-        cfg.version = 2
+        await target.send_message(UniMessage().text(message))
+
+
+cmd_remove_task = on_alconna(Alconna(
+    "re:删除(?:提醒|代办)",
+    Args["checker", str],
+))
+
+@cmd_remove_task.handle()
+async def _(checker: str, target: DepLongTaskTarget):
+    if target.target_id not in USER_CHECKOUT_TASK_CACHE:
+        await target.send_message(UniMessage().text(
+            "先用「查询提醒」来查询你有哪些提醒吧"
+        ))
+        return
+    if checker not in USER_CHECKOUT_TASK_CACHE[target.target_id]:
+        await target.send_message(UniMessage().text(
+            "没有这个任务哦，请检查一下吧"
+        ))
+    uuid = USER_CHECKOUT_TASK_CACHE[target.target_id][checker]
+    async with longtask_data() as data:
+        if uuid not in data.to_handle[LONG_TASK_NAME]:
+            await target.send_message(UniMessage().text(
+                "似乎这个提醒已经发出去了，或者已经被删除"
+            ))
+            return
+        _msg = data.to_handle[LONG_TASK_NAME][uuid].data["message"]
+        del data.to_handle[LONG_TASK_NAME][uuid]
+        await target.send_message(UniMessage().text(
+            f"成功取消了提醒：{_msg}"
+        ))
+
+
+cmd_notify_channel = on_alconna(Alconna(
+    "ntfy",
+    Subcommand("删除", dest="delete"),
+    Subcommand("创建", Args["notify_id?", str], dest="create"),
+), rule=lambda: config.plugin_notify_enable_ntfy)
+
+@cmd_notify_channel.assign("$main")
+async def _(target: DepLongTaskTarget):
+    async with DATA_FILE_LOCK:
+        data = load_notify_config()
+        target_channel = data.notify_channels.get(target.target_id)
+
+    if target_channel is None:
+        channel_msg = "目前还没有配置 ntfy 地址"
    else:
-        counter = 0
-        for notify in [*cfg.notifies]:
-            task = create_notify_task(notify, fail2remove=False)
-            ASYNK_TASKS.add(task)
-            task.add_done_callback(lambda self: ASYNK_TASKS.remove(self))
-            counter += 1
-        logger.info(f"成功创建了 {counter} 条代办事项")
-    save_notify_config(cfg)
-    DATA_FILE_LOCK.release()
+        channel_msg = f"配置的 ntfy Channel 为：{target_channel}\n\n服务器地址：{config.plugin_notify_base_url}"
+
+    await target.send_message(UniMessage.text(
+        f"{channel_msg}\n\n"
+        "配置 ntfy 通知：\n\n"
+        "- ntfy 创建: 启用 ntfy 通知，并为你随机生成一个通知渠道\n"
+        "- ntfy 删除：禁用 ntfy 通知\n"
+    ))
+
+@cmd_notify_channel.assign("create")
+async def _(target: DepLongTaskTarget, notify_id: str = ""):
+    if notify_id == "":
+        notify_id = nanoid.generate(
+            alphabet="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-",
+            size=16,
+        )
+
+    channel_name = f"{config.plugin_notify_prefix}{notify_id}"
+
+    async with DATA_FILE_LOCK:
+        data = load_notify_config()
+        data.notify_channels[target.target_id] = channel_name
+        save_notify_config(data)
+
+    await target.send_message(UniMessage.text(
+        f"了解！将会在 {channel_name} 为你提醒！\n"
+        "\n"
+        "食用教程：在你的手机端 / 网页端 ntfy 点击「订阅主题」，选择「使用其他服务器」，"
+        f"服务器填写 {config.plugin_notify_base_url} ，主题名填写 {channel_name}\n"
+        f"最后点击订阅，就能看到我给你发的消息啦！"
+    ))
+
+    await send_notify_to_ntfy_instance(
+        "如果你看到这条消息，说明你已经成功订阅主题！此方 BOT 将会在这里提醒你你的代办！",
+        channel_name,
+    )
+
+
+@cmd_notify_channel.assign("delete")
+async def _(target: DepLongTaskTarget):
+    async with DATA_FILE_LOCK:
+        data = load_notify_config()
+        del data.notify_channels[target.target_id]
+        save_notify_config(data)
+    await target.send_message(UniMessage.text("ok."))

--- a/konabot/plugins/xibao_generate/init.py
+++ b/konabot/plugins/xibao_generate/init.py
@ -0,0 +1,118 @@
+from typing import Optional
+from nonebot_plugin_alconna import Alconna, Args, UniMessage, UniMsg, on_alconna
+from konabot.common.web_render import WebRenderer
+from nonebot.adapters import Event as BaseEvent
+from playwright.async_api import Page
+
+async def continue_handle(page: Page, content: str) -> None:
+    # 这里可以添加一些预处理逻辑
+    # 找到 id 为 input 的 textarea 元素
+    textarea = await page.query_selector("#input")
+    if textarea:
+        # 在 textarea 中输入内容
+        await textarea.fill(content)
+    # 找到 id 为 submit-btn 的按钮元素
+    submit_button = await page.query_selector("#submit-btn")
+    if submit_button:
+        # 点击按钮提交
+        await submit_button.click()
+
+evt = on_alconna(
+    Alconna(
+        f"生成喜报",
+        Args["content?", str]
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=True,
+)
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent, content: Optional[str] = ""):
+
+    screenshot = await WebRenderer.render(
+        url="https://witnessbot.mxowl.com/services/congratulations/",
+        target="#main-canvas",
+        other_function=lambda page: continue_handle(page, content),
+        timeout=30
+    )
+    await evt.send(
+        await UniMessage().image(raw=screenshot).export()
+    )
+
+async def beibao_continue_handle(page: Page, content: str) -> None:
+    # 这里可以添加一些预处理逻辑
+    # 找到 id 为 input 的 textarea 元素
+    textarea = await page.query_selector("#input")
+    if textarea:
+        # 在 textarea 中输入内容
+        await textarea.fill(content)
+    # 找到 class 为 btn btn-outline-primary，for属性为 mode-2 的标签元素
+    mode_radio = await page.query_selector("label.btn.btn-outline-primary[for='mode-2']")
+    if mode_radio:
+        # 点击选择悲报模式
+        await mode_radio.click()
+    # 找到 id 为 submit-btn 的按钮元素
+    submit_button = await page.query_selector("#submit-btn")
+    if submit_button:
+        # 点击按钮提交
+        await submit_button.click()
+
+evt = on_alconna(
+    Alconna(
+        f"生成悲报",
+        Args["content?", str]
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=True,
+)
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent, content: Optional[str] = ""):
+
+    screenshot = await WebRenderer.render(
+        url="https://witnessbot.mxowl.com/services/congratulations/",
+        target="#main-canvas",
+        other_function=lambda page: beibao_continue_handle(page, content),
+        timeout=30
+    )
+    await evt.send(
+        await UniMessage().image(raw=screenshot).export()
+    )
+
+async def continue_handle_3(page: Page, arg1: str, arg2: str) -> None:
+    # 这里可以添加一些预处理逻辑
+    # 找到 id 为 textL 的 input，id 为 textR 的 input
+    input1 = await page.query_selector("#textL")
+    input2 = await page.query_selector("#textR")
+    if input1:
+        await input1.fill(arg1)
+    if input2:
+        await input2.fill(arg2)
+    # 等待 0.3 秒钟
+    await page.wait_for_timeout(300)
+    # 等待 id 为 loading 的元素不可见
+    loading = await page.query_selector("#loading")
+    if loading:
+        await loading.wait_for_element_state("hidden")
+
+evt = on_alconna(
+    Alconna(
+        f"BA生成",
+        Args["arg1", str],
+        Args["arg2", str]
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=True,
+)
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent, arg1: str, arg2: str):
+    screenshot = await WebRenderer.render(
+        url="https://tmp.nulla.top/ba-logo/",
+        target="#canvas",
+        other_function=lambda page: continue_handle_3(page, arg1, arg2),
+        timeout=30
+    )
+    await evt.send(
+        await UniMessage().image(raw=screenshot).export()
+    )
--- a/poetry.lock
+++ b/poetry.lock
@ -803,6 +803,23 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "distro"
+version = "1.9.0"
+description = "Distro - an OS platform information API"
+optional = false
+python-versions = ">=3.6"
+groups = ["main"]
+files = [
+    {file = "distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2"},
+    {file = "distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed"},
+]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "exceptiongroup"
 version = "1.3.0"
@ -989,6 +1006,79 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "greenlet"
+version = "3.2.4"
+description = "Lightweight in-process concurrent programming"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "greenlet-3.2.4-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:8c68325b0d0acf8d91dde4e6f930967dd52a5302cd4062932a6b2e7c2969f47c"},
+    {file = "greenlet-3.2.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:94385f101946790ae13da500603491f04a76b6e4c059dab271b3ce2e283b2590"},
+    {file = "greenlet-3.2.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f10fd42b5ee276335863712fa3da6608e93f70629c631bf77145021600abc23c"},
+    {file = "greenlet-3.2.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c8c9e331e58180d0d83c5b7999255721b725913ff6bc6cf39fa2a45841a4fd4b"},
+    {file = "greenlet-3.2.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58b97143c9cc7b86fc458f215bd0932f1757ce649e05b640fea2e79b54cedb31"},
+    {file = "greenlet-3.2.4-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c2ca18a03a8cfb5b25bc1cbe20f3d9a4c80d8c3b13ba3df49ac3961af0b1018d"},
+    {file = "greenlet-3.2.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:9fe0a28a7b952a21e2c062cd5756d34354117796c6d9215a87f55e38d15402c5"},
+    {file = "greenlet-3.2.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8854167e06950ca75b898b104b63cc646573aa5fef1353d4508ecdd1ee76254f"},
+    {file = "greenlet-3.2.4-cp310-cp310-win_amd64.whl", hash = "sha256:73f49b5368b5359d04e18d15828eecc1806033db5233397748f4ca813ff1056c"},
+    {file = "greenlet-3.2.4-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:96378df1de302bc38e99c3a9aa311967b7dc80ced1dcc6f171e99842987882a2"},
+    {file = "greenlet-3.2.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1ee8fae0519a337f2329cb78bd7a8e128ec0f881073d43f023c7b8d4831d5246"},
+    {file = "greenlet-3.2.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:94abf90142c2a18151632371140b3dba4dee031633fe614cb592dbb6c9e17bc3"},
+    {file = "greenlet-3.2.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:4d1378601b85e2e5171b99be8d2dc85f594c79967599328f95c1dc1a40f1c633"},
+    {file = "greenlet-3.2.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0db5594dce18db94f7d1650d7489909b57afde4c580806b8d9203b6e79cdc079"},
+    {file = "greenlet-3.2.4-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2523e5246274f54fdadbce8494458a2ebdcdbc7b802318466ac5606d3cded1f8"},
+    {file = "greenlet-3.2.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:1987de92fec508535687fb807a5cea1560f6196285a4cde35c100b8cd632cc52"},
+    {file = "greenlet-3.2.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:55e9c5affaa6775e2c6b67659f3a71684de4c549b3dd9afca3bc773533d284fa"},
+    {file = "greenlet-3.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:9c40adce87eaa9ddb593ccb0fa6a07caf34015a29bf8d344811665b573138db9"},
+    {file = "greenlet-3.2.4-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3b67ca49f54cede0186854a008109d6ee71f66bd57bb36abd6d0a0267b540cdd"},
+    {file = "greenlet-3.2.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddf9164e7a5b08e9d22511526865780a576f19ddd00d62f8a665949327fde8bb"},
+    {file = "greenlet-3.2.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f28588772bb5fb869a8eb331374ec06f24a83a9c25bfa1f38b6993afe9c1e968"},
+    {file = "greenlet-3.2.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:5c9320971821a7cb77cfab8d956fa8e39cd07ca44b6070db358ceb7f8797c8c9"},
+    {file = "greenlet-3.2.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c60a6d84229b271d44b70fb6e5fa23781abb5d742af7b808ae3f6efd7c9c60f6"},
+    {file = "greenlet-3.2.4-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b3812d8d0c9579967815af437d96623f45c0f2ae5f04e366de62a12d83a8fb0"},
+    {file = "greenlet-3.2.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:abbf57b5a870d30c4675928c37278493044d7c14378350b3aa5d484fa65575f0"},
+    {file = "greenlet-3.2.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:20fb936b4652b6e307b8f347665e2c615540d4b42b3b4c8a321d8286da7e520f"},
+    {file = "greenlet-3.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:a7d4e128405eea3814a12cc2605e0e6aedb4035bf32697f72deca74de4105e02"},
+    {file = "greenlet-3.2.4-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:1a921e542453fe531144e91e1feedf12e07351b1cf6c9e8a3325ea600a715a31"},
+    {file = "greenlet-3.2.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd3c8e693bff0fff6ba55f140bf390fa92c994083f838fece0f63be121334945"},
+    {file = "greenlet-3.2.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:710638eb93b1fa52823aa91bf75326f9ecdfd5e0466f00789246a5280f4ba0fc"},
+    {file = "greenlet-3.2.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c5111ccdc9c88f423426df3fd1811bfc40ed66264d35aa373420a34377efc98a"},
+    {file = "greenlet-3.2.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76383238584e9711e20ebe14db6c88ddcedc1829a9ad31a584389463b5aa504"},
+    {file = "greenlet-3.2.4-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23768528f2911bcd7e475210822ffb5254ed10d71f4028387e5a99b4c6699671"},
+    {file = "greenlet-3.2.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:00fadb3fedccc447f517ee0d3fd8fe49eae949e1cd0f6a611818f4f6fb7dc83b"},
+    {file = "greenlet-3.2.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:d25c5091190f2dc0eaa3f950252122edbbadbb682aa7b1ef2f8af0f8c0afefae"},
+    {file = "greenlet-3.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:554b03b6e73aaabec3745364d6239e9e012d64c68ccd0b8430c64ccc14939a8b"},
+    {file = "greenlet-3.2.4-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:49a30d5fda2507ae77be16479bdb62a660fa51b1eb4928b524975b3bde77b3c0"},
+    {file = "greenlet-3.2.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:299fd615cd8fc86267b47597123e3f43ad79c9d8a22bebdce535e53550763e2f"},
+    {file = "greenlet-3.2.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c17b6b34111ea72fc5a4e4beec9711d2226285f0386ea83477cbb97c30a3f3a5"},
+    {file = "greenlet-3.2.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b4a1870c51720687af7fa3e7cda6d08d801dae660f75a76f3845b642b4da6ee1"},
+    {file = "greenlet-3.2.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:061dc4cf2c34852b052a8620d40f36324554bc192be474b9e9770e8c042fd735"},
+    {file = "greenlet-3.2.4-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44358b9bf66c8576a9f57a590d5f5d6e72fa4228b763d0e43fee6d3b06d3a337"},
+    {file = "greenlet-3.2.4-cp314-cp314-win_amd64.whl", hash = "sha256:e37ab26028f12dbb0ff65f29a8d3d44a765c61e729647bf2ddfbbed621726f01"},
+    {file = "greenlet-3.2.4-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:b6a7c19cf0d2742d0809a4c05975db036fdff50cd294a93632d6a310bf9ac02c"},
+    {file = "greenlet-3.2.4-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:27890167f55d2387576d1f41d9487ef171849ea0359ce1510ca6e06c8bece11d"},
+    {file = "greenlet-3.2.4-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:18d9260df2b5fbf41ae5139e1be4e796d99655f023a636cd0e11e6406cca7d58"},
+    {file = "greenlet-3.2.4-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:671df96c1f23c4a0d4077a325483c1503c96a1b7d9db26592ae770daa41233d4"},
+    {file = "greenlet-3.2.4-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:16458c245a38991aa19676900d48bd1a6f2ce3e16595051a4db9d012154e8433"},
+    {file = "greenlet-3.2.4-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9913f1a30e4526f432991f89ae263459b1c64d1608c0d22a5c79c287b3c70df"},
+    {file = "greenlet-3.2.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b90654e092f928f110e0007f572007c9727b5265f7632c2fa7415b4689351594"},
+    {file = "greenlet-3.2.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:81701fd84f26330f0d5f4944d4e92e61afe6319dcd9775e39396e39d7c3e5f98"},
+    {file = "greenlet-3.2.4-cp39-cp39-win32.whl", hash = "sha256:65458b409c1ed459ea899e939f0e1cdb14f58dbc803f2f93c5eab5694d32671b"},
+    {file = "greenlet-3.2.4-cp39-cp39-win_amd64.whl", hash = "sha256:d2e685ade4dafd447ede19c31277a224a239a0a1a4eca4e6390efedf20260cfb"},
+    {file = "greenlet-3.2.4.tar.gz", hash = "sha256:0dca0d95ff849f9a364385f36ab49f50065d76964944638be9691e1832e9f86d"},
+]
+
+[package.extras]
+docs = ["Sphinx", "furo"]
+test = ["objgraph", "psutil", "setuptools"]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@ -1260,6 +1350,123 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "jiter"
+version = "0.11.1"
+description = "Fast iterable JSON parser."
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "jiter-0.11.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:ed58841a491bbbf3f7c55a6b68fff568439ab73b2cce27ace0e169057b5851df"},
+    {file = "jiter-0.11.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:499beb9b2d7e51d61095a8de39ebcab1d1778f2a74085f8305a969f6cee9f3e4"},
+    {file = "jiter-0.11.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b87b2821795e28cc990939b68ce7a038edea680a24910bd68a79d54ff3f03c02"},
+    {file = "jiter-0.11.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:83f6fa494d8bba14ab100417c80e70d32d737e805cb85be2052d771c76fcd1f8"},
+    {file = "jiter-0.11.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5fbc6aea1daa2ec6f5ed465f0c5e7b0607175062ceebbea5ca70dd5ddab58083"},
+    {file = "jiter-0.11.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:302288e2edc43174bb2db838e94688d724f9aad26c5fb9a74f7a5fb427452a6a"},
+    {file = "jiter-0.11.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85db563fe3b367bb568af5d29dea4d4066d923b8e01f3417d25ebecd958de815"},
+    {file = "jiter-0.11.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f1c1ba2b6b22f775444ef53bc2d5778396d3520abc7b2e1da8eb0c27cb3ffb10"},
+    {file = "jiter-0.11.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:523be464b14f8fd0cc78da6964b87b5515a056427a2579f9085ce30197a1b54a"},
+    {file = "jiter-0.11.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:25b99b3f04cd2a38fefb22e822e35eb203a2cd37d680dbbc0c0ba966918af336"},
+    {file = "jiter-0.11.1-cp310-cp310-win32.whl", hash = "sha256:47a79e90545a596bb9104109777894033347b11180d4751a216afef14072dbe7"},
+    {file = "jiter-0.11.1-cp310-cp310-win_amd64.whl", hash = "sha256:cace75621ae9bd66878bf69fbd4dfc1a28ef8661e0c2d0eb72d3d6f1268eddf5"},
+    {file = "jiter-0.11.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:9b0088ff3c374ce8ce0168523ec8e97122ebb788f950cf7bb8e39c7dc6a876a2"},
+    {file = "jiter-0.11.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:74433962dd3c3090655e02e461267095d6c84f0741c7827de11022ef8d7ff661"},
+    {file = "jiter-0.11.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d98030e345e6546df2cc2c08309c502466c66c4747b043f1a0d415fada862b8"},
+    {file = "jiter-0.11.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1d6db0b2e788db46bec2cf729a88b6dd36959af2abd9fa2312dfba5acdd96dcb"},
+    {file = "jiter-0.11.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55678fbbda261eafe7289165dd2ddd0e922df5f9a1ae46d7c79a5a15242bd7d1"},
+    {file = "jiter-0.11.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a6b74fae8e40497653b52ce6ca0f1b13457af769af6fb9c1113efc8b5b4d9be"},
+    {file = "jiter-0.11.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a55a453f8b035eb4f7852a79a065d616b7971a17f5e37a9296b4b38d3b619e4"},
+    {file = "jiter-0.11.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2638148099022e6bdb3f42904289cd2e403609356fb06eb36ddec2d50958bc29"},
+    {file = "jiter-0.11.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:252490567a5d990986f83b95a5f1ca1bf205ebd27b3e9e93bb7c2592380e29b9"},
+    {file = "jiter-0.11.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d431d52b0ca2436eea6195f0f48528202100c7deda354cb7aac0a302167594d5"},
+    {file = "jiter-0.11.1-cp311-cp311-win32.whl", hash = "sha256:db6f41e40f8bae20c86cb574b48c4fd9f28ee1c71cb044e9ec12e78ab757ba3a"},
+    {file = "jiter-0.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:0cc407b8e6cdff01b06bb80f61225c8b090c3df108ebade5e0c3c10993735b19"},
+    {file = "jiter-0.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:fe04ea475392a91896d1936367854d346724a1045a247e5d1c196410473b8869"},
+    {file = "jiter-0.11.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:c92148eec91052538ce6823dfca9525f5cfc8b622d7f07e9891a280f61b8c96c"},
+    {file = "jiter-0.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ecd4da91b5415f183a6be8f7158d127bdd9e6a3174138293c0d48d6ea2f2009d"},
+    {file = "jiter-0.11.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7e3ac25c00b9275684d47aa42febaa90a9958e19fd1726c4ecf755fbe5e553b"},
+    {file = "jiter-0.11.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:57d7305c0a841858f866cd459cd9303f73883fb5e097257f3d4a3920722c69d4"},
+    {file = "jiter-0.11.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e86fa10e117dce22c547f31dd6d2a9a222707d54853d8de4e9a2279d2c97f239"},
+    {file = "jiter-0.11.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae5ef1d48aec7e01ee8420155d901bb1d192998fa811a65ebb82c043ee186711"},
+    {file = "jiter-0.11.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb68e7bf65c990531ad8715e57d50195daf7c8e6f1509e617b4e692af1108939"},
+    {file = "jiter-0.11.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43b30c8154ded5845fa454ef954ee67bfccce629b2dea7d01f795b42bc2bda54"},
+    {file = "jiter-0.11.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:586cafbd9dd1f3ce6a22b4a085eaa6be578e47ba9b18e198d4333e598a91db2d"},
+    {file = "jiter-0.11.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:677cc2517d437a83bb30019fd4cf7cad74b465914c56ecac3440d597ac135250"},
+    {file = "jiter-0.11.1-cp312-cp312-win32.whl", hash = "sha256:fa992af648fcee2b850a3286a35f62bbbaeddbb6dbda19a00d8fbc846a947b6e"},
+    {file = "jiter-0.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:88b5cae9fa51efeb3d4bd4e52bfd4c85ccc9cac44282e2a9640893a042ba4d87"},
+    {file = "jiter-0.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:9a6cae1ab335551917f882f2c3c1efe7617b71b4c02381e4382a8fc80a02588c"},
+    {file = "jiter-0.11.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:71b6a920a5550f057d49d0e8bcc60945a8da998019e83f01adf110e226267663"},
+    {file = "jiter-0.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b3de72e925388453a5171be83379549300db01284f04d2a6f244d1d8de36f94"},
+    {file = "jiter-0.11.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc19dd65a2bd3d9c044c5b4ebf657ca1e6003a97c0fc10f555aa4f7fb9821c00"},
+    {file = "jiter-0.11.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d58faaa936743cd1464540562f60b7ce4fd927e695e8bc31b3da5b914baa9abd"},
+    {file = "jiter-0.11.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:902640c3103625317291cb73773413b4d71847cdf9383ba65528745ff89f1d14"},
+    {file = "jiter-0.11.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:30405f726e4c2ed487b176c09f8b877a957f535d60c1bf194abb8dadedb5836f"},
+    {file = "jiter-0.11.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3217f61728b0baadd2551844870f65219ac4a1285d5e1a4abddff3d51fdabe96"},
+    {file = "jiter-0.11.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b1364cc90c03a8196f35f396f84029f12abe925415049204446db86598c8b72c"},
+    {file = "jiter-0.11.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:53a54bf8e873820ab186b2dca9f6c3303f00d65ae5e7b7d6bda1b95aa472d646"},
+    {file = "jiter-0.11.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7e29aca023627b0e0c2392d4248f6414d566ff3974fa08ff2ac8dbb96dfee92a"},
+    {file = "jiter-0.11.1-cp313-cp313-win32.whl", hash = "sha256:f153e31d8bca11363751e875c0a70b3d25160ecbaee7b51e457f14498fb39d8b"},
+    {file = "jiter-0.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:f773f84080b667c69c4ea0403fc67bb08b07e2b7ce1ef335dea5868451e60fed"},
+    {file = "jiter-0.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:635ecd45c04e4c340d2187bcb1cea204c7cc9d32c1364d251564bf42e0e39c2d"},
+    {file = "jiter-0.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d892b184da4d94d94ddb4031296931c74ec8b325513a541ebfd6dfb9ae89904b"},
+    {file = "jiter-0.11.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa22c223a3041dacb2fcd37c70dfd648b44662b4a48e242592f95bda5ab09d58"},
+    {file = "jiter-0.11.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:330e8e6a11ad4980cd66a0f4a3e0e2e0f646c911ce047014f984841924729789"},
+    {file = "jiter-0.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:09e2e386ebf298547ca3a3704b729471f7ec666c2906c5c26c1a915ea24741ec"},
+    {file = "jiter-0.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:fe4a431c291157e11cee7c34627990ea75e8d153894365a3bc84b7a959d23ca8"},
+    {file = "jiter-0.11.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:0fa1f70da7a8a9713ff8e5f75ec3f90c0c870be6d526aa95e7c906f6a1c8c676"},
+    {file = "jiter-0.11.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:569ee559e5046a42feb6828c55307cf20fe43308e3ae0d8e9e4f8d8634d99944"},
+    {file = "jiter-0.11.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f69955fa1d92e81987f092b233f0be49d4c937da107b7f7dcf56306f1d3fcce9"},
+    {file = "jiter-0.11.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:090f4c9d4a825e0fcbd0a2647c9a88a0f366b75654d982d95a9590745ff0c48d"},
+    {file = "jiter-0.11.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbf3d8cedf9e9d825233e0dcac28ff15c47b7c5512fdfe2e25fd5bbb6e6b0cee"},
+    {file = "jiter-0.11.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2aa9b1958f9c30d3d1a558b75f0626733c60eb9b7774a86b34d88060be1e67fe"},
+    {file = "jiter-0.11.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e42d1ca16590b768c5e7d723055acd2633908baacb3628dd430842e2e035aa90"},
+    {file = "jiter-0.11.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5db4c2486a023820b701a17aec9c5a6173c5ba4393f26662f032f2de9c848b0f"},
+    {file = "jiter-0.11.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:4573b78777ccfac954859a6eff45cbd9d281d80c8af049d0f1a3d9fc323d5c3a"},
+    {file = "jiter-0.11.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:7593ac6f40831d7961cb67633c39b9fef6689a211d7919e958f45710504f52d3"},
+    {file = "jiter-0.11.1-cp314-cp314-win32.whl", hash = "sha256:87202ec6ff9626ff5f9351507def98fcf0df60e9a146308e8ab221432228f4ea"},
+    {file = "jiter-0.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:a5dd268f6531a182c89d0dd9a3f8848e86e92dfff4201b77a18e6b98aa59798c"},
+    {file = "jiter-0.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:5d761f863f912a44748a21b5c4979c04252588ded8d1d2760976d2e42cd8d991"},
+    {file = "jiter-0.11.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2cc5a3965285ddc33e0cab933e96b640bc9ba5940cea27ebbbf6695e72d6511c"},
+    {file = "jiter-0.11.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b572b3636a784c2768b2342f36a23078c8d3aa6d8a30745398b1bab58a6f1a8"},
+    {file = "jiter-0.11.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ad93e3d67a981f96596d65d2298fe8d1aa649deb5374a2fb6a434410ee11915e"},
+    {file = "jiter-0.11.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a83097ce379e202dcc3fe3fc71a16d523d1ee9192c8e4e854158f96b3efe3f2f"},
+    {file = "jiter-0.11.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7042c51e7fbeca65631eb0c332f90c0c082eab04334e7ccc28a8588e8e2804d9"},
+    {file = "jiter-0.11.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a68d679c0e47649a61df591660507608adc2652442de7ec8276538ac46abe08"},
+    {file = "jiter-0.11.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a1b0da75dbf4b6ec0b3c9e604d1ee8beaf15bc046fff7180f7d89e3cdbd3bb51"},
+    {file = "jiter-0.11.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:69dd514bf0fa31c62147d6002e5ca2b3e7ef5894f5ac6f0a19752385f4e89437"},
+    {file = "jiter-0.11.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:bb31ac0b339efa24c0ca606febd8b77ef11c58d09af1b5f2be4c99e907b11111"},
+    {file = "jiter-0.11.1-cp314-cp314t-win32.whl", hash = "sha256:b2ce0d6156a1d3ad41da3eec63b17e03e296b78b0e0da660876fccfada86d2f7"},
+    {file = "jiter-0.11.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f4db07d127b54c4a2d43b4cf05ff0193e4f73e0dd90c74037e16df0b29f666e1"},
+    {file = "jiter-0.11.1-cp314-cp314t-win_arm64.whl", hash = "sha256:28e4fdf2d7ebfc935523e50d1efa3970043cfaa161674fe66f9642409d001dfe"},
+    {file = "jiter-0.11.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:baa99c8db49467527658bb479857344daf0a14dff909b7f6714579ac439d1253"},
+    {file = "jiter-0.11.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:860fe55fa3b01ad0edf2adde1098247ff5c303d0121f9ce028c03d4f88c69502"},
+    {file = "jiter-0.11.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:173dd349d99b6feaf5a25a6fbcaf3489a6f947708d808240587a23df711c67db"},
+    {file = "jiter-0.11.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:14ac1dca837514cc946a6ac2c4995d9695303ecc754af70a3163d057d1a444ab"},
+    {file = "jiter-0.11.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69af47de5f93a231d5b85f7372d3284a5be8edb4cc758f006ec5a1406965ac5e"},
+    {file = "jiter-0.11.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:685f8b3abd3bbd3e06e4dfe2429ff87fd5d7a782701151af99b1fcbd80e31b2b"},
+    {file = "jiter-0.11.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d04afa2d4e5526e54ae8a58feea953b1844bf6e3526bc589f9de68e86d0ea01"},
+    {file = "jiter-0.11.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1e92b927259035b50d8e11a8fdfe0ebd014d883e4552d37881643fa289a4bcf1"},
+    {file = "jiter-0.11.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:e7bd8be4fad8d4c5558b7801770cd2da6c072919c6f247cc5336edb143f25304"},
+    {file = "jiter-0.11.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:121381a77a3c85987f3eba0d30ceaca9116f7463bedeec2fa79b2e7286b89b60"},
+    {file = "jiter-0.11.1-cp39-cp39-win32.whl", hash = "sha256:160225407f6dfabdf9be1b44e22f06bc293a78a28ffa4347054698bd712dad06"},
+    {file = "jiter-0.11.1-cp39-cp39-win_amd64.whl", hash = "sha256:028e0d59bcdfa1079f8df886cdaefc6f515c27a5288dec956999260c7e4a7cfd"},
+    {file = "jiter-0.11.1-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:e642b5270e61dd02265866398707f90e365b5db2eb65a4f30c789d826682e1f6"},
+    {file = "jiter-0.11.1-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:464ba6d000585e4e2fd1e891f31f1231f497273414f5019e27c00a4b8f7a24ad"},
+    {file = "jiter-0.11.1-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:055568693ab35e0bf3a171b03bb40b2dcb10352359e0ab9b5ed0da2bf1eb6f6f"},
+    {file = "jiter-0.11.1-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0c69ea798d08a915ba4478113efa9e694971e410056392f4526d796f136d3fa"},
+    {file = "jiter-0.11.1-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:0d4d6993edc83cf75e8c6828a8d6ce40a09ee87e38c7bfba6924f39e1337e21d"},
+    {file = "jiter-0.11.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f78d151c83a87a6cf5461d5ee55bc730dd9ae227377ac6f115b922989b95f838"},
+    {file = "jiter-0.11.1-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9022974781155cd5521d5cb10997a03ee5e31e8454c9d999dcdccd253f2353f"},
+    {file = "jiter-0.11.1-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18c77aaa9117510d5bdc6a946baf21b1f0cfa58ef04d31c8d016f206f2118960"},
+    {file = "jiter-0.11.1.tar.gz", hash = "sha256:849dcfc76481c0ea0099391235b7ca97d7279e0fa4c86005457ac7c88e8b76dc"},
+]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "linkify-it-py"
 version = "2.0.3"
@ -1743,6 +1950,23 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "nanoid"
+version = "2.0.0"
+description = "A tiny, secure, URL-friendly, unique string ID generator for Python"
+optional = false
+python-versions = "*"
+groups = ["main"]
+files = [
+    {file = "nanoid-2.0.0-py3-none-any.whl", hash = "sha256:90aefa650e328cffb0893bbd4c236cfd44c48bc1f2d0b525ecc53c3187b653bb"},
+    {file = "nanoid-2.0.0.tar.gz", hash = "sha256:5a80cad5e9c6e9ae3a41fa2fb34ae189f7cb420b2a5d8f82bd9d23466e4efa68"},
+]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "nepattern"
 version = "0.7.7"
@ -2110,6 +2334,70 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "openai"
+version = "2.7.1"
+description = "The official Python library for the openai API"
+optional = false
+python-versions = ">=3.8"
+groups = ["main"]
+files = [
+    {file = "openai-2.7.1-py3-none-any.whl", hash = "sha256:2f2530354d94c59c614645a4662b9dab0a5b881c5cd767a8587398feac0c9021"},
+    {file = "openai-2.7.1.tar.gz", hash = "sha256:df4d4a3622b2df3475ead8eb0fbb3c27fd1c070fa2e55d778ca4f40e0186c726"},
+]
+
+[package.dependencies]
+anyio = ">=3.5.0,<5"
+distro = ">=1.7.0,<2"
+httpx = ">=0.23.0,<1"
+jiter = ">=0.10.0,<1"
+pydantic = ">=1.9.0,<3"
+sniffio = "*"
+tqdm = ">4"
+typing-extensions = ">=4.11,<5"
+
+[package.extras]
+aiohttp = ["aiohttp", "httpx-aiohttp (>=0.1.9)"]
+datalib = ["numpy (>=1)", "pandas (>=1.2.3)", "pandas-stubs (>=1.1.0.11)"]
+realtime = ["websockets (>=13,<16)"]
+voice-helpers = ["numpy (>=2.0.2)", "sounddevice (>=0.5.1)"]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
+[[package]]
+name = "opencc"
+version = "1.1.9"
+description = "Conversion between Traditional and Simplified Chinese"
+optional = false
+python-versions = "*"
+groups = ["main"]
+files = [
+    {file = "OpenCC-1.1.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a33941dd4cb67457e6f44dfe36dddc30a602363a4f6a29b41d79b062b332c094"},
+    {file = "OpenCC-1.1.9-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:92769f9a60301574c73096f9ab8a9060fe0d13a9f8266735d82a2a3a92adbd26"},
+    {file = "OpenCC-1.1.9-cp310-cp310-win_amd64.whl", hash = "sha256:84e35e5ecfad445a64c0dcd6567d9e9f3a6aed9a6ffd89cdbc071f36cb9e089e"},
+    {file = "OpenCC-1.1.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3fb7c84f7c182cb5208e7bc1c104b817a3ca1a8fe111d4d19816be0d6e1ab396"},
+    {file = "OpenCC-1.1.9-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:64994c68796d93cdba42f37e0c073fb8ed6f9d6707232be0ba84f24dc5a36bbb"},
+    {file = "OpenCC-1.1.9-cp311-cp311-win_amd64.whl", hash = "sha256:9f6a1413ca2ff490e65a55822e4cae8c3f104bfab46355288de4893a14470fbb"},
+    {file = "OpenCC-1.1.9-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:48bc3e37942b91a9cf51f525631792f79378e5332bdba9e10c05f6e7fe9036ca"},
+    {file = "OpenCC-1.1.9-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:1c5d1489bdaf9dc2865f0ea30eb565093253e73c1868d9c19554c8a044b545d4"},
+    {file = "OpenCC-1.1.9-cp312-cp312-win_amd64.whl", hash = "sha256:64f8d22c8505b65e8ee2d6e73241cbc92785d38b3c93885b423d7c4fcd31c679"},
+    {file = "OpenCC-1.1.9-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:f4267b66ed6e656b5d8199f94e9673950ac39d49ebaf0e7927330801f06f038f"},
+    {file = "OpenCC-1.1.9-cp38-cp38-manylinux2014_x86_64.whl", hash = "sha256:c6d5f9756ed08e67de36c53dc4d8f0bdc72889d6f57a8fc4d8b073d99c58d4dc"},
+    {file = "OpenCC-1.1.9-cp38-cp38-win_amd64.whl", hash = "sha256:a6c2650bd3d6a9e3c31fc2057e0f36122c9507af1661627542f618c97d420293"},
+    {file = "OpenCC-1.1.9-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4d66473405c2e360ef346fe1625f201f3f3c4adbb16d5c1c7749a150ae42d875"},
+    {file = "OpenCC-1.1.9-cp39-cp39-manylinux2014_x86_64.whl", hash = "sha256:436c43e0855b4f9c9e4fd1191e8ac638e9d9f2c7e2d5753952e6e31aa231d36c"},
+    {file = "OpenCC-1.1.9-cp39-cp39-win_amd64.whl", hash = "sha256:b4c36d6974afd94b444ad5ad17364f40d228092ce89b86e46653f7ff38075201"},
+    {file = "opencc-1.1.9.tar.gz", hash = "sha256:8ad72283732951303390fae33a1ceda98ac9b03368a8f2912edc934d74077e4a"},
+]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "opencv-python-headless"
 version = "4.12.0.88"
@ -2287,6 +2575,33 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "playwright"
+version = "1.55.0"
+description = "A high-level API to automate web browsers"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "playwright-1.55.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:d7da108a95001e412effca4f7610de79da1637ccdf670b1ae3fdc08b9694c034"},
+    {file = "playwright-1.55.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:8290cf27a5d542e2682ac274da423941f879d07b001f6575a5a3a257b1d4ba1c"},
+    {file = "playwright-1.55.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:25b0d6b3fd991c315cca33c802cf617d52980108ab8431e3e1d37b5de755c10e"},
+    {file = "playwright-1.55.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:c6d4d8f6f8c66c483b0835569c7f0caa03230820af8e500c181c93509c92d831"},
+    {file = "playwright-1.55.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29a0777c4ce1273acf90c87e4ae2fe0130182100d99bcd2ae5bf486093044838"},
+    {file = "playwright-1.55.0-py3-none-win32.whl", hash = "sha256:29e6d1558ad9d5b5c19cbec0a72f6a2e35e6353cd9f262e22148685b86759f90"},
+    {file = "playwright-1.55.0-py3-none-win_amd64.whl", hash = "sha256:7eb5956473ca1951abb51537e6a0da55257bb2e25fc37c2b75af094a5c93736c"},
+    {file = "playwright-1.55.0-py3-none-win_arm64.whl", hash = "sha256:012dc89ccdcbd774cdde8aeee14c08e0dd52ddb9135bf10e9db040527386bd76"},
+]
+
+[package.dependencies]
+greenlet = ">=3.1.1,<4.0.0"
+pyee = ">=13,<14"
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "propcache"
 version = "0.3.2"
@ -2715,6 +3030,29 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "pyee"
+version = "13.0.0"
+description = "A rough port of Node.js's EventEmitter to Python with a few tricks of its own"
+optional = false
+python-versions = ">=3.8"
+groups = ["main"]
+files = [
+    {file = "pyee-13.0.0-py3-none-any.whl", hash = "sha256:48195a3cddb3b1515ce0695ed76036b5ccc2ef3a9f963ff9f77aec0139845498"},
+    {file = "pyee-13.0.0.tar.gz", hash = "sha256:b391e3c5a434d1f5118a25615001dbc8f669cf410ab67d04c4d4e07c55481c37"},
+]
+
+[package.dependencies]
+typing-extensions = "*"
+
+[package.extras]
+dev = ["black", "build", "flake8", "flake8-black", "isort", "jupyter-console", "mkdocs", "mkdocs-include-markdown-plugin", "mkdocstrings[python]", "mypy", "pytest", "pytest-asyncio ; python_version >= \"3.4\"", "pytest-trio ; python_version >= \"3.7\"", "sphinx", "toml", "tox", "trio", "trio ; python_version > \"3.6\"", "trio-typing ; python_version > \"3.6\"", "twine", "twisted", "validate-pyproject[all]"]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "pygments"
 version = "2.19.2"
@ -3216,6 +3554,33 @@ type = "legacy"
 url = "https://pypi.tuna.tsinghua.edu.cn/simple"
 reference = "mirrors"

+[[package]]
+name = "tqdm"
+version = "4.67.1"
+description = "Fast, Extensible Progress Meter"
+optional = false
+python-versions = ">=3.7"
+groups = ["main"]
+files = [
+    {file = "tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2"},
+    {file = "tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
+[package.extras]
+dev = ["nbval", "pytest (>=6)", "pytest-asyncio (>=0.24)", "pytest-cov", "pytest-timeout"]
+discord = ["requests"]
+notebook = ["ipywidgets (>=6)"]
+slack = ["slack-sdk"]
+telegram = ["requests"]
+
+[package.source]
+type = "legacy"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+reference = "mirrors"
+
 [[package]]
 name = "typing-extensions"
 version = "4.15.0"
@ -3807,4 +4172,4 @@ reference = "mirrors"
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.12,<4.0"
-content-hash = "78a299c64ba07999fae807300b10a1c622d45b8b387aded5a34d17cf5550e777"
+content-hash = "dcb6567ccb9eb6357179dd8b8eaa5fb69373cef0e17d3a49c7c895d289c0d642"
--- a/pyproject.toml
+++ b/pyproject.toml
@ -24,6 +24,10 @@ dependencies = [
  "nonebot-plugin-analysis-bilibili (>=2.8.1,<3.0.0)",
  "qrcode (>=8.2,<9.0)",
  "ptimeparse (>=0.2.1,<0.3.0)",
+  "nanoid (>=2.0.0,<3.0.0)",
+  "opencc (>=1.1.9,<2.0.0)",
+  "playwright (>=1.55.0,<2.0.0)",
+  "openai (>=2.7.1,<3.0.0)",
 ]

 [build-system]
--- a/scripts/watch_filter.py
+++ b/scripts/watch_filter.py
@ -0,0 +1,13 @@
+from pathlib import Path
+from watchfiles import Change
+
+
+base = Path(__file__).parent.parent.absolute()
+
+
+def filter(change: Change, path: str) -> bool:
+    if "__pycache__" in path:
+        return False
+    if Path(path).absolute().is_relative_to(base / "data"):
+        return False
+    return True
Author	SHA1	Message	Date
MixBadGun	03900f4416	成语接龙接入 LLM 和 MarkDown、LaTeX 接入 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-11-09 23:12:04 +08:00
钟晓帕	62f4195e46	Merge pull request '让豆包水印使用相对大小' (#47 ) from feature/doubao-watermark into master All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details Reviewed-on: #47	2025-11-07 21:17:16 +08:00
钟晓帕	751297e3bc	Merge branch 'master' into feature/doubao-watermark	2025-11-07 21:17:09 +08:00
passthem	b450998f3f	让豆包水印使用相对大小	2025-11-07 21:15:19 +08:00
钟晓帕	ae6297b98d	Merge pull request '添加豆包水印' (#46 ) from feature/doubao-watermark into master All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details Reviewed-on: #46	2025-11-07 19:18:41 +08:00
passthem	dacae29054	添加豆包水印	2025-11-07 19:18:24 +08:00
钟晓帕	8acb546c6a	Merge pull request '让浏览器等久一点' (#42 ) from feature/konaweb into master All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #42	2025-11-07 02:41:49 +08:00
passthem	49e0914416	让浏览器等久一点	2025-11-07 02:41:33 +08:00
钟晓帕	5b74c78ec3	Merge pull request '更新 web_render 模块并支持前端渲染' (#41 ) from feature/konaweb into master All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details Reviewed-on: #41	2025-11-07 02:31:06 +08:00
passthem	c911410276	更新 web_render 模块并支持前端渲染	2025-11-07 02:30:46 +08:00
钟晓帕	37ca4bf11f	Merge pull request '西多说 by 姬嵇' (#40 ) from feature/memepack/kiosay into master All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #40	2025-11-06 23:35:48 +08:00
passthem	8ef084c22a	西多说 by 姬嵇	2025-11-06 23:35:20 +08:00
钟晓帕	57f0cd728f	Merge pull request '使用 Discord Proxy 选项来下载图片' (#39 ) from bugfix/discord-image-download into master All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #39	2025-11-06 00:12:32 +08:00
passthem	627a29f57e	使用 Discord Proxy 选项来下载图片	2025-11-06 00:12:08 +08:00
钟晓帕	650c500f47	Merge pull request '监听更广泛的 Discord 消息' (#38 ) from bugfix/discord-image-download into master All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #38	2025-11-06 00:06:49 +08:00
passthem	86acbe51e9	Merge remote-tracking branch 'origin/master' into bugfix/discord-image-download	2025-11-06 00:05:20 +08:00
passthem	4900a7e0ad	Merge branch 'bugfix/discord-image-download' of ssh://gitea.service.jazzwhom.top:2221/mttu-developers/konabot into bugfix/discord-image-download	2025-11-06 00:05:08 +08:00
passthem	34da08126b	监听更广泛的 event	2025-11-06 00:04:57 +08:00
钟晓帕	00f416c8bc	Merge pull request '改为使用 proxy url' (#37 ) from bugfix/discord-image-download into master All checks were successful continuous-integration/drone/push Build is passing Details Reviewed-on: #37	2025-11-05 23:59:54 +08:00
钟晓帕	9c7d0a4486	Merge branch 'master' into bugfix/discord-image-download	2025-11-05 23:59:43 +08:00
passthem	e3b9d6723f	改为使用 proxy url	2025-11-05 23:58:55 +08:00
钟晓帕	ef80399a90	Merge pull request '尝试解决 Discord 无法读取图片的问题' (#30 ) from bugfix/discord-image-download into master All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details Reviewed-on: #30	2025-11-05 23:17:25 +08:00
passthem	bfbfa9d9be	尝试解决这个问题	2025-11-05 23:15:30 +08:00
钟晓帕	6b7be4d3b0	Merge pull request '添加基础的 LLM 支持' (#29 ) from feature/LLM-base into master Reviewed-on: #29	2025-11-05 20:40:40 +08:00
passthem	7c19c52d9f	添加关于 LLM 配置的文档	2025-11-05 20:36:51 +08:00
passthem	a5f4ae9bdc	添加基础的 LLM 支持	2025-11-05 18:40:13 +08:00
Passthem	9320815d3f	修复无法更改图片的问题 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-11-01 20:59:58 +08:00
Passthem	795300cb83	在每日答题情况添加记录点显示 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-11-01 18:42:47 +08:00
Passthem	0231aa04f4	添加中间答案功能 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-11-01 18:29:10 +08:00
Passthem	01fe33eb9f	部分解耦了 konaph 的一些层	2025-11-01 17:52:05 +08:00
Passthem	adfbac7d90	支持正义 utf-8	2025-11-01 13:48:48 +08:00
Passthem	994c1412da	为 Watchfiles 添加更可配置的过滤器 All checks were successful continuous-integration/drone/push Build is passing Details	2025-11-01 12:40:01 +08:00
passthem	8780dfec6f	在 Tag 成功后也进行 ntfy 通知 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-30 16:52:55 +08:00
passthem	490d807e7a	添加一些对题解提交空格的情况判定 All checks were successful continuous-integration/drone/push Build is passing Details	2025-10-30 16:48:09 +08:00
passthem	fa208199ab	我不小心多加了一个 s All checks were successful continuous-integration/drone/push Build is passing Details	2025-10-29 22:01:13 +08:00
passthem	38a17f42a3	添加 Ntfy 构建消息的报告 Some checks failed continuous-integration/drone/push Build is failing Details	2025-10-29 21:59:11 +08:00
passthem	37179fc4d7	添加显示提交记录的指令 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-27 15:31:12 +08:00
passthem	56e0aabbf3	优化 UX，添加 preview 指令	2025-10-27 15:20:40 +08:00
MixBadGun	ce2b7fd6f6	空调调温优化与排行榜，浏览器添加本地HTML支持 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-27 00:04:27 +08:00
MixBadGun	b28f8f85a2	Merge branch 'master' of https://gitea.service.jazzwhom.top/mttu-developers/konabot	2025-10-26 22:49:04 +08:00
passthem	0acffea86d	添加排行榜，优化 UX All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-26 12:45:29 +08:00
passthem	3e395f8a35	更少的量，更解耦的数据，更健壮的系统 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-26 11:56:03 +08:00
passthem	312e203bbe	忘记把这个答题情况通知加上了 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-26 04:07:26 +08:00
passthem	f9deabfce0	修复 Query 逻辑 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-26 04:03:51 +08:00
passthem	0a822bf440	优化 konaph UX 并添加文档 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-26 03:55:31 +08:00
passthem	534a2c9e75	解密厨来了2 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-26 03:42:28 +08:00
passthem	a03cef4124	解密厨来了	2025-10-26 03:23:51 +08:00
MixBadGun	7a20c3fe2f	空调指数概率损坏与空调、骰子gif图的背景优化	2025-10-26 01:06:26 +08:00
MixBadGun	16351792b6	修复成语接龙大家没被扣分的BUG All checks were successful continuous-integration/drone/push Build is passing Details	2025-10-25 23:59:41 +08:00
MixBadGun	7bbd4f81ee	成语接龙5.0、群空调功能 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-25 23:39:32 +08:00
MixBadGun	4d5678efac	Merge branch 'master' of https://gitea.service.jazzwhom.top/mttu-developers/konabot	2025-10-25 22:00:57 +08:00
MixBadGun	c7229bb763	new render	2025-10-25 21:54:38 +08:00
passthem	6abc963ccf	优化提醒 UX All checks were successful continuous-integration/drone/push Build is passing Details	2025-10-25 00:28:29 +08:00
passthem	881f38d187	调整 Web Renderer 的代码风格，完善类型注解 All checks were successful continuous-integration/drone/push Build is passing Details	2025-10-24 23:49:32 +08:00
MixBadGun	56d32bc9f4	BA All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-24 23:25:00 +08:00
passthem	76f19f9eac	添加 Emoji 字体 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-24 22:11:46 +08:00
passthem	1479d8f8da	添加 CJK 字体依赖	2025-10-24 22:10:16 +08:00
passthem	18785f034b	调整依赖，不再在运行时安装依赖 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-24 21:50:16 +08:00
passthem	7ba1a92623	解决依赖问题，容器体积什么的以后再修 All checks were successful continuous-integration/drone/push Build is passing Details	2025-10-24 20:40:05 +08:00
passthem	f6670eb672	先推上去看看有缺什么依赖 Some checks failed continuous-integration/drone/push Build is failing Details	2025-10-24 20:18:42 +08:00
MixBadGun	eb32c1af9a	new Some checks failed continuous-integration/drone/push Build is failing Details	2025-10-24 19:39:06 +08:00
passthem	e0c55545ec	添加此方提醒的 CURD 和 ntfy 联动 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-24 05:08:54 +08:00
passthem	164305e81f	调整 man	2025-10-24 02:27:56 +08:00
passthem	96679033f3	不再有 fortune All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-24 02:21:56 +08:00
passthem	afda0680ec	调整衰减函数 All checks were successful continuous-integration/drone/push Build is passing Details continuous-integration/drone/tag Build is passing Details	2025-10-24 01:59:41 +08:00