o'kok

core/async_task.py

@@ -11,70 +11,67 @@ from astrbot.api.star import Context, Star, register, StarTools
 from astrbot.api import logger
 from astrbot.api import AstrBotConfig
 
-from .jx3_data import JX3Service
 
+from .jx3_data import JX3Service
+from .sqlite import AsyncSQLiteDB
 
 class AsyncTask:
     """
     基于 APScheduler 的后台异步监控任务管理类
     """
 
-    def __init__(self, context: Context, config: AstrBotConfig, jx3fun: JX3Service):
+    def __init__(self, context: Context, config: AstrBotConfig, jx3api: JX3Service, sqlite: AsyncSQLiteDB):
         self.context = context
         self.conf = config
-        self.jx3fun = jx3fun
+        self.jx3fun = jx3api
+        self.sql = sqlite
 
         self.server = self.conf.get("server", "梦江南")
-        self.file_path = StarTools.get_data_dir("astrbot_plugin_jx3") / "local_async.json"
-        self._file_lock = asyncio.Lock()
         
         self.scheduler = AsyncIOScheduler()
-        self.tasks = {}  # 存储 task_id 对应的状态信息
+        self.tasks = {}  
         
-        logger.info(f"获取后台数据缓存文件路径成功：{self.file_path}")
+        logger.info(f"初始化推送功能成功")
 
     
     """===================== 本地读写 ====================="""
 
     async def set_local_data(self, key: str, value):
-        async with self._file_lock:
-            try:
-                self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            allowed = {"kfts", "xwts", "smts", "ctts"}
+            if key not in allowed:
+                raise ValueError("非法字段")
+            
+            await self.sql.update(
+                "tuishong",
+                {
+                    key: value,
+                },
+                "id=?",
+                (1,)
+            )
+        except Exception as e:
+            logger.error(f"数据写入失败：{e}")
 
-                if not self.file_path.exists():
-                    local_data = {}
-                else:
-                    async with aiofiles.open(self.file_path, "r", encoding="utf-8") as f:
-                        content = await f.read()
-                        local_data = json.loads(content) if content else {}
 
-                local_data[key] = value
-
-                async with aiofiles.open(self.file_path, "w", encoding="utf-8") as f:
-                    await f.write(
-                        json.dumps(local_data, ensure_ascii=False, indent=4)
-                    )
-
-            except (OSError, json.JSONDecodeError) as e:
-                logger.error(f"数据写入文件失败：{e}")
-
-    async def get_local_data(self, key: str, default=None):
-        async with self._file_lock:
-            try:
-                if not self.file_path.exists():
-                    return default
-
-                async with aiofiles.open(self.file_path, "r", encoding="utf-8") as f:
-                    content = await f.read()
-                    if not content:
-                        return default
-                    local_data = json.loads(content)
-
-                return local_data.get(key, default)
-
-            except (OSError, json.JSONDecodeError) as e:
-                logger.error(f"读取数据文件失败：{e}")
+    async def get_local_data(self, key: str, default: int=0):
+        try:
+            allowed = {"kfts", "xwts", "smts", "ctts"}
+            if key not in allowed:
                 return default
+            
+            data = await self.sql.select_one(
+                    "tuishong",
+                    "id=?",
+                    (1,)
+                )   
+            if data:                    
+                return data.get(key, default)
+            else:
+                return default
+        except Exception as e:
+            logger.error(f"数据读取失败：{e}")
+
 
     """===================== 通用后台任务 ====================="""
 
@@ -112,10 +109,10 @@ class AsyncTask:
 
     async def init_tasks(self):
         settings = [
-            ("kfjk", "开服监控", lambda: self.jx3fun.kaifu(self.server)),
-            ("xwzx", "新闻资讯", lambda: self.jx3fun.xinwen(1)),
-            ("smxx", "刷马消息", lambda: self.jx3fun.shuamamsg(self.server,type="horse",subtype="foreshow")),
-            ("ctxx", "赤兔消息", lambda: self.jx3fun.shuamamsg(self.server,type="chitu-horse",subtype="share_msg")),
+            ("kfts", "开服监控", lambda: self.jx3fun.kaifu(self.server)),
+            ("xwts", "新闻资讯", lambda: self.jx3fun.xinwen(1)),
+            ("smts", "刷马消息", lambda: self.jx3fun.shuamamsg(self.server,type="horse",subtype="foreshow")),
+            ("ctts", "赤兔消息", lambda: self.jx3fun.shuamamsg(self.server,type="chitu-horse",subtype="share_msg")),
         ]
 
         for key, name, fetch in settings:
