调整 notify 的强制退出

Reviewed-on: #26

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "assets/lexicon/THUOCL"]
+	path = assets/lexicon/THUOCL
+	url = https://github.com/thunlp/THUOCL.git

Dockerfile

@@ -4,6 +4,15 @@ FROM python:3.13-slim AS base
 ENV VIRTUAL_ENV=/app/.venv \
     PATH="/app/.venv/bin:$PATH"
 
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    libfontconfig1 \
+    libgl1 \
+    libegl1 \
+    libglvnd0 \
+    mesa-vulkan-drivers \
+    && rm -rf /var/lib/apt/lists/*
+
 
 
 FROM base AS builder

assets/json/poll.json

@@ -0,0 +1 @@
+{"poll": {"0": {"create": 1760357553, "expiry": 1760443953, "options": {"0": "此方bot", "1": "testpilot", "2": "小镜bot", "3": "可怜bot"}, "polldata": {}, "qq": "2975499623", "title": "我~是~谁~？"}}}

bot.py

@@ -7,6 +7,10 @@ from nonebot.adapters.discord import Adapter as DiscordAdapter
 from nonebot.adapters.minecraft import Adapter as MinecraftAdapter
 from nonebot.adapters.onebot.v11 import Adapter as OnebotAdapter
 
+from konabot.common.log import init_logger
+from konabot.common.nb.exc import BotExceptionMessage
+from konabot.common.path import LOG_PATH
+
 dotenv.load_dotenv()
 env = os.environ.get("ENVIRONMENT", "prod")
 env_enable_console = os.environ.get("ENABLE_CONSOLE", "none")
@@ -14,7 +18,12 @@ env_enable_qq = os.environ.get("ENABLE_QQ", "none")
 env_enable_discord = os.environ.get("ENABLE_DISCORD", "none")
 env_enable_minecraft = os.environ.get("ENABLE_MINECRAFT", "none")
 
+
 def main():
+    init_logger(LOG_PATH, [
+        BotExceptionMessage,
+    ])
+
     nonebot.init()
 
     driver = nonebot.get_driver()
@@ -33,6 +42,7 @@ def main():
 
     # nonebot.load_builtin_plugin("echo")
     nonebot.load_plugins("konabot/plugins")
+    nonebot.load_plugin("nonebot_plugin_analysis_bilibili")
 
     nonebot.run()
 

konabot/common/log.py

@@ -0,0 +1,79 @@
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Type
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from loguru import Record
+
+
+def file_exception_filter(
+    record: "Record", 
+    ignored_exceptions: tuple[Type[Exception], ...]
+) -> bool:
+    """
+    一个自定义的 Loguru 过滤器函数。
+    如果日志记录包含异常信息，并且该异常的类型在 ignored_exceptions 中，则返回 False（忽略）。
+    否则，返回 True（允许记录）。
+    """
+    exception_info = record.get("exception")
+    
+    if exception_info:
+        exception_type = exception_info[0]
+
+        if exception_type and issubclass(exception_type, ignored_exceptions):
+            return False
+
+    return True
+
+
+def init_logger(
+    log_dir: Path, 
+    ignored_exceptions: List[Type[Exception]]
+) -> None:
+    """
+    配置全局 Loguru Logger。
+
+    Args:
+        log_dir (Path): 存放日志文件的文件夹路径，会自动创建。
+        ignored_exceptions (List[Type[Exception]]): 在 WARNING 级别文件日志中需要忽略的异常类型列表。
+    """
+
+    ignored_exceptions_tuple = tuple(ignored_exceptions)
+    logger.remove()
+
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    logger.add(
+        sys.stderr,
+        level="INFO",
+        colorize=True,
+        format="<green>{time:HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+    )
+
+    info_log_path = log_dir / "log.log"
+    logger.add(
+        str(info_log_path),
+        level="INFO",
+        rotation="10 MB",
+        retention="7 days",
+        enqueue=True,
+        backtrace=False,
+        diagnose=False,
+    )
+
+    warning_error_log_path = log_dir / "error.log"
+    logger.add(
+        str(warning_error_log_path),
+        level="WARNING",
+        rotation="10 MB",
+        compression="zip",
+        enqueue=True,
+        filter=lambda record: file_exception_filter(record, ignored_exceptions_tuple),
+        backtrace=True,
+        diagnose=True,
+    )
+
+    logger.info("Loguru Logger 初始化完成！")
+    logger.info(f"控制台日志级别: INFO")

konabot/common/path.py

@@ -4,9 +4,18 @@ ASSETS_PATH = Path(__file__).resolve().parent.parent.parent / "assets"
 FONTS_PATH = ASSETS_PATH / "fonts"
 
 SRC_PATH = Path(__file__).resolve().parent.parent
+DATA_PATH = SRC_PATH.parent / "data"
+LOG_PATH = DATA_PATH / "logs"
 
 DOCS_PATH = SRC_PATH / "docs"
 DOCS_PATH_MAN1 = DOCS_PATH / "user"
 DOCS_PATH_MAN3 = DOCS_PATH / "lib"
 DOCS_PATH_MAN7 = DOCS_PATH / "concepts"
 DOCS_PATH_MAN8 = DOCS_PATH / "sys"
+
+if not DATA_PATH.exists():
+    DATA_PATH.mkdir()
+
+if not LOG_PATH.exists():
+    LOG_PATH.mkdir()
+

konabot/docs/user/giftool.txt

@@ -0,0 +1,59 @@
+指令介绍
+    giftool - 对 GIF 动图进行裁剪、抽帧等处理
+
+格式
+    giftool [图片] [选项]
+
+示例
+    回复一张 GIF 并发送：
+        `giftool --ss 1.5 -t 2.0`
+        从 1.5 秒处开始，截取 2 秒长度的片段。
+
+    `giftool [图片] --ss 0:10 -to 0:15`
+        截取从 10 秒到 15 秒之间的片段（支持 MM:SS 或 HH:MM:SS 格式）。
+
+    `giftool [图片] --frames:v 10`
+        将整张 GIF 均匀抽帧，最终保留 10 帧。
+
+    `giftool [图片] --ss 2 --frames:v 5`
+        从第 2 秒开始截取，并将结果抽帧为 5 帧。
+
+参数说明
+    图片（必需）
+        - 必须是 GIF 动图。
+        - 支持直接附带图片，或回复一条含 GIF 的消息后使用指令。
+
+    --ss <时间戳>（可选）
+        - 指定开始时间（单位：秒），可使用以下格式：
+            • 纯数字（如 `1.5` 表示 1.5 秒）
+            • 分秒格式（如 `1:30` 表示 1 分 30 秒）
+            • 时分秒格式（如 `0:1:30` 表示 1 分 30 秒）
+        - 默认从开头开始（0 秒）。
+
+    -t <持续时间>（可选）
+        - 指定截取的持续时间（单位：秒），格式同 --ss。
+        - 与 --ss 配合使用：截取 [ss, ss + t] 区间。
+        - 不能与 --to 同时使用。
+
+    --to <时间戳>（可选）
+        - 指定结束时间（单位：秒），格式同 --ss。
+        - 与 --ss 配合使用：截取 [ss, to] 区间。
+        - 不能与 -t 同时使用。
+
+    --frames:v <帧数>（可选）
+        - 对截取后的片段进行均匀抽帧，保留指定数量的帧。
+        - 帧数必须为正整数（> 0）。
+        - 若原始帧数 ≤ 指定帧数，则保留全部帧。
+
+    --s <速度>（可选）
+        - 调整 gif 图的速度。若为负数，则代表倒放
+
+使用方式
+    1. 发送指令前，请确保：
+        - 消息中附带一张 GIF 动图，或
+        - 回复一条包含 GIF 动图的消息后再发送指令。
+    2. 插件会自动：
+        - 解析 GIF 的每一帧及其持续时间（duration）
+        - 根据时间参数转换为帧索引进行裁剪
+        - 如指定抽帧，则对裁剪后的片段均匀采样
+        - 生成新的 GIF 并保持原始循环设置（loop=0）

konabot/docs/user/shadertool.txt

@@ -0,0 +1,47 @@
+指令介绍  
+    shadertool - 使用 SkSL（Skia Shader Language）代码实时渲染并生成 GIF 动画
+
+格式  
+    shadertool [选项] <SkSL 代码>
+
+示例  
+    shadertool """
+    uniform float u_time;
+    uniform float2 u_resolution;
+
+    half4 main(float2 coord) {
+        return half4(
+            1.0,
+            sin((coord.y / u_resolution.y + u_time) * 3.1415926 * 2) * 0.5 + 0.5,
+            coord.x / u_resolution.x,
+            1.0
+        );
+    }
+    """
+
+参数说明  
+    SkSL 代码（必填）  
+        - 类型：字符串（建议用英文双引号包裹）  
+        - 内容：符合 SkSL 语法的片段着色器代码，必须包含 `void main()` 函数，并为 `sk_FragColor` 赋值。  
+        - 注意：插件会自动去除代码首尾的单引号或双引号，便于命令行输入。
+
+    --width <整数>（可选）  
+        - 默认值：320  
+        - 作用：输出 GIF 的宽度（像素），必须大于 0。
+
+    --height <整数>（可选）  
+        - 默认值：180  
+        - 作用：输出 GIF 的高度（像素），必须大于 0。
+
+    --duration <浮点数>（可选）  
+        - 默认值：1.0  
+        - 作用：动画总时长（秒），必须大于 0。  
+        - 限制：`duration × fps` 必须 ≥ 1 且 ≤ 100（即至少 1 帧，最多 100 帧）。
+
+    --fps <浮点数>（可选）  
+        - 默认值：15.0  
+        - 作用：每秒帧数，控制动画流畅度，必须大于 0。  
+        - 常见值：10（低配流畅）、15（默认）、24/30（电影/视频级）。
+
+使用方式  
+    直接在群聊或私聊中发送 `shadertool` 指令，附上合法的 SkSL 代码即可。

konabot/docs/user/发起投票.txt

@@ -0,0 +1,11 @@
+指令介绍
+    发起投票 - 发起一个投票
+
+格式
+    发起投票 <投票标题> <选项1> <选项2> ...
+
+示例
+    `发起投票 这是一个投票 A B C` 发起标题为“这是一个投票”，选项为“A”、“B”、“C”的投票
+
+说明
+    投票各个选项之间用空格分隔，选项数量为2-15项。投票的默认有效期为24小时。

konabot/docs/user/投票.txt

@@ -0,0 +1,12 @@
+指令介绍
+    投票 - 参与已发起的投票
+
+格式
+    投票 <投票ID/标题> <选项文本>
+
+示例
+    `投票 1 A` 在ID为1的投票中，投给“A”
+    `投票 这是一个投票 B` 在标题为“这是一个投票”的投票中，投给“B”
+
+说明
+    目前不支持单人多投，每个人只能投一项。

konabot/docs/user/查看投票.txt

@@ -0,0 +1,12 @@
+指令介绍
+    查看投票 - 查看已发起的投票
+
+格式
+    查看投票 <投票ID或标题>
+
+示例
+    `查看投票 1` 查看ID为1的投票
+    `查看投票 这是一个投票` 查看标题为“这是一个投票”的投票
+
+说明
+    投票在进行时，使用此命令可以看到投票的各个选项；投票结束后，则可以看到各项的票数。

konabot/docs/user/生成二维码.txt

@@ -0,0 +1,8 @@
+指令介绍
+    生成二维码 - 将文本内容转换为二维码
+
+格式
+    生成二维码 <文本内容>
+
+示例
+    `生成二维码 嗨嗨嗨` 生成扫描结果为“嗨嗨嗨”的二维码图片

konabot/docs/user/黑白.txt

@@ -0,0 +1,5 @@
+指令介绍
+    黑白 - 将图片经过一个黑白滤镜的处理
+
+示例
+    引用一个带有图片的消息，或者消息本身携带图片，然后发送「黑白」即可

konabot/plugins/bilibili_fetch_fix.py

@@ -0,0 +1,25 @@
+import re
+from loguru import logger
+from nonebot import on_message
+from nonebot_plugin_alconna import Reference, Reply, UniMsg
+
+from nonebot.adapters import Event
+
+
+matcher_fix = on_message()
+
+pattern = (
+    r"^(?:(?:av|cv)\d+|BV[a-zA-Z0-9]{10})|"
+    r"(?:b23\.tv|bili(?:22|23|33|2233)\.cn|\.bilibili\.com|QQ小程序(?:]|]|\])哔哩哔哩).{0,500}"
+)
+
+
+@matcher_fix.handle()
+async def _(msg: UniMsg, event: Event):
+    to_search = msg.exclude(Reply, Reference).dump(json=True)
+    if not re.search(pattern, to_search):
+        return
+    logger.info("检测到有 Bilibili 相关的消息，直接进行一个调用")
+    _module = __import__("nonebot_plugin_analysis_bilibili")
+    await _module.handle_analysis(event)
+

konabot/plugins/gen_qrcode/__init__.py

@@ -0,0 +1,69 @@
+import qrcode
+# from pyzbar.pyzbar import decode
+# from PIL import Image
+import requests
+from io import BytesIO
+
+from nonebot_plugin_alconna import (Alconna, Args, Field, MultiVar, UniMessage,
+                                    on_alconna)
+from nonebot_plugin_alconna.uniseg import UniMsg, At, Reply
+
+async def download_img(url):
+    resp = requests.get(url.replace("https://multimedia.nt.qq","http://multimedia.nt.qq")) # bim获取QQ的图片时避免SSLv3报错
+    img_bytes = BytesIO()
+    with open(img_bytes,"wb") as f:
+        f.write(resp.content)
+    return img_bytes
+
+def genqr(data):
+    qr = qrcode.QRCode(version=1,error_correction=qrcode.constants.ERROR_CORRECT_L,box_size=8,border=4)
+    qr.add_data(data)
+    qr.make(fit=True)
+    img = qr.make_image(fill_color="black", back_color="white")
+    img_bytes = BytesIO()
+    img.save(img_bytes, format="PNG")
+    return img_bytes
+
+"""
+async def recqr(url):
+    im_path = "assets/img/qrcode/2.jpg"
+    data = await download_img(url)
+    img = Image.open(im_path)
+    decoded_objects = decode(img)
+    data = ""
+    for obj in decoded_objects:
+        data += obj.data.decode('utf-8')
+    return data
+"""
+
+gqrc = on_alconna(Alconna(
+    "genqr",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "请输入你要转换为二维码的文字！"
+    )],
+    # UniMessage[]
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases={"生成二维码","genqrcode"})
+
+@gqrc.handle()
+async def _(saying: list):
+    """
+    img = await draw_pt("\n".join(saying))
+    img_bytes = BytesIO()
+    img.save(img_bytes, format="PNG")
+
+    await pt.send(await UniMessage().image(raw=img_bytes).export())
+    
+    # print(saying)
+    # 二维码识别
+    if type(saying[0]) == 'image':
+        data = await recqr(saying[0].data['url'])
+        if data == "":
+            await gqrc.send("二维码图片解析失败！")
+        else:
+            await gqrc.send(recqr(saying[0].data['url']))
+    
+    # 二维码生成
+    else:
+    """
+        # genqr("\n".join(saying))
+    await gqrc.send(await UniMessage().image(raw=genqr("\n".join(saying))).export())

konabot/plugins/idiomgame/__init__.py

@@ -0,0 +1,177 @@
+import base64
+import secrets
+import json
+from typing import Literal
+
+from nonebot import on_message
+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, Args, Field, Subcommand,
+                                    UniMessage, UniMsg, on_alconna)
+
+from konabot.common.path import ASSETS_PATH
+
+ALL_WORDS = [] # 所有四字词语
+ALL_IDIOMS = [] # 所有成语
+IDIOM_FIRST_CHAR = {} # 成语首字字典
+
+INITED = False
+
+def init_lexicon():
+    global ALL_WORDS, ALL_IDIOMS, IDIOM_FIRST_CHAR
+    # 成语大表
+    with open(ASSETS_PATH / "lexicon" / "idiom.json", "r", encoding="utf-8") as f:
+        ALL_IDIOMS_INFOS = json.load(f)
+
+    # 词语大表
+    with open(ASSETS_PATH / "lexicon" / "ci.json", "r", encoding="utf-8") as f:
+        ALL_WORDS = json.load(f)
+    
+    COMMON_WORDS = []
+    # 读取 COMMON 词语大表
+    with open(ASSETS_PATH / "lexicon" / "common.txt", "r", encoding="utf-8") as f:
+        for line in f:
+            word = line.strip()
+            if len(word) == 4:
+                COMMON_WORDS.append(word)
+
+    # 读取 THUOCL 成语库
+    with open(ASSETS_PATH / "lexicon" / "THUOCL" / "data" / "THUOCL_chengyu.txt", "r", encoding="utf-8") as f:
+        THUOCL_IDIOMS = [line.split(" ")[0].strip() for line in f]
+
+    # 读取 THUOCL 剩下的所有 txt 文件，只保留四字词
+    THUOCL_WORDS = []
+    import os
+    for filename in os.listdir(ASSETS_PATH / "lexicon" / "THUOCL" / "data"):
+        if filename.endswith(".txt") and filename != "THUOCL_chengyu.txt":
+            with open(ASSETS_PATH / "lexicon" / "THUOCL" / "data" / filename, "r", encoding="utf-8") as f:
+                for line in f:
+                    word = line.lstrip().split(" ")[0].strip()
+                    if len(word) == 4:
+                        THUOCL_WORDS.append(word)
+
+
+    # 只有成语的大表
+    ALL_IDIOMS = [idiom["word"] for idiom in ALL_IDIOMS_INFOS] + THUOCL_IDIOMS
+    ALL_IDIOMS = list(set(ALL_IDIOMS)) # 去重
+
+    # 其他四字词语表，仅表示可以有这个词
+    ALL_WORDS = [word for word in ALL_WORDS if len(word) == 4] + THUOCL_WORDS + COMMON_WORDS
+    ALL_WORDS = list(set(ALL_WORDS)) # 去重
+
+    # 根据成语大表，划分出成语首字字典
+    IDIOM_FIRST_CHAR = {}
+    for idiom in ALL_IDIOMS + ALL_WORDS:
+        if idiom[0] not in IDIOM_FIRST_CHAR:
+            IDIOM_FIRST_CHAR[idiom[0]] = []
+        IDIOM_FIRST_CHAR[idiom[0]].append(idiom)
+
+NOW_PLAYING = False
+
+SCORE_BOARD = {}
+
+LAST_CHAR = ""
+
+USER_NAME_CACHE = {} # 缓存用户名称，避免多次获取
+
+evt = on_alconna(Alconna(
+    "我要玩成语接龙"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent):
+    global NOW_PLAYING, LAST_CHAR, INITED
+    if not INITED:
+        init_lexicon()
+        INITED = True
+    if NOW_PLAYING:
+        await evt.send(await UniMessage().text("当前已有成语接龙游戏在进行中，请稍后再试！").export())
+        return
+    NOW_PLAYING = True
+    await evt.send(await UniMessage().text("你小子，还真有意思！\n好，成语接龙游戏开始！我说一个成语，请大家接下去！").export())
+    # 选择一个随机成语
+    idiom = secrets.choice(ALL_IDIOMS)
+    LAST_CHAR = idiom[-1]
+    # 发布成语
+    await evt.send(await UniMessage().text(f"第一个成语：「{idiom}」，请接！").export())
+
+evt = on_alconna(Alconna(
+    "不玩了"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent):
+    global NOW_PLAYING, SCORE_BOARD, LAST_CHAR
+    if NOW_PLAYING:
+        NOW_PLAYING = False
+        # 发送好吧狗图片
+        # 打开好吧狗本地文件
+        with open(ASSETS_PATH / "img" / "dog" / "haoba_dog.jpg", "rb") as f:
+            img_data = f.read()
+        await evt.send(await UniMessage().image(raw=img_data).export())
+        result_text = UniMessage().text("游戏结束！\n最终得分榜：\n")
+        if len(SCORE_BOARD) == 0:
+            result_text += "无人得分！"
+        else:
+            # 按分数排序，名字用 at 的方式
+            sorted_score = sorted(SCORE_BOARD.items(), key=lambda x: x[1]["score"], reverse=True)
+            for i, (user_id, info) in enumerate(sorted_score):
+                result_text += f"{i+1}. " + UniMessage().at(user_id) + f": {info['score']} 分\n"
+        await evt.send(await result_text.export())
+        # 重置分数板
+        SCORE_BOARD = {}
+        LAST_CHAR = ""
+    else:
+        await evt.send(await UniMessage().text("当前没有成语接龙游戏在进行中！").export())
+
+# 跳过
+evt = on_alconna(Alconna(
+    "跳过成语"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent):
+    global NOW_PLAYING, LAST_CHAR
+    if not NOW_PLAYING:
+        return
+    await evt.send(await UniMessage().text("你们太菜了！全部扣100分！").export())
+    for user_id in SCORE_BOARD:
+        SCORE_BOARD[user_id]["score"] -= 100
+    # 选择下一个成语
+    idiom = secrets.choice(ALL_IDIOMS)
+    LAST_CHAR = idiom[-1]
+    await evt.send(await UniMessage().text(f"重新开始，下一个成语是「{idiom}」").export())
+
+# 直接读取消息
+evt = on_message()
+
+@evt.handle()
+async def _(event: BaseEvent, msg: UniMsg):
+    global NOW_PLAYING, LAST_CHAR, SCORE_BOARD
+    if not NOW_PLAYING:
+        return
+    user_idiom = msg.extract_plain_text().strip()
+    if(user_idiom[0] != LAST_CHAR):
+        return
+    if(user_idiom not in ALL_IDIOMS and user_idiom not in ALL_WORDS):
+        await evt.send(await UniMessage().text("接不上！这个不一样！").export())
+        return
+    # 成功接上
+    if isinstance(event, DiscordMessageEvent):
+        user_id = str(event.author.id)
+        user_name = str(event.author.name)
+    else:
+        user_id = str(event.get_user_id())
+        user_name = str(event.get_user_id())
+
+    if user_id not in SCORE_BOARD:
+        SCORE_BOARD[user_id] = {
+            "name": user_name,
+            "score": 0
+        }
+    SCORE_BOARD[user_id]["score"] += 1
+    # at 指定玩家
+    await evt.send(await UniMessage().at(user_id).text(f"接对了！你有 {SCORE_BOARD[user_id]['score']} 分！").export())
+    LAST_CHAR = user_idiom[-1]
+    await evt.send(await UniMessage().text(f"下一个成语请以「{LAST_CHAR}」开头！").export())

konabot/plugins/idiomgame/base/path.py

@@ -0,0 +1,3 @@
+from pathlib import Path
+
+ASSETS = Path(__file__).parent.parent / "assets"

konabot/plugins/image_process/__init__.py

@@ -1,6 +1,12 @@
+import re
+from io import BytesIO
+
 from nonebot import on_message
 from nonebot.adapters import Bot
+from nonebot_plugin_alconna import (Alconna, Args, Image, Option, UniMessage,
+                                    on_alconna)
 
+from konabot.common.nb.exc import BotExceptionMessage
 from konabot.common.nb.extract_image import PIL_Image
 from konabot.common.nb.match_keyword import match_keyword
 from konabot.common.nb.reply_image import reply_image
@@ -11,3 +17,195 @@ cmd_black_white = on_message(rule=match_keyword("黑白"))
 @cmd_black_white.handle()
 async def _(img: PIL_Image, bot: Bot):
     await reply_image(cmd_black_white, bot, img.convert("LA"))
+
+
+def parse_timestamp(tx: str) -> float | None:
+    res = 0.0
+    for component in tx.split(":"):
+        res *= 60
+        if not re.match(r"^\d+(\.\d+)?$", component):
+            return
+        res += float(component)
+    return res
+
+
+cmd_giftool = on_alconna(Alconna(
+    "giftool",
+    Args["img", Image | None],
+    Option("--ss", Args["start_point", str]),
+    Option("--frames:v", Args["frame_count", int]),
+    Option("-t", Args["length", str]),
+    Option("-to", Args["end_point", str]),
+    Option("--speed", Args["speed_factor", float], default=1.0, alias=["-s"]),
+))
+
+
+@cmd_giftool.handle()
+async def _(
+    image: PIL_Image,
+    start_point: str | None = None,
+    frame_count: int | None = None,
+    length: str | None = None,
+    speed_factor: float = 1.0,
+    end_point: str | None = None,
+):
+    ss: None | float = None
+    if start_point:
+        ss = parse_timestamp(start_point)
+        if ss is None:
+            raise BotExceptionMessage("--ss 的格式不满足条件")
+
+    t: None | float = None
+    if length:
+        t = parse_timestamp(length)
+        if t is None:
+            raise BotExceptionMessage("-t 的格式不满足条件")
+
+    to: None | float = None
+    if end_point:
+        to = parse_timestamp(end_point)
+        if to is None:
+            raise BotExceptionMessage("-to 的格式不满足条件")
+
+    if to is not None and ss is not None and to <= ss:
+        raise BotExceptionMessage("错误：出点时间小于入点")
+    if frame_count is not None and frame_count <= 0:
+        raise BotExceptionMessage("错误：帧数量应该大于 0")
+    if speed_factor == 0:
+        raise BotExceptionMessage("错误：速度不能为 0")
+
+    is_rev = speed_factor < 0
+    speed_factor = abs(speed_factor)
+
+    if not getattr(image, "is_animated", False):
+        raise BotExceptionMessage("错误：输入的不是动图（GIF）")
+
+    frames = []
+    durations = []
+    total_duration = 0.0
+
+    try:
+        for i in range(getattr(image, "n_frames")):
+            image.seek(i)
+            frames.append(image.copy())
+            duration = image.info.get("duration", 100)  # 单位：毫秒
+            durations.append(duration)
+            total_duration += duration / 1000.0  # 转为秒
+    except EOFError:
+        pass
+
+    if not frames:
+        raise BotExceptionMessage("错误：读取 GIF 帧失败")
+
+    def time_to_frame_index(target_time: float) -> int:
+        if target_time <= 0:
+            return 0
+        cum = 0.0
+        for idx, dur in enumerate(durations):
+            cum += dur / 1000.0
+            if cum >= target_time:
+                return min(idx, len(frames) - 1)
+        return len(frames) - 1
+    start_frame = 0
+    end_frame = len(frames) - 1
+    if ss is not None:
+        start_frame = time_to_frame_index(ss)
+    if to is not None:
+        end_frame = time_to_frame_index(to)
+        if end_frame < start_frame:
+            end_frame = start_frame
+    elif t is not None:
+        end_time = (ss or 0.0) + t
+        end_frame = time_to_frame_index(end_time)
+        if end_frame < start_frame:
+            end_frame = start_frame
+
+    start_frame = max(0, start_frame)
+    end_frame = min(len(frames) - 1, end_frame)
+    selected_frames = frames[start_frame : end_frame + 1]
+    selected_durations = durations[start_frame : end_frame + 1]
+
+    if frame_count is not None and frame_count > 0:
+        if frame_count >= len(selected_frames):
+            pass
+        else:
+            step = len(selected_frames) / frame_count
+            sampled_frames = []
+            sampled_durations = []
+            for i in range(frame_count):
+                idx = int(i * step)
+                sampled_frames.append(selected_frames[idx])
+                sampled_durations.append(
+                    sum(selected_durations) // len(selected_durations)
+                )
+            selected_frames = sampled_frames
+            selected_durations = sampled_durations
+
+    output_img = BytesIO()
+
+    adjusted_durations = [
+        dur / speed_factor for dur in selected_durations
+    ]
+
+    rframes = []
+    rdur = []
+
+    acc_mod_20 = 0
+
+    for i in range(len(selected_frames)):
+        fr = selected_frames[i]
+        du: float = adjusted_durations[i]
+
+        if du >= 20:
+            rframes.append(fr)
+            rdur.append(int(du))
+            acc_mod_20 = 0
+        else:
+            if acc_mod_20 == 0:
+                rframes.append(fr)
+                rdur.append(20)
+                acc_mod_20 += du
+            else:
+                acc_mod_20 += du
+                if acc_mod_20 >= 20:
+                    acc_mod_20 = 0
+
+    if len(rframes) == 1 and len(selected_frames) > 1:
+        rframes.append(selected_frames[max(2, len(selected_frames) // 2)])
+        rdur.append(20)
+
+    transparency_flag = False
+    for f in rframes:
+        if f.mode == "RGBA":
+            if any(pix < 255 for pix in f.getchannel("A").getdata()):
+                transparency_flag = True
+                break
+        elif f.mode == "P" and "transparency" in f.info:
+            transparency_flag = True
+            break
+
+    tf = {}
+    if transparency_flag:
+        tf['transparency'] = 0
+
+    if is_rev:
+        rframes = rframes[::-1]
+        rdur = rdur[::-1]
+
+    if rframes:
+        rframes[0].save(
+            output_img,
+            format="GIF",
+            save_all=True,
+            append_images=rframes[1:],
+            duration=rdur,
+            loop=0,
+            optimize=False,
+            disposal=2,
+            **tf,
+        )
+    else:
+        raise BotExceptionMessage("错误：没有可输出的帧")
+    output_img.seek(0)
+
+    await cmd_giftool.send(await UniMessage().image(raw=output_img).export())

konabot/plugins/poll/__init__.py

@@ -0,0 +1,166 @@
+import json, time
+
+from nonebot_plugin_alconna import Alconna, Args, Field, MultiVar, on_alconna
+from nonebot.adapters.onebot.v11 import Event
+
+from konabot.common.path import ASSETS_PATH, DATA_PATH
+
+
+POLL_TEMPLATE_FILE = ASSETS_PATH / "json" / "poll.json"
+POLL_DATA_FILE = DATA_PATH / "poll.json"
+
+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']
+
+async def createpoll(title,qqid,options):
+    polllength = len(poll_list)
+    pollid = str(polllength)
+    poll_create = int(time.time())
+    poll_expiry = poll_create + 24*3600
+    polljson = {"title":title,"qq":qqid,"create":poll_create,"expiry":poll_expiry,"options":options,"polldata":{}}
+    poll_list[pollid] = polljson
+    writeback()
+    return pollid
+
+def getpolldata(pollid_or_title):
+    # 初始化“被指定的投票项目”
+    thepoll = {}
+    polnum = -1
+    # 判断是ID还是标题
+    if str.isdigit(pollid_or_title):
+        if pollid_or_title in poll_list:
+            thepoll = poll_list[pollid_or_title]
+            polnum = pollid_or_title
+        else:
+            return [{},-1]
+    else:
+        for i in poll_list:
+            if poll_list[i]["title"] == pollid_or_title:
+                thepoll = poll_list[i]
+                polnum = i
+                break
+        if polnum == -1:
+            return [{},-1]
+    return [thepoll,polnum]
+
+def writeback():
+    # file = open(poll_json_path,"w",encoding="utf-8")
+    # 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))
+
+async def pollvote(polnum,optionnum,qqnum):
+    optiond = poll_list[polnum]["polldata"]
+    if optionnum not in optiond:
+        poll_list[polnum]["polldata"][optionnum] = []
+    poll_list[polnum]["polldata"][optionnum].append(qqnum)
+    writeback()
+    return
+
+poll = on_alconna(Alconna(
+    "poll",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "参数错误。用法：发起投票 <投票标题> <选项1> <选项2> ..."
+    )],
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases={"发起投票","createpoll"})
+@poll.handle()
+async def _(saying: list, event: Event):
+    if (len(saying) < 3):
+        await poll.send("请提供至少两个投票选项！")
+    elif (len(saying) < 17):
+        title = saying[0]
+        saying.remove(title)
+        options = {}
+        for i in saying:
+            options[saying.index(i)] = i
+        qqid = event.get_user_id()
+        result = await createpoll(title,qqid,options)
+        await poll.send("已创建投票。回复 查看投票 "+str(result)+" 查看该投票。")
+    else:
+        await poll.send("投票选项太多了！请减少到15个选项以内。")
+
+viewpoll = on_alconna(Alconna(
+    "viewpoll",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "请指定投票ID或标题！。用法：查看投票 <投票ID或标题>"
+    )],
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases={"查看投票"})
+@viewpoll.handle()
+async def _(saying: list):
+    # 参数，投票ID或者标题
+    # pollid_or_title = params[0]
+    polldata = getpolldata(saying[0])
+    # 被指定的投票项目
+    thepoll = polldata[0]
+    polnum = polldata[1]
+    if polnum == -1:
+        await viewpoll.send("该投票不存在！")
+    else:
+        # 检查投票是否已结束
+        pollended = 0
+        if time.time() > thepoll["expiry"]:
+            pollended = 1
+        # 回复内容
+        reply = "投票："+thepoll["title"]+" [ID: "+str(polnum)+"]"
+        # 如果投票已结束
+        if pollended:
+            for i in thepoll["options"]:
+                reply += "\n"
+                # 检查该选项是否有人投票
+                if i in thepoll["polldata"]:
+                    reply += "["+str(len(thepoll["polldata"][i]))+" 票]"
+                else:
+                    reply += "[0 票]"
+                reply += " "+thepoll["options"][i]
+            reply += "\n\n此投票已结束。"
+        else:
+            for i in thepoll["options"]:
+                reply += "\n"
+                reply += "- "+thepoll["options"][i]
+            # reply += "\n\n小提示：向bot私聊发送 /viewpoll "+str(polnum)+" 可查看已投票数哦！"
+            reply += "\n\n发送 投票 "+str(polnum)+" <选项文本> 即可参与投票！"
+        await viewpoll.send(reply)
+
+vote = on_alconna(Alconna(
+    "vote",
+    Args["saying", MultiVar(str, '+'), Field(
+        missing_tips=lambda: "参数错误。用法：投票 <投票ID/标题> <选项文本>"
+    )],
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=False, aliases={"投票","参与投票"})
+@vote.handle()
+async def _(saying: list, event: Event):
+    if (len(saying) < 2):
+        await vote.send("请指定投给哪一项！")
+    else:
+        polldata = getpolldata(saying[0])
+        # 被指定的投票项目
+        thepoll = polldata[0]
+        polnum = polldata[1]
+        if polnum == -1:
+            await viewpoll.finish("没有找到这个投票！")
+        # thepolldata = thepoll["polldata"]
+        # 查找对应的投票项
+        optionnum = -1
+        for i in thepoll["options"]:
+            if saying[1] == thepoll["options"][i]:
+                optionnum = i
+                break
+        if optionnum == -1:
+            reply = "此投票里面没有这一项！可用的选项有："
+            for i in thepoll["options"]:
+                reply += "\n"
+                reply += "- "+thepoll["options"][i]
+            await viewpoll.send(reply)
+        # 检查是否符合投票条件（该qq号是否已参与过投票、投票是否过期）
+        elif time.time() > thepoll["expiry"]:
+            await viewpoll.send("此投票已经结束！请发送 查看投票 "+polnum+" 查看结果。")
+        elif str(event.get_user_id()) in str(thepoll["polldata"]):
+            await viewpoll.send("你已参与过此投票！请在投票结束后发送 查看投票 "+polnum+" 查看结果。")
+        # 写入项目
+        else:
+            await pollvote(polnum,optionnum,event.get_user_id())
+            await viewpoll.send("投票成功！你投给了 "+saying[1])

konabot/plugins/roll_dice/roll_dice.py

@@ -309,7 +309,7 @@ async def generate_dice_image(number: str) -> BytesIO:
     if(len(text) > 50):
         output = BytesIO()
         push_image = Image.open(ASSETS_PATH / "img" / "dice" / "stick.png")
-        push_image.save(output,format='PNG')
+        push_image.save(output,format='GIF')
         output.seek(0)
         return output
 

konabot/plugins/simple_notify/__init__.py

@@ -1,8 +1,10 @@
-import asyncio
+import asyncio as asynkio
 import datetime
+import functools
 from pathlib import Path
 from typing import Any, Literal, cast
 
+import signal
 import nonebot
 import ptimeparse
 from loguru import logger
@@ -24,7 +26,9 @@ evt = on_message()
 
 (Path(__file__).parent.parent.parent.parent / "data").mkdir(exist_ok=True)
 DATA_FILE_PATH = Path(__file__).parent.parent.parent.parent / "data" / "notify.json"
-DATA_FILE_LOCK = asyncio.Lock()
+DATA_FILE_LOCK = asynkio.Lock()
+
+ASYNK_TASKS: set[asynkio.Task[Any]] = set()
 
 
 class Notify(BaseModel):
@@ -107,11 +111,20 @@ async def notify_now(notify: Notify):
     return True
 
 
-async def create_notify_task(notify: Notify, fail2remove: bool = True):
+def create_notify_task(notify: Notify, fail2remove: bool = True):
     async def mission():
         begin_time = datetime.datetime.now()
         if begin_time < notify.notify_time:
-            await asyncio.sleep((notify.notify_time - begin_time).total_seconds())
+            try:
+                await asynkio.sleep((notify.notify_time - begin_time).total_seconds())
+            except asynkio.CancelledError:
+                logger.debug("代办提醒被信号中止，任务退出")
+                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:
             await DATA_FILE_LOCK.acquire()
@@ -123,7 +136,7 @@ async def create_notify_task(notify: Notify, fail2remove: bool = True):
             DATA_FILE_LOCK.release()
         else:
             pass
-    return asyncio.create_task(mission())
+    return asynkio.create_task(mission())
 
 
 @evt.handle()
@@ -143,6 +156,7 @@ async def _(msg: UniMsg, mEvt: Event):
     # target_time = get_target_time(notify_time)
     try:
         target_time = ptimeparse.parse(notify_time)
+        logger.info(f"从 {notify_time} 解析出了时间：{target_time}")
     except Exception:
         logger.info(f"无法从 {notify_time} 中解析出时间")
         return
@@ -154,7 +168,7 @@ async def _(msg: UniMsg, mEvt: Event):
 
     await DATA_FILE_LOCK.acquire()
     cfg = load_notify_config()
-    
+
     if isinstance(mEvt, ConsoleMessageEvent):
         platform = "console"
         target = mEvt.get_user_id()
@@ -181,7 +195,7 @@ async def _(msg: UniMsg, mEvt: Event):
         notify_time=target_time,
         notify_msg=notify_text,
     )
-    await create_notify_task(notify)
+    create_notify_task(notify)
 
     cfg.notifies.append(notify)
     save_notify_config(cfg)
@@ -189,6 +203,7 @@ async def _(msg: UniMsg, mEvt: Event):
 
     await evt.send(await UniMessage().at(mEvt.get_user_id()).text(
         f" 了解啦！将会在 {notify.notify_time} 提醒你哦~").export())
+    logger.info(f"创建了一条于 {notify.notify_time} 的代办提醒")
 
 
 driver = nonebot.get_driver()
@@ -205,15 +220,41 @@ async def _():
 
     NOTIFIED_FLAG["task_added"] = True
 
-    await asyncio.sleep(10)
+    DELTA = 2
+    logger.info(f"第一次探测到 Bot 连接，等待 {DELTA} 秒后开始通知")
+    await asynkio.sleep(DELTA)
+
     await DATA_FILE_LOCK.acquire()
-    tasks = []
+
+    # tasks: set[asynkio.Task[Any]] = set()
     cfg = load_notify_config()
     if cfg.version == 1:
+        logger.info("将配置文件的版本升级为 2")
         cfg.version = 2
     else:
-        for notify in cfg.notifies:
-            tasks.append(create_notify_task(notify, fail2remove=False))
+        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()
 
-    await asyncio.gather(*tasks)
+    loop = asynkio.get_running_loop()
+
+    # 解决 asynk task 没有被 cancel 的问题
+    async def shutdown(sig: signal.Signals):
+        logger.info(f"收到 {sig.name} 指令，正在关闭所有的东西")
+        for task in ASYNK_TASKS:
+            task.cancel()
+        await asynkio.gather(*ASYNK_TASKS, return_exceptions=True)
+        logger.info("所有的代办提醒 Task 都已经退出了")
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        loop.add_signal_handler(sig, functools.partial(
+            asynkio.create_task, shutdown(sig)
+        ))
+
+    await asynkio.gather(*ASYNK_TASKS)

konabot/plugins/sksl/__init__.py

@@ -0,0 +1,43 @@
+from nonebot_plugin_alconna import Alconna, Args, Option, UniMessage, on_alconna
+
+from konabot.common.nb.exc import BotExceptionMessage
+from konabot.plugins.sksl.run_sksl import render_sksl_shader_to_gif
+
+
+cmd_run_sksl = on_alconna(Alconna(
+    "shadertool",
+    Option("--width", Args["width_", int]),
+    Option("--height", Args["height_", int]),
+    Option("--duration", Args["duration_", float]),
+    Option("--fps", Args["fps_", float]),
+    Args["code", str],
+))
+
+@cmd_run_sksl.handle()
+async def _(
+    code: str,
+    width_: int = 320,
+    height_: int = 180,
+    duration_: float = 1.0,
+    fps_: float = 15.0,
+):
+    if width_ <= 0 or height_ <= 0:
+        raise BotExceptionMessage("长宽应该大于 0")
+    if duration_ <= 0:
+        raise BotExceptionMessage("渲染时长应该大于 0")
+    if fps_ <= 0:
+        raise BotExceptionMessage("渲染帧率应该大于 0")
+    if fps_ * duration_ < 1:
+        raise BotExceptionMessage("时长太短或帧率太小，没有帧被渲染")
+    if fps_ * duration_ > 100:
+        raise BotExceptionMessage("太多帧啦！试着缩短一点时间吧！")
+    if width_ > 640 or height_ > 640:
+        raise BotExceptionMessage("最大支持 640x640 啦！不要太大啦！")
+
+    code = code.strip("\"").strip("'")
+
+    try:
+        res = await render_sksl_shader_to_gif(code, width_, height_, duration_, fps_)
+        await cmd_run_sksl.send(await UniMessage().image(raw=res).export())
+    except (ValueError, RuntimeError) as e:
+        await cmd_run_sksl.send(await UniMessage().text(f"渲染时遇到了问题：\n\n{e}").export())

konabot/plugins/sksl/run_sksl.py

@@ -0,0 +1,155 @@
+import asyncio
+import io
+import struct
+
+from loguru import logger
+import numpy as np
+import skia
+from PIL import Image
+
+
+def _pack_uniforms(uniforms_dict, width, height, time_val):
+    """
+    根据常见的教学用 uniform 布局打包字节数据
+    假设 SkSL 中 uniform 顺序为: float u_time; float2 u_resolution;
+    内存布局: [u_time(4B)][u_res_x(4B)][u_res_y(4B)] (总共 12 字节，无填充)
+    注意：为匹配 skia.RuntimeEffect 的紧凑布局，已移除 float 和 float2 之间的 4 字节填充。
+    """
+    # u_time (float) - 4 bytes
+    time_bytes = struct.pack('f', time_val)
+    
+    # u_resolution (vec2/float2) - 8 bytes
+    res_bytes = struct.pack('ff', float(width), float(height))
+    
+    # 移除填充字节，使用紧凑布局
+    return time_bytes + res_bytes
+
+
+def _render_sksl_shader_to_gif(
+    sksl_code: str,
+    width: int = 256,
+    height: int = 256,
+    duration: float = 2.0,
+    fps: float = 15,
+) -> io.BytesIO:
+    """
+    渲染 SkSL 着色器动画为 GIF（适配 skia-python >= 138）
+    """
+
+    logger.info(f"开始编译\n{sksl_code}")
+
+    runtime_effect = skia.RuntimeEffect.MakeForShader(sksl_code)
+    if runtime_effect is None:
+        # SkSL 编译失败时，尝试获取错误信息（如果 skia 版本支持）
+        error_message = ""
+        # 注意：skia-python 的错误信息捕获可能因版本而异
+        
+        # 尝试检查编译错误是否在日志中，但最直接的是抛出已知错误
+        raise ValueError("SkSL 编译失败，请检查语法")
+    
+    # --- 修复: 移除对不存在的 uniformSize() 的调用，直接使用硬编码的 12 字节尺寸 ---
+    # float (4 bytes) + float2 (8 bytes) = 12 bytes (基于 _pack_uniforms 函数的紧凑布局)
+    EXPECTED_UNIFORM_SIZE = 12
+
+    # 创建 CPU 后端 Surface
+    surface = skia.Surface(width, height)
+    
+    frames = []
+    total_frames = int(duration * fps)
+
+    for frame in range(total_frames):
+        time_val = frame / fps
+        
+        # 打包 uniform 数据
+        uniform_bytes = _pack_uniforms(None, width, height, time_val)
+        
+        # [检查] 确保打包后的字节数与期望值匹配
+        if len(uniform_bytes) != EXPECTED_UNIFORM_SIZE:
+             raise ValueError(
+                f"Uniform 数据大小不匹配！期望 {EXPECTED_UNIFORM_SIZE} 字节，实际 {len(uniform_bytes)} 字节。请检查 _pack_uniforms 函数。"
+            )
+
+        uniform_data = skia.Data.MakeWithCopy(uniform_bytes)
+
+        # 创建着色器
+        try:
+            # makeShader 的参数: uniform_data, children_shaders, child_count
+            shader = runtime_effect.makeShader(uniform_data, None, 0)
+            if shader is None:
+                # 如果 SkSL 语法正确但 uniform 匹配失败，makeShader 会返回 None
+                raise RuntimeError("着色器创建返回 None！请检查 SkSL 语法和 uniform 数据匹配。")
+        except Exception as e:
+            raise ValueError(f"着色器创建失败: {e}")
+
+        # 绘制
+        canvas = surface.getCanvas()
+        canvas.clear(skia.Color(0, 0, 0, 255))
+        
+        paint = skia.Paint()
+        paint.setShader(shader)
+        canvas.drawRect(skia.Rect.MakeWH(width, height), paint)
+        
+        # --- 修复 peekPixels() 错误：改用 readPixels() 将数据复制到缓冲区 ---
+        image = surface.makeImageSnapshot()
+        
+        # 1. 准备目标 ImageInfo (通常是 kBGRA_8888_ColorType)
+        target_info = skia.ImageInfo.Make(
+            image.width(), 
+            image.height(), 
+            skia.ColorType.kBGRA_8888_ColorType, # 目标格式，匹配 Skia 常见的输出格式
+            skia.AlphaType.kPremul_AlphaType
+        )
+        
+        # 2. 创建一个用于接收像素数据的 bytearray 缓冲区
+        pixel_data = bytearray(image.width() * image.height() * 4) # 4 bytes per pixel (BGRA)
+        
+        # 3. 将图像数据复制到缓冲区
+        success = image.readPixels(target_info, pixel_data, target_info.minRowBytes())
+
+        if not success:
+            raise RuntimeError("无法通过 readPixels() 获取图像像素")
+            
+        # 4. 转换 bytearray 到 NumPy 数组 (BGRA 顺序)
+        img_array = np.frombuffer(pixel_data, dtype=np.uint8).reshape((height, width, 4))
+        
+        # 5. BGRA 转换成 RGB 顺序 (交换 R 和 B 通道)
+        # [B, G, R, A] -> [R, G, B] (丢弃 A 通道)
+        rgb_array = img_array[:, :, [2, 1, 0]] 
+        
+        # 6. 创建 PIL Image
+        pil_img = Image.fromarray(rgb_array)
+        frames.append(pil_img)
+        # ------------------------------------------------------------------
+
+    # 生成 GIF
+    gif_buffer = io.BytesIO()
+    # 计算每帧的毫秒延迟
+    frame_duration_ms = int(1000 / fps)
+    frames[0].save(
+        gif_buffer,
+        format='GIF',
+        save_all=True,
+        append_images=frames[1:],
+        duration=frame_duration_ms,
+        loop=0, # 0 表示无限循环
+        optimize=True
+    )
+    gif_buffer.seek(0)
+    return gif_buffer
+
+
+async def render_sksl_shader_to_gif(
+    sksl_code: str,
+    width: int = 256,
+    height: int = 256,
+    duration: float = 2.0,
+    fps: float = 15,
+) -> io.BytesIO:
+    return await asyncio.to_thread(
+        _render_sksl_shader_to_gif,
+        sksl_code,
+        width,
+        height,
+        duration,
+        fps,
+    )

poetry.lock

@@ -748,6 +748,18 @@ all = ["email-validator (>=2.0.0)", "fastapi-cli[standard] (>=0.0.8)", "httpx (>
 standard = ["email-validator (>=2.0.0)", "fastapi-cli[standard] (>=0.0.8)", "httpx (>=0.23.0,<1.0.0)", "jinja2 (>=3.1.5)", "python-multipart (>=0.0.18)", "uvicorn[standard] (>=0.12.0)"]
 standard-no-fastapi-cloud-cli = ["email-validator (>=2.0.0)", "fastapi-cli[standard-no-fastapi-cloud-cli] (>=0.0.8)", "httpx (>=0.23.0,<1.0.0)", "jinja2 (>=3.1.5)", "python-multipart (>=0.0.18)", "uvicorn[standard] (>=0.12.0)"]
 
+[[package]]
+name = "filetype"
+version = "1.2.0"
+description = "Infer file type and MIME type of any file/buffer. No external dependencies."
+optional = false
+python-versions = "*"
+groups = ["main"]
+files = [
+    {file = "filetype-1.2.0-py2.py3-none-any.whl", hash = "sha256:7ce71b6880181241cf7ac8697a2f1eb6a8bd9b429f7ad6d27b8db9ba5f1c2d25"},
+    {file = "filetype-1.2.0.tar.gz", hash = "sha256:66b56cd6474bf41d8c54660347d37afcc3f7d1970648de365c102ef77548aadb"},
+]
+
 [[package]]
 name = "frozenlist"
 version = "1.7.0"
@@ -1630,6 +1642,23 @@ nonebot-plugin-waiter = ">=0.6.0"
 nonebot2 = ">=2.3.0"
 tarina = ">=0.6.8,<0.7"
 
+[[package]]
+name = "nonebot-plugin-analysis-bilibili"
+version = "2.8.1"
+description = "nonebot2解析bilibili插件"
+optional = false
+python-versions = "<4.0,>=3.8"
+groups = ["main"]
+files = [
+    {file = "nonebot_plugin_analysis_bilibili-2.8.1-py3-none-any.whl", hash = "sha256:f882a0428ca87fc77a56fae6013607f6b286d8ae0ed46a1a87b4a1a6d3f4d011"},
+    {file = "nonebot_plugin_analysis_bilibili-2.8.1.tar.gz", hash = "sha256:17c2c15a1783a2e1075638861384bd55b3fef09c0c7eb94857f811f60dbb446a"},
+]
+
+[package.dependencies]
+aiohttp = ">=3.7,<4.0"
+nonebot-plugin-send-anything-anywhere = ">=0,<1"
+nonebot2 = ">=2.1.1,<3.0.0"
+
 [[package]]
 name = "nonebot-plugin-apscheduler"
 version = "0.5.0"
@@ -1647,6 +1676,25 @@ apscheduler = ">=3.7.0,<4.0.0"
 nonebot2 = ">=2.2.0,<3.0.0"
 pydantic = ">=1.10.0,<2.5.0 || >2.5.0,<2.5.1 || >2.5.1,<3.0.0"
 
+[[package]]
+name = "nonebot-plugin-send-anything-anywhere"
+version = "0.7.1"
+description = "An adaptor for nonebot2 adaptors"
+optional = false
+python-versions = "<4.0,>=3.9"
+groups = ["main"]
+files = [
+    {file = "nonebot_plugin_send_anything_anywhere-0.7.1-py3-none-any.whl", hash = "sha256:b52044272be9a7bc77bd7a53ef700481c071fd4e889ae21a0411d0df22d13c16"},
+    {file = "nonebot_plugin_send_anything_anywhere-0.7.1.tar.gz", hash = "sha256:ec9c7ba59c824238b812950146a894acc88ca8da98f500de15217feebcd5e868"},
+]
+
+[package.dependencies]
+anyio = ">=3.3.0,<5.0.0"
+filetype = ">=1.2.0,<2.0.0"
+nonebot2 = ">=2.3.0,<3.0.0"
+pydantic = ">=1.10.0,<2.5.0 || >2.5.0,<2.5.1 || >2.5.1,<3.0.0"
+strenum = ">=0.4.8,<0.5.0"
+
 [[package]]
 name = "nonebot-plugin-waiter"
 version = "0.8.1"
@@ -2079,6 +2127,21 @@ type = "legacy"
 url = "https://gitea.service.jazzwhom.top/api/packages/Passthem/pypi/simple"
 reference = "pt-gitea-pypi"
 
+[[package]]
+name = "pybind11"
+version = "3.0.1"
+description = "Seamless operability between C++11 and Python"
+optional = false
+python-versions = ">=3.8"
+groups = ["main"]
+files = [
+    {file = "pybind11-3.0.1-py3-none-any.whl", hash = "sha256:aa8f0aa6e0a94d3b64adfc38f560f33f15e589be2175e103c0a33c6bce55ee89"},
+    {file = "pybind11-3.0.1.tar.gz", hash = "sha256:9c0f40056a016da59bab516efb523089139fcc6f2ba7e4930854c61efb932051"},
+]
+
+[package.extras]
+global = ["pybind11-global (==3.0.1)"]
+
 [[package]]
 name = "pycares"
 version = "4.11.0"
@@ -2455,6 +2518,26 @@ files = [
     {file = "pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f"},
 ]
 
+[[package]]
+name = "qrcode"
+version = "8.2"
+description = "QR Code image generator"
+optional = false
+python-versions = "<4.0,>=3.9"
+groups = ["main"]
+files = [
+    {file = "qrcode-8.2-py3-none-any.whl", hash = "sha256:16e64e0716c14960108e85d853062c9e8bba5ca8252c0b4d0231b9df4060ff4f"},
+    {file = "qrcode-8.2.tar.gz", hash = "sha256:35c3f2a4172b33136ab9f6b3ef1c00260dd2f66f858f24d88418a015f446506c"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+
+[package.extras]
+all = ["pillow (>=9.1.0)", "pypng"]
+pil = ["pillow (>=9.1.0)"]
+png = ["pypng"]
+
 [[package]]
 name = "requests"
 version = "2.32.5"
@@ -2515,6 +2598,53 @@ pygments = ">=2.13.0,<3.0.0"
 [package.extras]
 jupyter = ["ipywidgets (>=7.5.1,<9)"]
 
+[[package]]
+name = "skia-python"
+version = "138.0"
+description = "Skia python binding"
+optional = false
+python-versions = "*"
+groups = ["main"]
+files = [
+    {file = "skia_python-138.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a8bcf4f8d6ea08bdf718ed257f9a9c722f643223f9b93230fd4c15ac5c82029f"},
+    {file = "skia_python-138.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:1b7f24a5b306f57d75b8733658189dd61ce9114a84b5d119b3b1fb09cbc991cb"},
+    {file = "skia_python-138.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:2c4164013355bcf255651ac8a0ca519fd6095b6e58fa5e7a057919bec158411d"},
+    {file = "skia_python-138.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:63a7f9dc8d5fdda969f35d7f8f3a774029093468a9c06771ccce9ab967b275ca"},
+    {file = "skia_python-138.0-cp310-cp310-win_amd64.whl", hash = "sha256:740104424e9c94a70a767adcdbfa2bce131c93a82fa00a50432406dc04bac7e8"},
+    {file = "skia_python-138.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6e369105b2811b6c32d7f15624202609deeb428164ee395c715df01221c847f5"},
+    {file = "skia_python-138.0-cp311-cp311-macosx_11_0_x86_64.whl", hash = "sha256:55a2ae437d1c6dc46d9bbc2e3e0b4b5642022dcebc0634591ae1c8acea52a413"},
+    {file = "skia_python-138.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:e67c9bcac953fbeb31b38474a4e566371e5719d4e27032686359cbe602819af8"},
+    {file = "skia_python-138.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:4e9fb097849604e290be28a6b4cc29cb0079b0233e599c2f6b2ec635e47169d2"},
+    {file = "skia_python-138.0-cp311-cp311-win_amd64.whl", hash = "sha256:df5a0dd52e1038423f2e1c03677cba5ea974d215adec10763dd855f4a6ca0cfc"},
+    {file = "skia_python-138.0-cp311-cp311-win_arm64.whl", hash = "sha256:054ca430003d52468974cf69d98719e61f188630709a3706a868efc16e817970"},
+    {file = "skia_python-138.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b83d7b8101038ab0fcb920b1a91c872615e45b0ac19fe0c66b55d3ad0d61970"},
+    {file = "skia_python-138.0-cp312-cp312-macosx_11_0_x86_64.whl", hash = "sha256:f22060f513b2fc258b4269e631128ca68889107bc4aa65255119f3d9c1c32993"},
+    {file = "skia_python-138.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:02b0c2146d25f45224c2c156dd8b859e89265ee5894c3fa8f456c6c41b27122d"},
+    {file = "skia_python-138.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:fb9e980a61defcb6ca19d73c97ea23d1aea633a82e9d1dead6ed259c3856baaf"},
+    {file = "skia_python-138.0-cp312-cp312-win_amd64.whl", hash = "sha256:625bb95dc225ea2257f1d1f7b0aee203290b91d909c8f5feaa7cd428f13bce22"},
+    {file = "skia_python-138.0-cp312-cp312-win_arm64.whl", hash = "sha256:e495143edba2a7cdf59e83723f00c9a247e5baeda4981fc6587803ed46c5ed2a"},
+    {file = "skia_python-138.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1433b5a0bd4ca1c1d050541f54c25d27d55a129894dbd827d4e440697090ff83"},
+    {file = "skia_python-138.0-cp313-cp313-macosx_11_0_x86_64.whl", hash = "sha256:3f053128aa6344fa991c2485f29f40bda77b5f46467a43e778a34ec8f5b3615a"},
+    {file = "skia_python-138.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:878212d9576d065a45fd143c57d412bc0496c6594ecfcd9cc2cd93b4fd943cb4"},
+    {file = "skia_python-138.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:a6b3e58756a9fa8af3714edc05aeafc7922090f5a276c4be11337f252921dbe8"},
+    {file = "skia_python-138.0-cp313-cp313-win_amd64.whl", hash = "sha256:f2d596d5807fafef6bc43440f4df28f71db189f9e2cfb8613224713916837e3c"},
+    {file = "skia_python-138.0-cp313-cp313-win_arm64.whl", hash = "sha256:20285bf4ee41da754b842c80076fc4a240cb3801f4a1cbbb50b26a5dca1ebc39"},
+    {file = "skia_python-138.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ff8dcb98b19e85d565c1d0accf8919e4b8a35d2a121d2d6f1c21fea655c85884"},
+    {file = "skia_python-138.0-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:ff3e692214b27490e38caf6ed123d82d2ff762da4561473a5a34fab1cb5dcd14"},
+    {file = "skia_python-138.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:db3388f4e6e8f63c9e2b6cb0add0c2e483cbed783558b10eb7d94540f75db9b6"},
+    {file = "skia_python-138.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:1dd9306b2025e296ad1d0e2c3038e3221ade1d48dfd0a20ce926f8116603b909"},
+    {file = "skia_python-138.0-cp38-cp38-win_amd64.whl", hash = "sha256:9ae5de84629dba4c751b334a8c43b04e9b7fe2a65df26992770648aa5e131b0c"},
+    {file = "skia_python-138.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:736e6618f246444bff2ff73b9efe8fd7159d9048c85ecdffb23290702a5c9099"},
+    {file = "skia_python-138.0-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:ab438dfe40d1be3da6fdd94890862781dc4e545a0bfa169a8e9dcc25f3bb0afd"},
+    {file = "skia_python-138.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:2f5d842930d1e385aa7911e0705d4751d8e4aa550389baf88d40673672f180b1"},
+    {file = "skia_python-138.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:d17ad82d6094f9c7bfc25b6525e1080bf3715abcc848be042c786b365f51a48c"},
+    {file = "skia_python-138.0-cp39-cp39-win_amd64.whl", hash = "sha256:0f6136827a269a4a5294d92919bc6fad008da7d7e74256666d81506f863a6ff9"},
+]
+
+[package.dependencies]
+numpy = "*"
+pybind11 = ">=2.6"
+
 [[package]]
 name = "sniffio"
 version = "1.3.1"
@@ -2558,6 +2688,23 @@ typing-extensions = {version = ">=4.10.0", markers = "python_version < \"3.13\""
 [package.extras]
 full = ["httpx (>=0.27.0,<0.29.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.18)", "pyyaml"]
 
+[[package]]
+name = "strenum"
+version = "0.4.15"
+description = "An Enum that inherits from str."
+optional = false
+python-versions = "*"
+groups = ["main"]
+files = [
+    {file = "StrEnum-0.4.15-py3-none-any.whl", hash = "sha256:a30cda4af7cc6b5bf52c8055bc4bf4b2b6b14a93b574626da33df53cf7740659"},
+    {file = "StrEnum-0.4.15.tar.gz", hash = "sha256:878fb5ab705442070e4dd1929bb5e2249511c0bcf2b0eeacf3bcd80875c82eff"},
+]
+
+[package.extras]
+docs = ["myst-parser[linkify]", "sphinx", "sphinx-rtd-theme"]
+release = ["twine"]
+test = ["pylint", "pytest", "pytest-black", "pytest-cov", "pytest-pylint"]
+
 [[package]]
 name = "tarina"
 version = "0.6.8"
@@ -3198,4 +3345,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.12,<4.0"
-content-hash = "b4c3d28f7572c57e867d126ce0c64787ae608b114e66b8de06147caf13e049dd"
+content-hash = "6fc63a138508a779d47346e0186b4c771ed17b10f278a0e094c6994c1d99a877"

pyproject.toml

@@ -23,6 +23,9 @@ dependencies = [
     "opencv-python-headless (>=4.12.0.88,<5.0.0.0)",
     "returns (>=0.26.0,<0.27.0)",
     "ptimeparse (>=0.1.1,<0.2.0)",
+    "skia-python (>=138.0,<139.0)",
+    "nonebot-plugin-analysis-bilibili (>=2.8.1,<3.0.0)",
+    "qrcode (>=8.2,<9.0)",
 ]
 
 [build-system]