@@ -131,7 +128,10 @@ class AsyncTask:
             }
 
             if self.tasks[key]["enable"]:
-                self._add_scheduler(key, name, fetch)
+                if self.tasks[key]["umos"]:
+                    self._add_scheduler(key, name, fetch)
+                else:
+                    logger.warning(f"{name} 推送对象为空，任务未启动")
 
         if not self.scheduler.running:
             self.scheduler.start()

core/jx3_data.py

@@ -1,9 +1,4 @@
-
-# pyright: reportArgumentType=false
-# pyright: reportAttributeAccessIssue=false
-# pyright: reportIndexIssue=false
-# pyright: reportOptionalMemberAccess=false
-
+import json
 from datetime import datetime
 from typing import Dict, Any, Optional, List, Union
 
@@ -15,10 +10,16 @@ from .sqlite import AsyncSQLiteDB
 from .fun_basic import load_template,gold_to_string,week_to_num,compare_date_str
 
 class JX3Service:
-    def __init__(self, api_config, config:AstrBotConfig, sqlite:AsyncSQLiteDB):
-        self._api = APIClient()
-        # 引用API配置文件
-        self._api_config = api_config
+    def __init__(self, api_data_path: str, config: AstrBotConfig, sqlite: AsyncSQLiteDB):
+        # 加载API配置文件
+        try:
+            with open(api_data_path, 'r', encoding='utf-8') as f:
+                self._api_config = json.load(f) 
+        except FileNotFoundError as e:
+            logger.error(f"加载API配置文件失败: {e}")
+            self._api_config = {}
+        # 实例化 API Client
+        self._api: APIClient = APIClient()
         # 引用插件配置文件
         self._config = config
         # 引用sqlite
@@ -27,13 +28,13 @@ class JX3Service:
         # 获取配置中的 Token
         self.token = self._config.get("jx3api_token", "")
         if  self.token == "":
-            logger.info("获取配置token失败，请正确填写token,否则部分功能无法正常使用")
+            logger.warning("获取配置token失败，请正确填写token,否则部分功能无法正常使用")
         else:
             logger.debug(f"获取配置token成功。{self.token}")
         # 获取配置中的 ticket
         self.ticket = self._config.get("jx3api_ticket", "")
         if  self.ticket == "":
-            logger.info("获取配置ticket失败，请正确填写ticket,否则部分功能无法正常使用")
+            logger.warning("获取配置ticket失败，请正确填写ticket,否则部分功能无法正常使用")
         else:
             logger.debug(f"获取配置ticket成功。{self.ticket}")
         
@@ -42,7 +43,6 @@ class JX3Service:
         """释放底层 APIClient 资源"""
         if self._api:
             await self._api.close()
-            self._api = None
 
 
     def _init_return_data(self) -> Dict[str, Any]:
@@ -72,12 +72,15 @@ class JX3Service:
         :return: 成功时返回提取后的数据，失败时返回 None。
         """
         try:
+            if not self._api:
+                logger.error("API client is not initialized")
+                return None
+                
             api_config = self._api_config.get(config_key)
             if not api_config:
                 logger.error(f"配置文件中未找到 key: {config_key}")
                 return None
             
-            # 复制 params，避免修改原始配置模板
             request_params = api_config.get("params", {}).copy()
             if params:
                 request_params.update(params)
@@ -185,7 +188,7 @@ class JX3Service:
         # 3. 处理返回数据
         try:
             items = []
-            num_richang  = week_to_num(data["data"][0]["week"])
+            num_richang  = week_to_num(data["data"][0]["week"]) or 0
             # 空白数据
             for _ in range(num_richang):
                 items.append({
@@ -271,7 +274,7 @@ class JX3Service:
         params = {"subject": subject, "limit": limit}
 
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[List[Dict[str, Any]]] = await self._base_request(
             "jx3_keju", "GET", params=params
         )
         if not data:
@@ -511,7 +514,7 @@ class JX3Service:
         return_data = self._init_return_data()
         
         
-        data: Optional[Dict[str, Any]] = await self._base_request("jx3_zhuangtai", "GET") 
+        data: Optional[List[Dict[str, Any]]] = await self._base_request("jx3_zhuangtai", "GET") 
         
         if not data:
             return_data["msg"] = "获取接口信息失败"
@@ -621,8 +624,8 @@ class JX3Service:
         return_data = self._init_return_data()
 
         params = {"server": server, "type": type, "subtype": subtype}
-        # 提取字段可能返回列表
-        data: Optional[List[Dict[str, Any]]] = await self._base_request(
+        # 提取字段可能返回字典
+        data: Optional[Dict[str, Any]] = await self._base_request(
             "jx3box_shuamamsg", "GET", params=params)
         
         if not data:
@@ -631,7 +634,7 @@ class JX3Service:
         
         try:
             # 
-            new_msg = data.get("list")[0]
+            new_msg = data.get("list",[])[0]
             return_data["status"] = new_msg.get('id')
 
             result_msg = f"{server}\n"
@@ -653,18 +656,14 @@ class JX3Service:
         """区服金价"""
         return_data = self._init_return_data()
         
-        # 获取配置中的 Token
-        token = self._config.get("jx3api_token", "")
-        if  token == "":
-            return_data["msg"] = "系统未配置API访问Token"
-            return return_data
 
-        params = {"server": server, "limit": limit, "token": token}
+        params = {"server": server, "limit": limit, "token": self.token}
         data_list: Optional[List[Dict[str, Any]]] = await self._base_request("jx3_jinjia", "GET", params=params)
         
         if not data_list or not isinstance(data_list, list):
             return_data["msg"] = "获取接口信息失败或数据格式错误"
             return return_data
+        
         # 加载模板
         try:
             return_data["temp"] = await load_template("jinjia.html")
@@ -772,7 +771,7 @@ class JX3Service:
         params = {"server": server, "name": name,"token": self.token}
 
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[List[Dict[str, Any]]] = await self._base_request(
             "jx3_jiaoyihang", "GET", params=params
         )
 
@@ -785,18 +784,19 @@ class JX3Service:
         
         try:
             for item in data:
-                inner_list = item.get("data", []) 
-                first = inner_list[0] if inner_list else {}
-                new_item = {
-                    "name": item.get("name"),
-                    "icon": f"https://icon.jx3box.com/icon/{item.get('icon')}.png",
-                    "sever": first.get("server"),
-                    "count": len(inner_list),
-                    "unit_price": gold_to_string(first.get("unit_price")),
-                    "created": datetime.fromtimestamp(first.get("created")).strftime("%Y-%m-%d %H:%M:%S"),
-                }
-                result.append(new_item)
-                return_data["data"]["list"] = result
+                if isinstance(item, dict):
+                    inner_list = item.get("data", []) 
+                    first = inner_list[0] if inner_list else {}
+                    new_item = {
+                        "name": item.get("name"),
+                        "icon": f"https://icon.jx3box.com/icon/{item.get('icon')}.png",
+                        "sever": first.get("server"),
+                        "count": len(inner_list),
+                        "unit_price": gold_to_string(first.get("unit_price")),
+                        "created": datetime.fromtimestamp(first.get("created", "")).strftime("%Y-%m-%d %H:%M:%S"),
+                    }
+                    result.append(new_item)
+            return_data["data"]["list"] = result
         except Exception as e:
             logger.error(f"处理交易行数据失败: {e}")
             return_data["msg"] = "处理交易行数据失败"
@@ -868,7 +868,7 @@ class JX3Service:
         params = {"server": server, "name": name,"token": self.token}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[List[Dict[str, Any]]] = await self._base_request(
             "jx3_yanhuachaxun", "GET", params=params
         )
         
@@ -879,12 +879,12 @@ class JX3Service:
         # 3. 处理返回数据 
         try:            
             for item in data:
-                timestamp = item.get("time")
-                if timestamp and isinstance(timestamp, (int, float)):
-                    # 修复时间戳：原代码显示这里是毫秒级，除以 1000
-                    item["time"] = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
-                else:
-                    item["time"] = "未知时间" # 确保即使 time 字段缺失也不会报错
+                if isinstance(item, dict):
+                    timestamp = item.get("time")
+                    if timestamp and isinstance(timestamp, (int, float)):
+                        item["time"] = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+                    else:
+                        item["time"] = "未知时间" 
 
             return_data["data"]["list"] = data
         except Exception as e:
@@ -913,7 +913,7 @@ class JX3Service:
         params = {"server": server, "token": self.token}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[List[Dict[str, Any]]] = await self._base_request(
             "jx3_dilujilu", "GET", params=params
         )
         
@@ -927,7 +927,7 @@ class JX3Service:
                 item["refresh_time"] = datetime.fromtimestamp(item["refresh_time"]).strftime("%Y-%m-%d %H:%M:%S")
                 item["capture_time"] = datetime.fromtimestamp(item["capture_time"]).strftime("%Y-%m-%d %H:%M:%S")
                 item["auction_time"] = datetime.fromtimestamp(item["auction_time"]).strftime("%Y-%m-%d %H:%M:%S")
-                return_data["data"]["list"] = data
+            return_data["data"]["list"] = data
         except Exception as e:
             logger.error(f"数据处理时出错: {e}")
             return_data["msg"] = "处理接口返回信息时出错" 
@@ -1034,7 +1034,7 @@ class JX3Service:
         params = {"server": server, "name": name, "token": self.token}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[List[Dict[str, Any]]] = await self._base_request(
             "jx3_qiyu", "GET", params=params
         )
 
@@ -1082,7 +1082,7 @@ class JX3Service:
         params = {"server": server, "name": name, "token": self.token}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[List[Dict[str, Any]]] = await self._base_request(
             "jx3_zhengyingpaimai", "GET", params=params
         )
         
@@ -1122,7 +1122,7 @@ class JX3Service:
         params = {"server": server, "token": self.token}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[list[Dict[str, Any]]] = await self._base_request(
             "jx3_fuyaojiutian", "GET", params=params
         )
         
@@ -1240,7 +1240,7 @@ class JX3Service:
         params = {"class": type, "limit": "5", "token": self.token}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[list[Dict[str, Any]]] = await self._base_request(
             "jx3_bagua", "GET", params=params
         )
         
@@ -1277,7 +1277,7 @@ class JX3Service:
         params = {"name": name}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[list[Dict[str, Any]]] = await self._base_request(
             "jx3box_qiyugonglue", "GET", params=params, out_key="list"
         )
         
@@ -1290,11 +1290,10 @@ class JX3Service:
         url = f"https://node.jx3box.com/serendipity/{dwID}/achievement"
         logger.debug(f"获取ID接口地址：{url}")
 
-        # 3. 获取奇遇攻略
-        # 获取achievement_id
         data1 = await self._api.get(url)
         url1 = f"https://cms.jx3box.com/api/cms/wiki/post/type/achievement/source/{data1['achievement_id']}"
         logger.debug(f"获取攻略接口地址：{url1}")
+
         # 获取奇遇攻略
         data2 = await self._api.get(url1, out_key="data")
         if not data2:
@@ -1327,8 +1326,12 @@ class JX3Service:
                 (name, name, name, name, name, name)
             )
 
-        kungfu = result.get("name",None)
-        if kungfu == None:
+        if result is None:
+            return_data["msg"] = "未找到该心法"
+            return return_data
+
+        kungfu = result.get("name", None)
+        if kungfu is None:
             return_data["msg"] = "未找到该心法"
             return return_data
         
@@ -1338,7 +1341,7 @@ class JX3Service:
         params = {"kungfu": kungfu}
         
         # 2. 调用基础请求
-        data: Optional[Dict[str, Any]] = await self._base_request(
+        data: Optional[list[Dict[str, Any]]] = await self._base_request(
             "jx3box_hong", "GET", params=params, out_key=""
         )
         logger.debug(data)
@@ -1377,6 +1380,7 @@ class JX3Service:
         # 发起请求
         url = f"https://cms.jx3box.com/api/cms/post/{pid}"
         logger.debug(f"获取宏接口地址：{url}")
+
         data = await self._api.get(url, out_key="data")
         # 验证数据
         if not data:
@@ -1414,9 +1418,13 @@ class JX3Service:
                 "name=? OR name1=? OR name2=? OR name3=? OR name4=? OR name5=?",
                 (name, name, name, name, name, name)
             )
-
-        mount = result.get("pzid",None)
-        if mount == None:
+        logger.debug(result)
+        if result is None:
+            return_data["msg"] = "未找到该心法"
+            return return_data
+        
+        mount = result.get("pzid", None)
+        if not mount:
             return_data["msg"] = "未找到该心法"
             return return_data
         

core/message.py

@@ -0,0 +1,379 @@
+from astrbot.core import html_renderer
+from astrbot.api import logger
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.core.utils.session_waiter import (
+    SessionController,
+    session_waiter,
+)
+
+from .jx3_data import JX3Service
+from .async_task import AsyncTask
+from .bilei_data import BiLeidata
+
+
+class MessageBuilder:
+    """回复消息构建"""
+    def __init__(self, server: str, jx3api: JX3Service, bilei: BiLeidata, jx3at: AsyncTask):
+        self.server = server
+        self.jx3api = jx3api
+        self.bilei = bilei
+        self.jx3at = jx3at
+
+
+    async def html_render(
+        self,
+        tmpl: str,
+        data: dict,
+        return_url=True,
+        options: dict | None = None,
+    ) -> str:
+        """渲染 HTML"""
+        return await html_renderer.render_custom_template(
+            tmpl,
+            data,
+            return_url=return_url,
+            options=options,
+        )
+    
+
+    def serverdefault(self,server) -> str:
+        """加载配置默认服务器"""
+        if server == "":
+            return self.server
+        return server
+
+
+    async def plain_msg(self, event: AstrMessageEvent, action):
+        """最终将数据整理成文本发送"""
+        data= await action()
+        try:
+            if data["code"] == 200:
+                await event.send( event.plain_result(data["data"]))
+            else:
+                await event.send(event.plain_result(data["msg"])) 
+        except Exception as e:
+            logger.error(f"功能函数执行错误: {e}")
+            await event.send(event.plain_result("猪脑过载，请稍后再试")) 
+
+
+    async def T2I_image_msg(self, event: AstrMessageEvent, action):
+        """最终将数据渲染成图片发送"""
+        data = await action()
+        try:
+            if data["code"] == 200:
+                url = await self.html_render(data["temp"], data["data"], options={})
+                await event.send(event.image_result(url)) 
+            else:
+                await event.send(event.plain_result(data["msg"])) 
+
+        except Exception as e:
+            logger.error(f"功能函数执行错误: {e}")
+            await event.send(event.plain_result("猪脑过载，请稍后再试")) 
+
+
+    async def image_msg(self, event: AstrMessageEvent, action):
+        """最终将数据整理成图片发送"""
+        data = await action()
+        try:
+            if data["code"] == 200:
+                await event.send(event.image_result(data["data"])) 
+            else:
+                await event.send(event.plain_result(data["msg"])) 
+
+        except Exception as e:
+            logger.error(f"功能函数执行错误: {e}")
+            await event.send(event.plain_result("猪脑过载，请稍后再试")) 
+
+
+    async def handler_plain_image_msg(self, event: AstrMessageEvent, action1, action2):
+        """两轮会话消息发送通用，先文本列表等反馈序号在发送图片"""
+        # 会话触发
+        try:
+            # 获取一轮数据
+            data = await action1()
+            if data["code"] == 200:
+                # 发送一轮消息
+                await event.send(event.plain_result(data["msg"])) 
+                # 获取触发用户ID
+                user_id = event.get_sender_id()
+
+                # 二轮会话流程
+                @session_waiter(timeout=30)
+                async def macro_select_waiter(controller: SessionController,new_event: AstrMessageEvent):
+                    # 跳过非触发用户消息
+                    if new_event.get_sender_id() != user_id:
+                        return
+                    # 获取用户消息
+                    msg = new_event.get_message_str().strip()
+                    # 判断消息是否为数字
+                    if not msg.isdigit():
+                        await new_event.send(
+                            MessageChain().message("输入异常，结束会话")
+                        )
+                        controller.stop()
+                        return
+                    # 判断数字是否在有效值内
+                    num = int(msg)
+                    if num < 1 or num > data["data"]["num"]:
+                        await new_event.send(
+                            MessageChain().message("无效序号，结束会话")
+                        )
+                        controller.stop()
+                        return
+                    
+                    # 获取二轮数据
+                    try:
+                        data1 = await action2(data["data"]["list"][num])
+                        if data1["code"] != 200:
+                            await new_event.send(
+                                MessageChain().message("获取详细数据失败")
+                            )
+                            controller.stop()
+                            return
+                        
+                        # 消息拼接发送
+                        chain = MessageChain()
+                        msg_text = data1["data"]
+                        chain.message(msg_text)
+                        if data1["temp"] != "":
+                            url = await self.html_render(data1["temp"], {}, options={})
+                            chain.url_image(url)
+                        await new_event.send(chain)
+
+                    except Exception as e:
+                        logger.error(f"功能函数执行错误: {e}")
+                        await new_event.send(
+                            MessageChain().message("猪脑过载，请稍后再试")
+                        )
+
+                    controller.stop()
+
+                # 二轮会话激活
+                try:
+                    await macro_select_waiter(event)  
+                except TimeoutError:
+                    await event.send(event.plain_result("选择超时，已结束会话")) 
+                except Exception:
+                    logger.error("宏选择发生异常", exc_info=True)
+
+            else:
+                await event.send(event.plain_result(f"未搜索到相关内容")) 
+                return
+                
+        except Exception as e:
+            logger.error(f"功能函数执行错误: {e}")
+            await event.send(event.plain_result("猪脑过载，请稍后再试"))
+
+
+    async def jx3_helps(self, event: AstrMessageEvent):
+        """剑三 功能"""
+        return await self.T2I_image_msg(event, self.jx3api.helps)
+
+
+    async def jx3_richang(self, event: AstrMessageEvent,server: str = "" ,num: int = 0):
+        """剑三 日常 服务器 天数"""
+        return await self.plain_msg(event, lambda: self.jx3api.richang(self.serverdefault(server),num))
+
+
+    async def jx3_richangyuche(self, event: AstrMessageEvent):
+        """剑三 日常预测"""
+        return await self.T2I_image_msg(event, self.jx3api.richangyuche)
+
+
+    async def jx3_xingxiashijian(self, event: AstrMessageEvent,name: str = "穹野卫"):
+        """剑三 名望"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.xingxiashijian(name))
+
+
+    async def jx3_kaifu(self, event: AstrMessageEvent,server: str = ""):
+        """剑三 开服 服务器"""
+        return await self.plain_msg(event, lambda: self.jx3api.kaifu(self.serverdefault(server)))
+
+
+    async def jx3_zhuangtai(self, event: AstrMessageEvent):
+        """剑三 状态"""
+        return await self.T2I_image_msg(event, self.jx3api.zhuangtai)
+
+     
+    async def jx3_shaohua(self, event: AstrMessageEvent,):
+        """剑三 骚话"""
+        return await self.plain_msg(event, self.jx3api.shaohua)
+
+
+    async def jx3_jigai(self, event: AstrMessageEvent,):
+        """剑三 技改"""
+        return await self.plain_msg(event, self.jx3api.jigai)
+
+
+    async def jx3_xinwen(self, event: AstrMessageEvent,num:int = 5):
+        """剑三 新闻"""
+        return await self.plain_msg(event, lambda: self.jx3api.xinwen(num))
+ 
+
+    async def jx3_keju(self, event: AstrMessageEvent,subject: str, limit: int = 5):
+        """剑三 科举"""
+        return await self.plain_msg(event, lambda: self.jx3api.keju(subject,limit))
+
+
+    async def jx3_huajia(self, event: AstrMessageEvent,  name: str= "", server: str = "", map: str= ""):
+        """剑三 花价 名称 服务器 地图"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.huajia(self.serverdefault(server),name,map))
+
+
+    async def jx3_zhuangshi(self, event: AstrMessageEvent,  name: str):
+        """剑三 装饰 名称"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.zhuangshi(name))
+
+
+    async def jx3_qiwu(self, event: AstrMessageEvent,  name: str):
+        """剑三 器物 地图名称"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.qiwu(name))
+            
+
+    async def jx3_shapan(self, event: AstrMessageEvent,server: str = ""):
+        """剑三 沙盘 服务器"""
+        return await self.image_msg(event, lambda: self.jx3api.shapan(self.serverdefault(server)))  
+
+
+    async def jx3_qufuqiyu(self, event: AstrMessageEvent,adventureName: str = "阴阳两界", server: str = ""):
+        """剑三 奇遇统计 奇遇名称 服务器"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.qiyu(adventureName,self.serverdefault(server)))
+ 
+
+    async def jx3_qiyugonglue(self, event: AstrMessageEvent,name: str):
+        """剑三 奇遇攻略 奇遇名称"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.qiyugonglue(name))
+
+
+    async def jx3_hong(self, event: AstrMessageEvent,name: str = "易筋经"):
+        """剑三 宏 心法"""
+        return await self.handler_plain_image_msg(event, lambda: self.jx3api.hong1(name), self.jx3api.hong2)
+
+
+    async def jx3_peizhuang(self, event: AstrMessageEvent,name: str = "易筋经", tags: str = ""):
+        """剑三 配装 心法"""
+        return await self.plain_msg(event, lambda: self.jx3api.peizhuang( name,tags))
+
+
+    async def jx3_jinjia(self, event: AstrMessageEvent,server: str = "", limit:str = "15"):
+        """剑三 金价 服务器"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.jinjia( self.serverdefault(server),limit))
+
+
+    async def jx3_wujia(self, event: AstrMessageEvent,Name: str = "秃盒", server: str = ""):
+        """剑三 物价 外观名称"""    
+        return await self.T2I_image_msg(event, lambda: self.jx3api.wujia(Name, self.serverdefault(server))) 
+
+
+    async def jx3_jiaoyihang(self, event: AstrMessageEvent,Name: str = "守缺式",server: str = ""):
+        """剑三 交易行 物品名称 服务器"""     
+        return await self.T2I_image_msg(event, lambda: self.jx3api.jiaoyihang(Name, self.serverdefault(server)))
+
+
+    async def jx3_jueshemingpian(self, event: AstrMessageEvent, name: str = "飞翔大野猪", server: str = ""):
+        """剑三 名片 角色 服务器"""
+        return await self.image_msg(event, lambda: self.jx3api.jueshemingpian( self.serverdefault(server),name)) 
+
+
+    async def jx3_shuijimingpian(self, event: AstrMessageEvent,force: str = "万花", body: str = "萝莉", server: str = ""):
+        """剑三 随机名片 职业 体型 服务器"""
+        return await self.image_msg(event, lambda: self.jx3api.shuijimingpian(force,body, self.serverdefault(server)))
+ 
+
+    async def jx3_yanhuachaxun(self, event: AstrMessageEvent,name: str = "飞翔大野猪", server: str = ""):
+        """剑三 烟花 角色 服务器"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.yanhuachaxun( self.serverdefault(server),name))
+
+
+    async def jx3_dilujilu(self, event: AstrMessageEvent,server: str = ""):
+        """剑三 的卢 服务器"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.dilujilu( self.serverdefault(server)))
+  
+
+    async def jx3_tuanduizhaomu(self, event: AstrMessageEvent,keyword: str = "25人普通会战弓月城", server: str = ""):
+        """剑三 招募 副本 服务器"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.tuanduizhaomu( self.serverdefault(server),keyword))
+
+
+    async def jx3_zhanji(self, event: AstrMessageEvent,name: str = "飞翔大野猪", server: str = "", mode:str = "33"):
+        """剑三 战绩 角色 服务器 类型"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.zhanji(name, self.serverdefault(server),mode))
+
+
+    async def jx3_qiyu(self, event: AstrMessageEvent,name: str = "飞翔大野猪", server: str = ""):
+        """剑三 奇遇 角色名称 服务器"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.juesheqiyu(name, self.serverdefault(server)))
+    
+
+    async def jx3_zhengyingpaimai(self, event: AstrMessageEvent,name: str = "玄晶", server: str = ""):
+        """剑三 阵营拍卖 物品名称 服务器"""
+        return await self.T2I_image_msg(event, lambda: self.jx3api.zhengyingpaimai( self.serverdefault(server), name))
+ 
+
+    async def jx3_fuyaojjiutian(self, event: AstrMessageEvent,server: str = ""):
+        """剑三 扶摇九天 服务器"""
+        return await self.plain_msg(event, lambda: self.jx3api.fuyaojjiutian( self.serverdefault(server)))
+
+
+    async def jx3_shuma(self, event: AstrMessageEvent,server: str = ""): 
+        """剑三 刷马 服务器"""
+        return await self.plain_msg(event, lambda: self.jx3api.shuma( self.serverdefault(server)))
+
+
+    async def jx3_pianzhi(self, event: AstrMessageEvent,qq: str):
+        """剑三 骗子 QQ"""
+        return await self.plain_msg(event, lambda: self.jx3api.pianzhi(qq))
+
+
+    async def jx3_bagua(self, event: AstrMessageEvent,name: str = "818"):
+        """剑三 八卦 类型"""
+        return await self.plain_msg(event, lambda: self.jx3api.bagua(name))
+    
+
+    async def bilei_add(self, event: AstrMessageEvent,name: str, text: str):
+        """避雷添加 名称 备注"""
+        return await self.plain_msg(event, lambda: self.bilei.add(name,text,event.get_sender_name()))
+    
+
+    async def bilei_all(self, event: AstrMessageEvent):
+        """避雷查看"""
+        return await self.T2I_image_msg(event, self.bilei.all)
+    
+
+    async def bilei_select(self, event: AstrMessageEvent, name:str):
+        """避雷查询"""
+        return await self.T2I_image_msg(event, lambda: self.bilei.select(name))
+
+
+    async def bilei_update(self, event: AstrMessageEvent, id:int, name: str, text: str):
+        """避雷修改 ID 名称 备注"""
+        return await self.plain_msg(event, lambda: self.bilei.update(id,name,text,event.get_sender_name()))
+
+
+    async def bilei_delete(self, event: AstrMessageEvent, id:int):
+        """避雷删除 ID"""
+        return await self.plain_msg(event, lambda: self.bilei.delete(id))
+
+
+    async def jx3_kaifhujiank(self, event: AstrMessageEvent):
+        """剑三 开服监控"""     
+        return_msg = await self.jx3at.get_task_info("kfts")
+        await event.send(event.plain_result(return_msg)) 
+
+
+    async def jx3_xinwenzhixun(self, event: AstrMessageEvent):
+        """剑三 新闻推送"""     
+        return_msg = await self.jx3at.get_task_info("xwts")
+        await event.send(event.plain_result(return_msg)) 
+
+
+    async def jx3_shuamamsg(self, event: AstrMessageEvent):
+        """剑三 刷马推送"""     
+        return_msg = await self.jx3at.get_task_info("smts")
+        await event.send(event.plain_result(return_msg)) 
+
+
+    async def jx3_chitusg(self, event: AstrMessageEvent):
+        """剑三 赤兔推送"""     
+        return_msg = await self.jx3at.get_task_info("ctts")
+        await event.send(event.plain_result(return_msg)) 

core/sqlite.py

@@ -8,10 +8,18 @@ class AsyncSQLiteDB:
     def __init__(self, db_path: str = "data.db"):
         self.db_path = db_path
         self.conn: Optional[aiosqlite.Connection] = None
+        
 
     # ======================
     # 生命周期
     # ======================
+    
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.close()
 
     async def connect(self):
         self.conn = await aiosqlite.connect(self.db_path)