fix download message

- 在更新系统配置时，使用 deepcopy 复制新值以避免内存共享

.github/workflows/build.yml

@@ -25,7 +25,9 @@ jobs:
         id: meta
         uses: docker/metadata-action@v5
         with:
-          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+          images: |
+            ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+            ghcr.io/${{ github.repository }}
           tags: |
             type=raw,value=${{ env.app_version }}
             type=raw,value=latest
@@ -42,6 +44,13 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
+      - name: Login GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
       - name: Build Image
         uses: docker/build-push-action@v5
         with:

.github/workflows/issues.yml

@@ -0,0 +1,30 @@
+name: Close inactive issues
+on:
+ workflow_dispatch:
+
+ schedule:
+   # Github Action 只支持 UTC 时间。
+   # '0 18 * * *' 对应 UTC 时间的 18:00，也就是中国时区 (UTC+8) 的第二天凌晨 02:00。
+   - cron: "0 18 * * *"
+
+jobs:
+ close-issues:
+   runs-on: ubuntu-latest
+   permissions:
+     issues: write
+     pull-requests: write
+   steps:
+     - uses: actions/stale@v5
+       with:
+         # 标记 stale 标签时间
+         days-before-issue-stale: 30
+         # 关闭 issues 标签时间
+         days-before-issue-close: 14
+         # 自定义标签名
+         stale-issue-label: "stale"
+         stale-issue-message: "此问题已过时，因为它已打开 30 天且没有任何活动。"
+         close-issue-message: "此问题已关闭，因为它在标记为 stale 后，已处于无更新状态 14 天。"
+         # 忽略所有的 Pull Request，只处理 Issue
+         days-before-pr-stale: -1
+         days-before-pr-close: -1
+         repo-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pylint.yml

@@ -1,16 +1,6 @@
 name: Pylint Code Quality Check
 
 on:
-  # 在推送到任何分支时运行
-  push:
-    branches: [ "main", "v2", "develop" ]
-    paths:
-      - '**.py'
-  # 在PR时运行
-  pull_request:
-    branches: [ "main", "v2", "develop" ]
-    paths:
-      - '**.py'
   # 允许手动触发
   workflow_dispatch:
 
@@ -24,12 +14,13 @@ jobs:
       uses: actions/checkout@v4
       
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
-        python-version: '3.11'
+        python-version: '3.12'
+        cache: 'pip'
         
     - name: Cache pip dependencies
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: ~/.cache/pip
         key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt', '**/requirements.in') }}
@@ -38,13 +29,17 @@ jobs:
           
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
+        python -m pip install --upgrade pip setuptools wheel
         pip install pylint
         # 安装项目依赖
         if [ -f requirements.txt ]; then
+          echo "📦 安装 requirements.txt 中的依赖..."
           pip install -r requirements.txt
         elif [ -f requirements.in ]; then
+          echo "📦 安装 requirements.in 中的依赖..."
           pip install -r requirements.in
+        else
+          echo "⚠️ 未找到依赖文件，仅安装 pylint"
         fi
         
     - name: Verify pylint config
@@ -83,7 +78,7 @@ jobs:
         pylint app/ --score=yes --reports=no | tail -2 || true
         
     - name: Upload pylint report
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       if: always()
       with:
         name: pylint-report

app/actions/add_download.py

@@ -26,37 +26,31 @@ class AddDownloadAction(BaseAction):
     添加下载资源
     """
 
-    # 已添加的下载
-    _added_downloads = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.downloadchain = DownloadChain()
-        self.mediachain = MediaChain()
         self._added_downloads = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "添加下载"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "根据资源列表添加下载任务"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return AddDownloadParams().dict()
 
     @property
     def success(self) -> bool:
         return not self._has_error
 
-    def execute(self, workflow_id: int,  params: dict, context: ActionContext) -> ActionContext:
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
         """
         将上下文中的torrents添加到下载任务中
         """
@@ -73,13 +67,13 @@ class AddDownloadAction(BaseAction):
             if not t.meta_info:
                 t.meta_info = MetaInfo(title=t.torrent_info.title, subtitle=t.torrent_info.description)
             if not t.media_info:
-                t.media_info = self.mediachain.recognize_media(meta=t.meta_info)
+                t.media_info = MediaChain().recognize_media(meta=t.meta_info)
             if not t.media_info:
                 self._has_error = True
                 logger.warning(f"{t.torrent_info.title} 未识别到媒体信息，无法下载")
                 continue
             if params.only_lack:
-                exists_info = self.downloadchain.media_exists(t.media_info)
+                exists_info = DownloadChain().media_exists(t.media_info)
                 if exists_info:
                     if t.media_info.type == MediaType.MOVIE:
                         # 电影
@@ -96,14 +90,15 @@ class AddDownloadAction(BaseAction):
                             exists_episodes = exists_seasons.get(t.meta_info.begin_season)
                             if exists_episodes:
                                 if set(t.meta_info.episode_list).issubset(exists_episodes):
-                                    logger.warning(f"{t.meta_info.title} 第 {t.meta_info.begin_season} 季第 {t.meta_info.episode_list} 集已存在，跳过")
+                                    logger.warning(
+                                        f"{t.meta_info.title} 第 {t.meta_info.begin_season} 季第 {t.meta_info.episode_list} 集已存在，跳过")
                                     continue
 
             _started = True
-            did = self.downloadchain.download_single(context=t,
-                                                     downloader=params.downloader,
-                                                     save_path=params.save_path,
-                                                     label=params.labels)
+            did = DownloadChain().download_single(context=t,
+                                                  downloader=params.downloader,
+                                                  save_path=params.save_path,
+                                                  label=params.labels)
             if did:
                 self._added_downloads.append(did)
                 # 保存缓存

app/actions/add_subscribe.py

@@ -19,29 +19,24 @@ class AddSubscribeAction(BaseAction):
     添加订阅
     """
 
-    _added_subscribes = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.subscribechain = SubscribeChain()
-        self.subscribeoper = SubscribeOper()
         self._added_subscribes = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "添加订阅"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "根据媒体列表添加订阅"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return AddSubscribeParams().dict()
 
     @property
@@ -63,19 +58,20 @@ class AddSubscribeAction(BaseAction):
                 continue
             mediainfo = MediaInfo()
             mediainfo.from_dict(media.dict())
-            if self.subscribechain.exists(mediainfo):
+            subscribechain = SubscribeChain()
+            if subscribechain.exists(mediainfo):
                 logger.info(f"{media.title} 已存在订阅")
                 continue
             # 添加订阅
             _started = True
-            sid, message = self.subscribechain.add(mtype=mediainfo.type,
-                                                   title=mediainfo.title,
-                                                   year=mediainfo.year,
-                                                   tmdbid=mediainfo.tmdb_id,
-                                                   season=mediainfo.season,
-                                                   doubanid=mediainfo.douban_id,
-                                                   bangumiid=mediainfo.bangumi_id,
-                                                   username=settings.SUPERUSER)
+            sid, message = subscribechain.add(mtype=mediainfo.type,
+                                              title=mediainfo.title,
+                                              year=mediainfo.year,
+                                              tmdbid=mediainfo.tmdb_id,
+                                              season=mediainfo.season,
+                                              doubanid=mediainfo.douban_id,
+                                              bangumiid=mediainfo.bangumi_id,
+                                              username=settings.SUPERUSER)
             if sid:
                 self._added_subscribes.append(sid)
                 # 保存缓存
@@ -84,7 +80,7 @@ class AddSubscribeAction(BaseAction):
         if self._added_subscribes:
             logger.info(f"已添加 {len(self._added_subscribes)} 个订阅")
             for sid in self._added_subscribes:
-                context.subscribes.append(self.subscribeoper.get(sid))
+                context.subscribes.append(SubscribeOper().get(sid))
         elif _started:
             self._has_error = True
 

app/actions/fetch_downloads.py

@@ -16,11 +16,8 @@ class FetchDownloadsAction(BaseAction):
     获取下载任务
     """
 
-    _downloads = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.chain = ActionChain()
         self._downloads = []
 
     @classmethod
@@ -51,7 +48,7 @@ class FetchDownloadsAction(BaseAction):
             if global_vars.is_workflow_stopped(workflow_id):
                 break
             logger.info(f"获取下载任务 {download.download_id} 状态 ...")
-            torrents = self.chain.list_torrents(hashs=[download.download_id])
+            torrents = ActionChain().list_torrents(hashs=[download.download_id])
             if not torrents:
                 download.completed = True
                 continue

app/actions/fetch_medias.py

@@ -27,10 +27,6 @@ class FetchMediasAction(BaseAction):
     获取媒体数据
     """
 
-    _inner_sources = []
-    _medias = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
 

app/actions/fetch_rss.py

@@ -29,29 +29,24 @@ class FetchRssAction(BaseAction):
     获取RSS资源列表
     """
 
-    _rss_torrents = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.rsshelper = RssHelper()
-        self.chain = ActionChain()
         self._rss_torrents = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "获取RSS资源"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "订阅RSS地址获取资源"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return FetchRssParams().dict()
 
     @property
@@ -74,10 +69,10 @@ class FetchRssAction(BaseAction):
         if params.ua:
             headers["User-Agent"] = params.ua
 
-        rss_items = self.rsshelper.parse(url=params.url,
-                                         proxy=settings.PROXY if params.proxy else None,
-                                         timeout=params.timeout,
-                                         headers=headers)
+        rss_items = RssHelper().parse(url=params.url,
+                                      proxy=settings.PROXY if params.proxy else None,
+                                      timeout=params.timeout,
+                                      headers=headers)
         if rss_items is None or rss_items is False:
             logger.error(f'RSS地址 {params.url} 请求失败！')
             self._has_error = True
@@ -103,7 +98,7 @@ class FetchRssAction(BaseAction):
             meta = MetaInfo(title=torrentinfo.title, subtitle=torrentinfo.description)
             mediainfo = None
             if params.match_media:
-                mediainfo = self.chain.recognize_media(meta)
+                mediainfo = ActionChain().recognize_media(meta)
                 if not mediainfo:
                     logger.warning(f"{torrentinfo.title} 未识别到媒体信息")
                     continue

app/actions/fetch_torrents.py

@@ -29,26 +29,23 @@ class FetchTorrentsAction(BaseAction):
     搜索站点资源
     """
 
-    _torrents = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.searchchain = SearchChain()
         self._torrents = []
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "搜索站点资源"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "搜索站点种子资源列表"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return FetchTorrentsParams().dict()
 
     @property
@@ -60,9 +57,10 @@ class FetchTorrentsAction(BaseAction):
         搜索站点，获取资源列表
         """
         params = FetchTorrentsParams(**params)
+        searchchain = SearchChain()
         if params.search_type == "keyword":
             # 按关键字搜索
-            torrents = self.searchchain.search_by_title(title=params.name, sites=params.sites)
+            torrents = searchchain.search_by_title(title=params.name, sites=params.sites)
             for torrent in torrents:
                 if global_vars.is_workflow_stopped(workflow_id):
                     break
@@ -74,7 +72,7 @@ class FetchTorrentsAction(BaseAction):
                     continue
                 # 识别媒体信息
                 if params.match_media:
-                    torrent.media_info = self.searchchain.recognize_media(torrent.meta_info)
+                    torrent.media_info = searchchain.recognize_media(torrent.meta_info)
                     if not torrent.media_info:
                         logger.warning(f"{torrent.torrent_info.title} 未识别到媒体信息")
                         continue
@@ -84,10 +82,10 @@ class FetchTorrentsAction(BaseAction):
             for media in context.medias:
                 if global_vars.is_workflow_stopped(workflow_id):
                     break
-                torrents = self.searchchain.search_by_id(tmdbid=media.tmdb_id,
-                                                         doubanid=media.douban_id,
-                                                         mtype=MediaType(media.type),
-                                                         sites=params.sites)
+                torrents = searchchain.search_by_id(tmdbid=media.tmdb_id,
+                                                    doubanid=media.douban_id,
+                                                    mtype=MediaType(media.type),
+                                                    sites=params.sites)
                 for torrent in torrents:
                     self._torrents.append(torrent)
 

app/actions/filter_medias.py

@@ -22,8 +22,6 @@ class FilterMediasAction(BaseAction):
     过滤媒体数据
     """
 
-    _medias = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
         self._medias = []

app/actions/filter_torrents.py

@@ -27,12 +27,8 @@ class FilterTorrentsAction(BaseAction):
     过滤资源数据
     """
 
-    _torrents = []
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.torrenthelper = TorrentHelper()
-        self.chain = ActionChain()
         self._torrents = []
 
     @classmethod
@@ -62,7 +58,7 @@ class FilterTorrentsAction(BaseAction):
         for torrent in context.torrents:
             if global_vars.is_workflow_stopped(workflow_id):
                 break
-            if self.torrenthelper.filter_torrent(
+            if TorrentHelper().filter_torrent(
                     torrent_info=torrent.torrent_info,
                     filter_params={
                         "quality": params.quality,
@@ -73,7 +69,7 @@ class FilterTorrentsAction(BaseAction):
                         "size": params.size
                     }
             ):
-                if self.chain.filter_torrents(
+                if ActionChain().filter_torrents(
                         rule_groups=params.rule_groups,
                         torrent_list=[torrent.torrent_info],
                         mediainfo=torrent.media_info

app/actions/invoke_plugin.py

@@ -20,8 +20,6 @@ class InvokePluginAction(BaseAction):
     调用插件
     """
 
-    _success = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
         self._success = False

app/actions/scan_file.py

@@ -24,12 +24,8 @@ class ScanFileAction(BaseAction):
     整理文件
     """
 
-    _fileitems = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.storagechain = StorageChain()
         self._fileitems = []
         self._has_error = False
 
@@ -59,12 +55,13 @@ class ScanFileAction(BaseAction):
         params = ScanFileParams(**params)
         if not params.storage or not params.directory:
             return context
-        fileitem = self.storagechain.get_file_item(params.storage, Path(params.directory))
+        storagechain = StorageChain()
+        fileitem = storagechain.get_file_item(params.storage, Path(params.directory))
         if not fileitem:
             logger.error(f"目录不存在: 【{params.storage}】{params.directory}")
             self._has_error = True
             return context
-        files = self.storagechain.list_files(fileitem, recursion=True)
+        files = storagechain.list_files(fileitem, recursion=True)
         for file in files:
             if global_vars.is_workflow_stopped(workflow_id):
                 break

app/actions/scrape_file.py

@@ -21,13 +21,8 @@ class ScrapeFileAction(BaseAction):
     刮削文件
     """
 
-    _scraped_files = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.storagechain = StorageChain()
-        self.mediachain = MediaChain()
         self._scraped_files = []
         self._has_error = False
 
@@ -61,7 +56,7 @@ class ScrapeFileAction(BaseAction):
                 break
             if fileitem in self._scraped_files:
                 continue
-            if not self.storagechain.exists(fileitem):
+            if not StorageChain().exists(fileitem):
                 continue
             # 检查缓存
             cache_key = f"{fileitem.path}"
@@ -69,12 +64,13 @@ class ScrapeFileAction(BaseAction):
                 logger.info(f"{fileitem.path} 已刮削过，跳过")
                 continue
             meta = MetaInfoPath(Path(fileitem.path))
-            mediainfo = self.mediachain.recognize_media(meta)
+            mediachain = MediaChain()
+            mediainfo = mediachain.recognize_media(meta)
             if not mediainfo:
                 _failed_count += 1
                 logger.info(f"{fileitem.path} 未识别到媒体信息，无法刮削")
                 continue
-            self.mediachain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
+            mediachain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
             self._scraped_files.append(fileitem)
             # 保存缓存
             self.save_cache(workflow_id, cache_key)

app/actions/send_message.py

@@ -4,7 +4,7 @@ from pydantic import Field
 
 from app.actions import BaseAction, ActionChain
 from app.schemas import ActionParams, ActionContext, Notification
-from core.config import settings
+from app.core.config import settings
 
 
 class SendMessageParams(ActionParams):
@@ -22,7 +22,6 @@ class SendMessageAction(BaseAction):
 
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.chain = ActionChain()
 
     @classmethod
     @property
@@ -60,7 +59,7 @@ class SendMessageAction(BaseAction):
             if not params.client:
                 params.client = [""]
             for client in params.client:
-                self.chain.post_message(
+                ActionChain().post_message(
                     Notification(
                         source=client,
                         userid=params.userid,

app/actions/transfer_file.py

@@ -26,30 +26,24 @@ class TransferFileAction(BaseAction):
     整理文件
     """
 
-    _fileitems = []
-    _has_error = False
-
     def __init__(self, action_id: str):
         super().__init__(action_id)
-        self.transferchain = TransferChain()
-        self.storagechain = StorageChain()
-        self.transferhis = TransferHistoryOper()
         self._fileitems = []
         self._has_error = False
 
     @classmethod
     @property
-    def name(cls) -> str: # noqa
+    def name(cls) -> str:  # noqa
         return "整理文件"
 
     @classmethod
     @property
-    def description(cls) -> str: # noqa
+    def description(cls) -> str:  # noqa
         return "整理队列中的文件"
 
     @classmethod
     @property
-    def data(cls) -> dict: # noqa
+    def data(cls) -> dict:  # noqa
         return TransferFileParams().dict()
 
     @property
@@ -72,6 +66,9 @@ class TransferFileAction(BaseAction):
         params = TransferFileParams(**params)
         # 失败次数
         _failed_count = 0
+        storagechain = StorageChain()
+        transferchain = TransferChain()
+        transferhis = TransferHistoryOper()
         if params.source == "downloads":
             # 从下载任务中整理文件
             for download in context.downloads:
@@ -85,16 +82,16 @@ class TransferFileAction(BaseAction):
                 if self.check_cache(workflow_id, cache_key):
                     logger.info(f"{download.path} 已整理过，跳过")
                     continue
-                fileitem = self.storagechain.get_file_item(storage="local", path=Path(download.path))
+                fileitem = storagechain.get_file_item(storage="local", path=Path(download.path))
                 if not fileitem:
                     logger.info(f"文件 {download.path} 不存在")
                     continue
-                transferd = self.transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                transferd = transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
                 if transferd:
                     # 已经整理过的文件不再整理
                     continue
                 logger.info(f"开始整理文件 {download.path} ...")
-                state, errmsg = self.transferchain.do_transfer(fileitem, background=False)
+                state, errmsg = transferchain.do_transfer(fileitem, background=False)
                 if not state:
                     _failed_count += 1
                     logger.error(f"整理文件 {download.path} 失败: {errmsg}")
@@ -112,13 +109,13 @@ class TransferFileAction(BaseAction):
                 if self.check_cache(workflow_id, cache_key):
                     logger.info(f"{fileitem.path} 已整理过，跳过")
                     continue
-                transferd = self.transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                transferd = transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
                 if transferd:
                     # 已经整理过的文件不再整理
                     continue
                 logger.info(f"开始整理文件 {fileitem.path} ...")
-                state, errmsg = self.transferchain.do_transfer(fileitem, background=False,
-                                                               continue_callback=check_continue)
+                state, errmsg = transferchain.do_transfer(fileitem, background=False,
+                                                          continue_callback=check_continue)
                 if not state:
                     _failed_count += 1
                     logger.error(f"整理文件 {fileitem.path} 失败: {errmsg}")

app/api/endpoints/discover.py

@@ -7,9 +7,9 @@ from app.core.event import eventmanager
 from app.core.security import verify_token
 from app.schemas import DiscoverSourceEventData
 from app.schemas.types import ChainEventType, MediaType
-from chain.bangumi import BangumiChain
-from chain.douban import DoubanChain
-from chain.tmdb import TmdbChain
+from app.chain.bangumi import BangumiChain
+from app.chain.douban import DoubanChain
+from app.chain.tmdb import TmdbChain
 
 router = APIRouter()
 

app/api/endpoints/download.py

@@ -94,22 +94,22 @@ def add(
 
 @router.get("/start/{hashString}", summary="开始任务", response_model=schemas.Response)
 def start(
-        hashString: str,
+        hashString: str, name: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     开如下载任务
     """
-    ret = DownloadChain().set_downloading(hashString, "start")
+    ret = DownloadChain().set_downloading(hashString, "start", name=name)
     return schemas.Response(success=True if ret else False)
 
 
 @router.get("/stop/{hashString}", summary="暂停任务", response_model=schemas.Response)
-def stop(hashString: str,
+def stop(hashString: str, name: Optional[str] = None,
          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     暂停下载任务
     """
-    ret = DownloadChain().set_downloading(hashString, "stop")
+    ret = DownloadChain().set_downloading(hashString, "stop", name=name)
     return schemas.Response(success=True if ret else False)
 
 
@@ -125,10 +125,10 @@ def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.delete("/{hashString}", summary="删除下载任务", response_model=schemas.Response)
-def delete(hashString: str,
+def delete(hashString: str, name: Optional[str] = None,
            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     删除下载任务
     """
-    ret = DownloadChain().remove_downloading(hashString)
+    ret = DownloadChain().remove_downloading(hashString, name=name)
     return schemas.Response(success=True if ret else False)

app/api/endpoints/history.py

@@ -1,12 +1,10 @@
 from typing import List, Any, Optional
 
-import jieba
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.storage import StorageChain
-from app.core.config import settings
 from app.core.event import eventmanager
 from app.core.security import verify_token
 from app.db import get_db
@@ -59,9 +57,6 @@ def transfer_history(title: Optional[str] = None,
         status = True
 
     if title:
-        if settings.TOKENIZED_SEARCH:
-            words = jieba.cut(title, HMM=False)
-            title = "%".join(words)
         total = TransferHistory.count_by_title(db, title=title, status=status)
         result = TransferHistory.list_by_title(db, title=title, page=page,
                                                count=count, status=status)

app/api/endpoints/login.py

@@ -43,7 +43,8 @@ def login_access_token(
         user_id=user_or_message.id,
         user_name=user_or_message.name,
         avatar=user_or_message.avatar,
-        level=level
+        level=level,
+        permissions= user_or_message.permissions or {},
     )
 
 

app/api/endpoints/plugin.py

@@ -137,7 +137,7 @@ def register_plugin(plugin_id: str):
 
 @router.get("/", summary="所有插件", response_model=List[schemas.Plugin])
 def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
-                state: Optional[str] = "all") -> List[schemas.Plugin]:
+                state: Optional[str] = "all", force: bool = False) -> List[schemas.Plugin]:
     """
     查询所有插件清单，包括本地插件和在线插件，插件状态：installed, market, all
     """
@@ -151,7 +151,7 @@ def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
     # 未安装的本地插件
     not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
     # 在线插件
-    online_plugins = PluginManager().get_online_plugins()
+    online_plugins = PluginManager().get_online_plugins(force)
     if not online_plugins:
         # 没有获取在线插件
         if state == "market":
@@ -348,7 +348,7 @@ def plugin_static_file(plugin_id: str, filepath: str):
     获取插件静态文件
     """
     # 基础安全检查
-    if ".." in filepath or ".." in filepath:
+    if ".." in filepath or ".." in plugin_id:
         logger.warning(f"Static File API: Path traversal attempt detected: {plugin_id}/{filepath}")
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
 

app/api/endpoints/system.py

@@ -1,6 +1,7 @@
 import asyncio
 import io
 import json
+import re
 import tempfile
 from collections import deque
 from datetime import datetime
@@ -225,7 +226,7 @@ def set_env_setting(env: dict,
     if failed_updates:
         return schemas.Response(
             success=False,
-            message=f"{', '.join(failed_updates.keys())} 配置项更新失败",
+            message=f"{', '.join([v[1] for v in failed_updates.values()])}",
             data={
                 "success_updates": success_updates,
                 "failed_updates": failed_updates
@@ -446,30 +447,55 @@ def ruletest(title: str,
 
 
 @router.get("/nettest", summary="测试网络连通性")
-def nettest(url: str,
-            proxy: bool,
-            _: schemas.TokenPayload = Depends(verify_token)):
+def nettest(
+    url: str,
+    proxy: bool,
+    include: Optional[str] = None,
+    _: schemas.TokenPayload = Depends(verify_token),
+):
     """
     测试网络连通性
     """
     # 记录开始的毫秒数
     start_time = datetime.now()
+    headers = None
+    if "github" in url or "{GITHUB_PROXY}" in url:
+        # 这是github的连通性测试
+        url = url.replace(
+            "{GITHUB_PROXY}", UrlUtils.standardize_base_url(settings.GITHUB_PROXY or "")
+        )
+        headers = settings.GITHUB_HEADERS
     url = url.replace("{TMDBAPIKEY}", settings.TMDB_API_KEY)
-    result = RequestUtils(proxies=settings.PROXY if proxy else None,
-                          ua=settings.USER_AGENT).get_res(url)
+    url = url.replace(
+        "{PIP_PROXY}",
+        UrlUtils.standardize_base_url(settings.PIP_PROXY or "https://pypi.org/simple/"),
+    )
+    result = RequestUtils(
+        proxies=settings.PROXY if proxy else None,
+        headers=headers,
+        timeout=10,
+        ua=settings.USER_AGENT,
+    ).get_res(url)
     # 计时结束的毫秒数
     end_time = datetime.now()
+    time = round((end_time - start_time).total_seconds() * 1000)
     # 计算相关秒数
-    if result and result.status_code == 200:
-        return schemas.Response(success=True, data={
-            "time": round((end_time - start_time).microseconds / 1000)
-        })
-    elif result:
-        return schemas.Response(success=False, message=f"错误码：{result.status_code}", data={
-            "time": round((end_time - start_time).microseconds / 1000)
-        })
+    if result is None:
+        return schemas.Response(success=False, message="无法连接", data={"time": time})
+    elif result.status_code == 200:
+        if include and not re.search(r"%s" % include, result.text, re.IGNORECASE):
+            # 通常是被加速代理跳转到其它页面了
+            logger.error(f"{url} 的响应内容不匹配包含规则 {include}")
+            return schemas.Response(
+                success=False,
+                message=f"无效响应，不匹配 {include}",
+                data={"time": time},
+            )
+        return schemas.Response(success=True, data={"time": time})
     else:
-        return schemas.Response(success=False, message="网络连接失败！")
+        return schemas.Response(
+            success=False, message=f"错误码：{result.status_code}", data={"time": time}
+        )
 
 
 @router.get("/modulelist", summary="查询已加载的模块ID列表", response_model=schemas.Response)

app/chain/__init__.py

@@ -1,5 +1,4 @@
 import copy
-import gc
 import pickle
 import traceback
 from abc import ABCMeta
@@ -69,10 +68,6 @@ class ChainBase(metaclass=ABCMeta):
                 pickle.dump(cache, f)  # noqa
         except Exception as err:
             logger.error(f"保存缓存 {filename} 出错：{str(err)}")
-        finally:
-            # 主动资源回收
-            del cache
-            gc.collect()
 
     @staticmethod
     def remove_cache(filename: str) -> None:
@@ -617,7 +612,8 @@ class ChainBase(metaclass=ABCMeta):
         # 发送消息事件
         self.eventmanager.send_event(etype=EventType.NoticeMessage, data={**message.dict(), "type": message.mtype})
         # 按原消息发送
-        self.messagequeue.send_message("post_message", message=message)
+        self.messagequeue.send_message("post_message", message=message,
+                                       immediately=True if message.userid else False)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
@@ -629,7 +625,8 @@ class ChainBase(metaclass=ABCMeta):
         note_list = [media.to_dict() for media in medias]
         self.messagehelper.put(message, role="user", note=note_list, title=message.title)
         self.messageoper.add(**message.dict(), note=note_list)
-        return self.messagequeue.send_message("post_medias_message", message=message, medias=medias)
+        return self.messagequeue.send_message("post_medias_message", message=message, medias=medias,
+                                              immediately=True if message.userid else False)
 
     def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
@@ -641,7 +638,8 @@ class ChainBase(metaclass=ABCMeta):
         note_list = [torrent.torrent_info.to_dict() for torrent in torrents]
         self.messagehelper.put(message, role="user", note=note_list, title=message.title)
         self.messageoper.add(**message.dict(), note=note_list)
-        return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents)
+        return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents,
+                                              immediately=True if message.userid else False)
 
     def metadata_img(self, mediainfo: MediaInfo,
                      season: Optional[int] = None, episode: Optional[int] = None) -> Optional[dict]:

app/chain/download.py

@@ -324,10 +324,12 @@ class DownloadChain(ChainBase):
             self.post_message(
                 Notification(
                     channel=channel,
+                    source=source if channel else None,
                     mtype=NotificationType.Download,
                     ctype=ContentType.DownloadAdded,
                     image=_media.get_message_image(),
                     link=settings.MP_DOMAIN('/#/downloading'),
+                    userid=userid,
                     username=username
                 ),
                 meta=_meta,
@@ -445,19 +447,6 @@ class DownloadChain(ChainBase):
                 return 9999
             return no_exist[season].total_episode
 
-        def _calculate_intersection_ratio(episodes_set: set, target_set: set) -> Tuple[float, set]:
-            """
-            计算种子与目标缺失集之间的交集比例。
-            :param episodes_set (Set[int]): 当前种子的集数集合。
-            :param target_set (Set[int]): 当前季缺失的集数集合。
-            :return: Tuple[float, Set[int]]: - 交集比例（0~1）- 交集集合（Set[int]）
-            """
-            cal_intersection = episodes_set & target_set
-            if not cal_intersection:
-                return 0.0, set()
-            cal_ratio = len(cal_intersection) / len(episodes_set)
-            return cal_ratio, cal_intersection
-
         # 发送资源选择事件，允许外部修改上下文数据
         logger.debug(f"Initial contexts: {len(contexts)} items, Downloader: {downloader}")
         event_data = ResourceSelectionEventData(
@@ -616,8 +605,6 @@ class DownloadChain(ChainBase):
                     # 缺失整季的转化为缺失集进行比较
                     if not need_episodes:
                         need_episodes = list(range(start_episode, total_episode + 1))
-                    # 计算每个种子的集数与缺失集数的交集比例 shaw
-                    torrent_ratios = []
                     # 循环种子
                     for context in contexts:
                         if global_vars.is_system_stopped:
@@ -644,54 +631,24 @@ class DownloadChain(ChainBase):
                             # 整季的不处理
                             if not torrent_episodes:
                                 continue
-                            # 计算交集
-                            # 若种子[5-10],[7-10],[9-10]  need_episodes=[9,10,11,12,13,14]
-                            # 计算后的交集比例( len(torrent_episodes ∩ need_episodes) / len(torrent_episodes)  )分别  0.33 0.66  1.0
-                            ratio, intersection = _calculate_intersection_ratio(torrent_episodes, set(need_episodes))
-                            if ratio <= (settings.EPISODE_INTERSECTION_MIN_CONFIDENCE or 0.05):
-                                # 可以设定阈值
-                                logger.info(
-                                    f"{context.meta_info.title} 与当前缺失集数交集比例过低：{ratio:.2%}，跳过")
-                                continue
-
-                            # 收集候选种子
-                            torrent_ratios.append((context, ratio, len(intersection)))
-                    if not torrent_ratios:
-                        continue
-                    # 按交集比例排序
-                    torrent_ratios.sort(key=lambda x: (x[1], x[2]), reverse=True)
-                    # 按排序后的顺序下载
-                    for context, _, _ in torrent_ratios:
-                        if global_vars.is_system_stopped:
-                            break
-                        # 重新计算与当前need_episodes的交集比例
-                        current_episodes = set(context.meta_info.episode_list)
-                        current_ratio, current_intersection = _calculate_intersection_ratio(current_episodes,
-                                                                                            set(need_episodes))
-                        if current_ratio <= (settings.EPISODE_INTERSECTION_MIN_CONFIDENCE or 0.05):
-                            # 可以设定阈值
-                            logger.info(
-                                f"{context.meta_info.title} 与当前缺失集数交集比例过低：{current_ratio:.2%}，跳过")
-                            continue
-                        # 下载
-                        logger.info(f"开始下载 {context.meta_info.title} ...")
-                        download_id = self.download_single(context, save_path=save_path,
-                                                           channel=channel, source=source,
-                                                           userid=userid, username=username,
-                                                           downloader=downloader)
-                        if download_id:
-                            # 下载成功
-                            logger.info(f"{context.meta_info.title} 添加下载成功")
-                            downloaded_list.append(context)
-                            # 更新仍需集数
-                            need_episodes = __update_episodes(_mid=need_mid,
-                                                              _need=need_episodes,
-                                                              _sea=need_season,
-                                                              _current=current_intersection)
-                            logger.info(f"季 {need_season} 剩余需要集：{need_episodes}")
-                            # 如果已经没有需要下载的集数，跳出当前循环
-                            if not need_episodes:
-                                break
+                            # 为需要集的子集则下载
+                            if torrent_episodes.issubset(set(need_episodes)):
+                                # 下载
+                                logger.info(f"开始下载 {meta.title} ...")
+                                download_id = self.download_single(context, save_path=save_path,
+                                                                   channel=channel, source=source,
+                                                                   userid=userid, username=username,
+                                                                   downloader=downloader)
+                                if download_id:
+                                    # 下载成功
+                                    logger.info(f"{meta.title} 添加下载成功")
+                                    downloaded_list.append(context)
+                                    # 更新仍需集数
+                                    need_episodes = __update_episodes(_mid=need_mid,
+                                                                      _need=need_episodes,
+                                                                      _sea=need_season,
+                                                                      _current=torrent_episodes)
+                                    logger.info(f"季 {need_season} 剩余需要集：{need_episodes}")
 
         # 仍然缺失的剧集，从整季中选择需要的集数文件下载，仅支持QB和TR
         if no_exists:
@@ -841,7 +798,6 @@ class DownloadChain(ChainBase):
             totals = {}
 
         mediaserver = MediaServerOper()
-
         if mediainfo.type == MediaType.MOVIE:
             # 电影
             itemid = mediaserver.get_item_id(mtype=mediainfo.type.value,
@@ -985,21 +941,21 @@ class DownloadChain(ChainBase):
             ret_torrents.append(torrent)
         return ret_torrents
 
-    def set_downloading(self, hash_str, oper: str) -> bool:
+    def set_downloading(self, hash_str, oper: str, name: Optional[str] = None) -> bool:
         """
         控制下载任务 start/stop
         """
         if oper == "start":
-            return self.start_torrents(hashs=[hash_str])
+            return self.start_torrents(hashs=[hash_str], downloader=name)
         elif oper == "stop":
-            return self.stop_torrents(hashs=[hash_str])
+            return self.stop_torrents(hashs=[hash_str], downloader=name)
         return False
 
-    def remove_downloading(self, hash_str: str) -> bool:
+    def remove_downloading(self, hash_str: str, name: Optional[str] = None) -> bool:
         """
         删除下载任务
         """
-        return self.remove_torrents(hashs=[hash_str])
+        return self.remove_torrents(hashs=[hash_str], downloader=name)
 
     @eventmanager.register(EventType.DownloadFileDeleted)
     def download_file_deleted(self, event: Event):

app/chain/media.py

@@ -10,9 +10,10 @@ from app.core.context import Context, MediaInfo
 from app.core.event import eventmanager, Event
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo, MetaInfoPath
+from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.schemas import FileItem
-from app.schemas.types import EventType, MediaType, ChainEventType
+from app.schemas.types import EventType, MediaType, ChainEventType, SystemConfigKey
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
@@ -26,6 +27,49 @@ class MediaChain(ChainBase):
     媒体信息处理链，单例运行
     """
 
+    @staticmethod
+    def _get_scraping_switchs() -> dict:
+        """
+        获取刮削开关配置
+        """
+        switchs = SystemConfigOper().get(SystemConfigKey.ScrapingSwitchs) or {}
+        # 默认配置
+        default_switchs = {
+            'movie_nfo': True,          # 电影NFO
+            'movie_poster': True,       # 电影海报
+            'movie_backdrop': True,     # 电影背景图
+            'movie_logo': True,         # 电影Logo
+            'movie_disc': True,         # 电影光盘图
+            'movie_banner': True,       # 电影横幅图
+            'movie_thumb': True,        # 电影缩略图
+            'tv_nfo': True,            # 电视剧NFO
+            'tv_poster': True,         # 电视剧海报  
+            'tv_backdrop': True,       # 电视剧背景图
+            'tv_banner': True,         # 电视剧横幅图
+            'tv_logo': True,           # 电视剧Logo
+            'tv_thumb': True,          # 电视剧缩略图
+            'season_nfo': True,        # 季NFO
+            'season_poster': True,     # 季海报
+            'season_banner': True,     # 季横幅图
+            'season_thumb': True,      # 季缩略图
+            'episode_nfo': True,       # 集NFO
+            'episode_thumb': True      # 集缩略图
+        }
+        # 合并用户配置和默认配置
+        for key, default_value in default_switchs.items():
+            if key not in switchs:
+                switchs[key] = default_value
+        return switchs
+
+    @staticmethod
+    def set_scraping_switchs(switchs: dict) -> bool:
+        """
+        设置刮削开关配置
+        :param switchs: 开关配置字典
+        :return: 是否设置成功
+        """
+        return SystemConfigOper().set(SystemConfigKey.ScrapingSwitchs, switchs)
+
     def metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
                      season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
         """
@@ -404,37 +448,47 @@ class MediaChain(ChainBase):
         if not mediainfo:
             logger.warn(f"{filepath} 无法识别文件媒体信息！")
             return
+        
+        # 获取刮削开关配置
+        scraping_switchs = self._get_scraping_switchs()
         logger.info(f"开始刮削：{filepath} ...")
         if mediainfo.type == MediaType.MOVIE:
             # 电影
             if fileitem.type == "file":
-                # 是否已存在
-                nfo_path = filepath.with_suffix(".nfo")
-                if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                    # 电影文件
-                    movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
-                    if movie_nfo:
-                        # 保存或上传nfo文件到上级目录
-                        __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
-                    else:
-                        logger.warn(f"{filepath.name} nfo文件生成失败！")
-                else:
-                    logger.info(f"已存在nfo文件：{nfo_path}")
-            else:
-                # 电影目录
-                if is_bluray_folder(fileitem):
-                    # 原盘目录
-                    nfo_path = filepath / (filepath.name + ".nfo")
+                # 检查电影NFO开关
+                if scraping_switchs.get('movie_nfo', True):
+                    # 是否已存在
+                    nfo_path = filepath.with_suffix(".nfo")
                     if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                        # 生成原盘nfo
+                        # 电影文件
                         movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
                         if movie_nfo:
-                            # 保存或上传nfo文件到当前目录
-                            __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                            # 保存或上传nfo文件到上级目录
+                            __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
                         else:
                             logger.warn(f"{filepath.name} nfo文件生成失败！")
                     else:
                         logger.info(f"已存在nfo文件：{nfo_path}")
+                else:
+                    logger.info("电影NFO刮削已关闭，跳过")
+            else:
+                # 电影目录
+                if is_bluray_folder(fileitem):
+                    # 原盘目录
+                    if scraping_switchs.get('movie_nfo', True):
+                        nfo_path = filepath / (filepath.name + ".nfo")
+                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                            # 生成原盘nfo
+                            movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                            if movie_nfo:
+                                # 保存或上传nfo文件到当前目录
+                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                            else:
+                                logger.warn(f"{filepath.name} nfo文件生成失败！")
+                        else:
+                            logger.info(f"已存在nfo文件：{nfo_path}")
+                    else:
+                        logger.info("电影NFO刮削已关闭，跳过")
                 else:
                     # 处理目录内的文件
                     files = __list_files(_fileitem=fileitem)
@@ -449,16 +503,35 @@ class MediaChain(ChainBase):
                     image_dict = self.metadata_img(mediainfo=mediainfo)
                     if image_dict:
                         for image_name, image_url in image_dict.items():
-                            image_path = filepath.with_name(image_name)
-                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
-                                                                           path=image_path):
-                                # 下载图片
-                                content = __download_image(image_url)
-                                # 写入图片到当前目录
-                                if content:
-                                    __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                            # 根据图片类型检查开关
+                            if 'poster' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_poster', True)
+                            elif 'backdrop' in image_name.lower() or 'fanart' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_backdrop', True)
+                            elif 'logo' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_logo', True)
+                            elif 'disc' in image_name.lower() or 'cdart' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_disc', True)
+                            elif 'banner' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_banner', True)
+                            elif 'thumb' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_thumb', True)
+                            else:
+                                should_scrape = True  # 未知类型默认刮削
+                            
+                            if should_scrape:
+                                image_path = filepath.with_name(image_name)
+                                if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                               path=image_path):
+                                    # 下载图片
+                                    content = __download_image(image_url)
+                                    # 写入图片到当前目录
+                                    if content:
+                                        __save_file(_fileitem=fileitem, _path=image_path, _content=content)
                                 else:
                                     logger.info(f"已存在图片文件：{image_path}")
+                            else:
+                                logger.info(f"电影图片刮削已关闭，跳过：{image_name}")
         else:
             # 电视剧
             if fileitem.type == "file":
@@ -472,38 +545,45 @@ class MediaChain(ChainBase):
                 if not file_mediainfo:
                     logger.warn(f"{filepath.name} 无法识别文件媒体信息！")
                     return
-                # 是否已存在
-                nfo_path = filepath.with_suffix(".nfo")
-                if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                    # 获取集的nfo文件
-                    episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
-                                                    season=file_meta.begin_season,
-                                                    episode=file_meta.begin_episode)
-                    if episode_nfo:
-                        # 保存或上传nfo文件到上级目录
-                        if not parent:
-                            parent = storagechain.get_parent_item(fileitem)
-                        __save_file(_fileitem=parent, _path=nfo_path, _content=episode_nfo)
-                    else:
-                        logger.warn(f"{filepath.name} nfo文件生成失败！")
-                else:
-                    logger.info(f"已存在nfo文件：{nfo_path}")
-                # 获取集的图片
-                image_dict = self.metadata_img(mediainfo=file_mediainfo,
-                                               season=file_meta.begin_season, episode=file_meta.begin_episode)
-                if image_dict:
-                    for episode, image_url in image_dict.items():
-                        image_path = filepath.with_suffix(Path(image_url).suffix)
-                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=image_path):
-                            # 下载图片
-                            content = __download_image(image_url)
-                            # 保存图片文件到当前目录
-                            if content:
-                                if not parent:
-                                    parent = storagechain.get_parent_item(fileitem)
-                                __save_file(_fileitem=parent, _path=image_path, _content=content)
+                # 检查集NFO开关
+                if scraping_switchs.get('episode_nfo', True):
+                    # 是否已存在
+                    nfo_path = filepath.with_suffix(".nfo")
+                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                        # 获取集的nfo文件
+                        episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
+                                                        season=file_meta.begin_season,
+                                                        episode=file_meta.begin_episode)
+                        if episode_nfo:
+                            # 保存或上传nfo文件到上级目录
+                            if not parent:
+                                parent = storagechain.get_parent_item(fileitem)
+                            __save_file(_fileitem=parent, _path=nfo_path, _content=episode_nfo)
                         else:
-                            logger.info(f"已存在图片文件：{image_path}")
+                            logger.warn(f"{filepath.name} nfo文件生成失败！")
+                    else:
+                        logger.info(f"已存在nfo文件：{nfo_path}")
+                else:
+                    logger.info("集NFO刮削已关闭，跳过")
+                # 获取集的图片
+                if scraping_switchs.get('episode_thumb', True):
+                    image_dict = self.metadata_img(mediainfo=file_mediainfo,
+                                                   season=file_meta.begin_season, episode=file_meta.begin_episode)
+                    if image_dict:
+                        for episode, image_url in image_dict.items():
+                            image_path = filepath.with_suffix(Path(image_url).suffix)
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=image_path):
+                                # 下载图片
+                                content = __download_image(image_url)
+                                # 保存图片文件到当前目录
+                                if content:
+                                    if not parent:
+                                        parent = storagechain.get_parent_item(fileitem)
+                                    __save_file(_fileitem=parent, _path=image_path, _content=content)
+                            else:
+                                logger.info(f"已存在图片文件：{image_path}")
+                else:
+                    logger.info("集缩略图刮削已关闭，跳过")
             else:
                 # 当前为目录，处理目录内的文件
                 files = __list_files(_fileitem=fileitem)
@@ -521,71 +601,95 @@ class MediaChain(ChainBase):
                     if filepath.name in settings.RENAME_FORMAT_S0_NAMES:
                         season_meta.begin_season = 0
                     if season_meta.begin_season is not None:
-                        # 是否已存在
-                        nfo_path = filepath / "season.nfo"
-                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                            # 当前目录有季号，生成季nfo
-                            season_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo,
-                                                           season=season_meta.begin_season)
-                            if season_nfo:
-                                # 写入nfo到根目录
-                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=season_nfo)
-                            else:
-                                logger.warn(f"无法生成电视剧季nfo文件：{meta.name}")
-                        else:
-                            logger.info(f"已存在nfo文件：{nfo_path}")
-                        # TMDB季poster图片
-                        image_dict = self.metadata_img(mediainfo=mediainfo, season=season_meta.begin_season)
-                        if image_dict:
-                            for image_name, image_url in image_dict.items():
-                                image_path = filepath.with_name(image_name)
-                                if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
-                                                                               path=image_path):
-                                    # 下载图片
-                                    content = __download_image(image_url)
-                                    # 保存图片文件到剧集目录
-                                    if content:
-                                        if not parent:
-                                            parent = storagechain.get_parent_item(fileitem)
-                                        __save_file(_fileitem=parent, _path=image_path, _content=content)
+                        # 检查季NFO开关
+                        if scraping_switchs.get('season_nfo', True):
+                            # 是否已存在
+                            nfo_path = filepath / "season.nfo"
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                                # 当前目录有季号，生成季nfo
+                                season_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo,
+                                                               season=season_meta.begin_season)
+                                if season_nfo:
+                                    # 写入nfo到根目录
+                                    __save_file(_fileitem=fileitem, _path=nfo_path, _content=season_nfo)
                                 else:
-                                    logger.info(f"已存在图片文件：{image_path}")
-                        # 额外fanart季图片：poster thumb banner
-                        image_dict = self.metadata_img(mediainfo=mediainfo)
-                        if image_dict:
-                            for image_name, image_url in image_dict.items():
-                                if image_name.startswith("season"):
+                                    logger.warn(f"无法生成电视剧季nfo文件：{meta.name}")
+                            else:
+                                logger.info(f"已存在nfo文件：{nfo_path}")
+                        else:
+                            logger.info("季NFO刮削已关闭，跳过")
+                        # TMDB季poster图片
+                        if scraping_switchs.get('season_poster', True):
+                            image_dict = self.metadata_img(mediainfo=mediainfo, season=season_meta.begin_season)
+                            if image_dict:
+                                for image_name, image_url in image_dict.items():
                                     image_path = filepath.with_name(image_name)
-                                    # 只下载当前刮削季的图片
-                                    image_season = "00" if "specials" in image_name else image_name[6:8]
-                                    if image_season != str(season_meta.begin_season).rjust(2, '0'):
-                                        logger.info(f"当前刮削季为：{season_meta.begin_season}，跳过文件：{image_path}")
-                                        continue
                                     if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
                                                                                    path=image_path):
                                         # 下载图片
                                         content = __download_image(image_url)
-                                        # 保存图片文件到当前目录
+                                        # 保存图片文件到剧集目录
                                         if content:
                                             if not parent:
                                                 parent = storagechain.get_parent_item(fileitem)
                                             __save_file(_fileitem=parent, _path=image_path, _content=content)
                                     else:
                                         logger.info(f"已存在图片文件：{image_path}")
+                        else:
+                            logger.info("季海报刮削已关闭，跳过")
+                        # 额外fanart季图片：poster thumb banner
+                        image_dict = self.metadata_img(mediainfo=mediainfo)
+                        if image_dict:
+                            for image_name, image_url in image_dict.items():
+                                if image_name.startswith("season"):
+                                    # 根据季图片类型检查开关
+                                    if 'poster' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_poster', True)
+                                    elif 'banner' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_banner', True)
+                                    elif 'thumb' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_thumb', True)
+                                    else:
+                                        should_scrape = True  # 未知类型默认刮削
+                                    
+                                    if should_scrape:
+                                        image_path = filepath.with_name(image_name)
+                                        # 只下载当前刮削季的图片
+                                        image_season = "00" if "specials" in image_name else image_name[6:8]
+                                        if image_season != str(season_meta.begin_season).rjust(2, '0'):
+                                            logger.info(f"当前刮削季为：{season_meta.begin_season}，跳过文件：{image_path}")
+                                            continue
+                                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                                       path=image_path):
+                                            # 下载图片
+                                            content = __download_image(image_url)
+                                            # 保存图片文件到当前目录
+                                            if content:
+                                                if not parent:
+                                                    parent = storagechain.get_parent_item(fileitem)
+                                                __save_file(_fileitem=parent, _path=image_path, _content=content)
+                                        else:
+                                            logger.info(f"已存在图片文件：{image_path}")
+                                    else:
+                                        logger.info(f"季图片刮削已关闭，跳过：{image_name}")
                     # 判断当前目录是不是剧集根目录
                     if not season_meta.season:
-                        # 是否已存在
-                        nfo_path = filepath / "tvshow.nfo"
-                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
-                            # 当前目录有名称，生成tvshow nfo 和 tv图片
-                            tv_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
-                            if tv_nfo:
-                                # 写入tvshow nfo到根目录
-                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=tv_nfo)
+                        # 检查电视剧NFO开关
+                        if scraping_switchs.get('tv_nfo', True):
+                            # 是否已存在
+                            nfo_path = filepath / "tvshow.nfo"
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                                # 当前目录有名称，生成tvshow nfo 和 tv图片
+                                tv_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                                if tv_nfo:
+                                    # 写入tvshow nfo到根目录
+                                    __save_file(_fileitem=fileitem, _path=nfo_path, _content=tv_nfo)
+                                else:
+                                    logger.warn(f"无法生成电视剧nfo文件：{meta.name}")
                             else:
-                                logger.warn(f"无法生成电视剧nfo文件：{meta.name}")
+                                logger.info(f"已存在nfo文件：{nfo_path}")
                         else:
-                            logger.info(f"已存在nfo文件：{nfo_path}")
+                            logger.info("电视剧NFO刮削已关闭，跳过")
                         # 生成目录图片
                         image_dict = self.metadata_img(mediainfo=mediainfo)
                         if image_dict:
@@ -593,14 +697,31 @@ class MediaChain(ChainBase):
                                 # 不下载季图片
                                 if image_name.startswith("season"):
                                     continue
-                                image_path = filepath / image_name
-                                if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
-                                                                               path=image_path):
-                                    # 下载图片
-                                    content = __download_image(image_url)
-                                    # 保存图片文件到当前目录
-                                    if content:
-                                        __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                                # 根据电视剧图片类型检查开关
+                                if 'poster' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_poster', True)
+                                elif 'backdrop' in image_name.lower() or 'fanart' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_backdrop', True)
+                                elif 'banner' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_banner', True)
+                                elif 'logo' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_logo', True)
+                                elif 'thumb' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_thumb', True)
                                 else:
-                                    logger.info(f"已存在图片文件：{image_path}")
+                                    should_scrape = True  # 未知类型默认刮削
+                                
+                                if should_scrape:
+                                    image_path = filepath / image_name
+                                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                                   path=image_path):
+                                        # 下载图片
+                                        content = __download_image(image_url)
+                                        # 保存图片文件到当前目录
+                                        if content:
+                                            __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                                    else:
+                                        logger.info(f"已存在图片文件：{image_path}")
+                                else:
+                                    logger.info(f"电视剧图片刮削已关闭，跳过：{image_name}")
         logger.info(f"{filepath.name} 刮削完成")

app/chain/message.py

@@ -1,6 +1,6 @@
 import gc
 import re
-from typing import Any, Optional, Dict, Union
+from typing import Any, Optional, Dict, Union, List
 
 from app.chain import ChainBase
 from app.chain.download import DownloadChain
@@ -11,10 +11,10 @@ from app.core.config import settings
 from app.core.context import MediaInfo, Context
 from app.core.meta import MetaBase
 from app.db.user_oper import UserOper
-from app.helper.memory import memory_optimized
 from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import Notification, NotExistMediaInfo, CommingMessage
+from app.schemas.message import ChannelCapabilityManager
 from app.schemas.types import EventType, MessageChannel, MediaType
 from app.utils.string import StringUtils
 
@@ -115,12 +115,19 @@ class MessageChain(ChainBase):
         if not text:
             logger.debug(f'未识别到消息内容：：{body}{form}{args}')
             return
-        # 处理消息
-        self.handle_message(channel=channel, source=source, userid=userid, username=username, text=text)
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
+        # 获取原消息ID信息
+        original_message_id = info.message_id
+        original_chat_id = info.chat_id
+
+        # 处理消息
+        self.handle_message(channel=channel, source=source, userid=userid, username=username, text=text,
+                            original_message_id=original_message_id, original_chat_id=original_chat_id)
+
     def handle_message(self, channel: MessageChannel, source: str,
-                       userid: Union[str, int], username: str, text: str) -> None:
+                       userid: Union[str, int], username: str, text: str,
+                       original_message_id: Optional[Union[str, int]] = None,
+                       original_chat_id: Optional[str] = None) -> None:
         """
         识别消息内容，执行操作
         """
@@ -131,23 +138,32 @@ class MessageChain(ChainBase):
         # 处理消息
         logger.info(f'收到用户消息内容，用户：{userid}，内容：{text}')
         # 保存消息
-        self.messagehelper.put(
-            CommingMessage(
-                userid=userid,
-                username=username,
+        if not text.startswith('CALLBACK:'):
+            self.messagehelper.put(
+                CommingMessage(
+                    userid=userid,
+                    username=username,
+                    channel=channel,
+                    source=source,
+                    text=text
+                ), role="user")
+            self.messageoper.add(
                 channel=channel,
                 source=source,
-                text=text
-            ), role="user")
-        self.messageoper.add(
-            channel=channel,
-            source=source,
-            userid=username or userid,
-            text=text,
-            action=0
-        )
+                userid=username or userid,
+                text=text,
+                action=0
+            )
         # 处理消息
-        if text.startswith('/'):
+        if text.startswith('CALLBACK:'):
+            # 处理按钮回调（适配支持回调的渠道）
+            if ChannelCapabilityManager.supports_callbacks(channel):
+                self._handle_callback(text=text, channel=channel, source=source,
+                                      userid=userid, username=username,
+                                      original_message_id=original_message_id, original_chat_id=original_chat_id)
+            else:
+                logger.warning(f"渠道 {channel.value} 不支持回调，但收到了回调消息：{text}")
+        elif text.startswith('/'):
             # 执行命令
             self.eventmanager.send_event(
                 EventType.CommandExcute,
@@ -263,11 +279,9 @@ class MessageChain(ChainBase):
                                                  title=mediainfo.title,
                                                  items=contexts[:self._page_size],
                                                  userid=userid,
-                                                 total=len(contexts))
-
-                # 清理内存
-                del cache_list
-                del cache_data
+                                                 total=len(contexts),
+                                                 original_message_id=original_message_id,
+                                                 original_chat_id=original_chat_id)
 
             elif cache_type in ["Subscribe", "ReSubscribe"]:
                 # 订阅或洗版媒体
@@ -348,7 +362,9 @@ class MessageChain(ChainBase):
                                              title=_current_media.title,
                                              items=cache_list[start:end],
                                              userid=userid,
-                                             total=len(cache_list))
+                                             total=len(cache_list),
+                                             original_message_id=original_message_id,
+                                             original_chat_id=original_chat_id)
             else:
                 # 发送媒体数据
                 self.__post_medias_message(channel=channel,
@@ -356,10 +372,9 @@ class MessageChain(ChainBase):
                                            title=_current_meta.name,
                                            items=cache_list[start:end],
                                            userid=userid,
-                                           total=len(cache_list))
-            # 清理内存
-            del cache_list
-            del cache_data
+                                           total=len(cache_list),
+                                           original_message_id=original_message_id,
+                                           original_chat_id=original_chat_id)
 
         elif text.lower() == "n":
             # 下一页
@@ -389,16 +404,21 @@ class MessageChain(ChainBase):
                     self.__post_torrents_message(channel=channel,
                                                  source=source,
                                                  title=_current_media.title,
-                                                 items=cache_list, userid=userid, total=total)
+                                                 items=cache_list,
+                                                 userid=userid,
+                                                 total=total,
+                                                 original_message_id=original_message_id,
+                                                 original_chat_id=original_chat_id)
                 else:
                     # 发送媒体数据
                     self.__post_medias_message(channel=channel,
                                                source=source,
                                                title=_current_meta.name,
-                                               items=cache_list, userid=userid, total=total)
-            # 清理内存
-            del cache_list
-            del cache_data
+                                               items=cache_list,
+                                               userid=userid,
+                                               total=total,
+                                               original_message_id=original_message_id,
+                                               original_chat_id=original_chat_id)
 
         else:
             # 搜索或订阅
@@ -458,7 +478,9 @@ class MessageChain(ChainBase):
                                            source=source,
                                            title=meta.name,
                                            items=medias[:self._page_size],
-                                           userid=userid, total=len(medias))
+                                           userid=userid, total=len(medias),
+                                           original_message_id=original_message_id,
+                                           original_chat_id=original_chat_id)
             else:
                 # 广播事件
                 self.eventmanager.send_event(
@@ -480,6 +502,133 @@ class MessageChain(ChainBase):
 
         gc.collect()
 
+    def _handle_callback(self, text: str, channel: MessageChannel, source: str,
+                         userid: Union[str, int], username: str,
+                         original_message_id: Optional[Union[str, int]] = None,
+                         original_chat_id: Optional[str] = None) -> None:
+        """
+        处理按钮回调
+        """
+        # 提取回调数据
+        callback_data = text[9:]  # 去掉 "CALLBACK:" 前缀
+        logger.info(f"处理按钮回调：{callback_data}")
+
+        # 插件消息的事件回调 [PLUGIN]插件ID|内容
+        if callback_data.startswith('[PLUGIN]'):
+            # 提取插件ID和内容
+            plugin_id, content = callback_data.split("|", 1)
+            # 广播给插件处理
+            self.eventmanager.send_event(
+                EventType.MessageAction,
+                {
+                    "plugin_id": plugin_id.replace("[PLUGIN]", ""),
+                    "text": content,
+                    "userid": userid,
+                    "channel": channel,
+                    "source": source,
+                    "original_message_id": original_message_id,
+                    "original_chat_id": original_chat_id
+                }
+            )
+            return
+
+        # 解析系统回调数据
+        if callback_data.startswith("page_"):
+            # 翻页操作
+            self._handle_page_callback(callback_data=callback_data, channel=channel,
+                                       source=source, userid=userid,
+                                       original_message_id=original_message_id, original_chat_id=original_chat_id)
+        elif callback_data.startswith("select_"):
+            # 选择操作或翻页操作
+            if callback_data in ["select_p", "select_n"]:
+                # 翻页操作
+                page_text = callback_data.split("_")[1]  # 提取 "p" 或 "n"
+                self.handle_message(channel=channel, source=source,
+                                    userid=userid, username=username,
+                                    text=page_text,
+                                    original_message_id=original_message_id, original_chat_id=original_chat_id)
+            else:
+                # 选择操作
+                self._handle_select_callback(callback_data=callback_data, channel=channel,
+                                             source=source, userid=userid, username=username)
+        elif callback_data.startswith("download_"):
+            # 下载操作
+            self._handle_download_callback(callback_data=callback_data, channel=channel,
+                                           source=source, userid=userid, username=username)
+        elif callback_data.startswith("subscribe_"):
+            # 订阅操作
+            self._handle_subscribe_callback(callback_data=callback_data, channel=channel,
+                                            source=source, userid=userid, username=username)
+        else:
+            # 其他自定义回调
+            logger.info(f"未知的回调数据：{callback_data}")
+
+    def _handle_page_callback(self, callback_data: str, channel: MessageChannel, source: str,
+                              userid: Union[str, int], original_message_id: Optional[Union[str, int]],
+                              original_chat_id: Optional[str]):
+        """
+        处理翻页回调
+        """
+        try:
+            page = int(callback_data.split("_")[1])
+
+            # 获取当前页面
+            global _current_page
+
+            # 判断是上一页还是下一页
+            if page < _current_page:
+                # 上一页，调用原来的 "p" 逻辑
+                self.handle_message(channel=channel, source=source, userid=userid,
+                                    username="", text="p",
+                                    original_message_id=original_message_id, original_chat_id=original_chat_id)
+            elif page > _current_page:
+                # 下一页，调用原来的 "n" 逻辑  
+                self.handle_message(channel=channel, source=source, userid=userid,
+                                    username="", text="n",
+                                    original_message_id=original_message_id, original_chat_id=original_chat_id)
+
+        except (ValueError, IndexError) as e:
+            logger.error(f"处理翻页回调失败：{e}")
+
+    def _handle_select_callback(self, callback_data: str, channel: MessageChannel, source: str,
+                                userid: Union[str, int], username: str) -> None:
+        """
+        处理选择回调
+        """
+        try:
+            index = int(callback_data.split("_")[1])
+            # 调用原有的数字选择逻辑
+            self.handle_message(channel=channel, source=source, userid=userid, username=username, text=str(index + 1))
+        except (ValueError, IndexError) as e:
+            logger.error(f"处理选择回调失败：{e}")
+
+    def _handle_download_callback(self, callback_data: str, channel: MessageChannel, source: str,
+                                  userid: Union[str, int], username: str) -> None:
+        """
+        处理下载回调
+        """
+        try:
+            if callback_data == "download_auto":
+                # 自动选择下载
+                self.handle_message(channel=channel, source=source, userid=userid, username=username, text="0")
+            else:
+                index = int(callback_data.split("_")[1])
+                self.handle_message(channel=channel, source=source, userid=userid, username=username,
+                                    text=str(index + 1))
+        except (ValueError, IndexError) as e:
+            logger.error(f"处理下载回调失败：{e}")
+
+    def _handle_subscribe_callback(self, callback_data: str, channel: MessageChannel, source: str,
+                                   userid: Union[str, int], username: str) -> None:
+        """
+        处理订阅回调
+        """
+        try:
+            index = int(callback_data.split("_")[1])
+            self.handle_message(channel=channel, source=source, userid=userid, username=username, text=str(index + 1))
+        except (ValueError, IndexError) as e:
+            logger.error(f"处理订阅回调失败：{e}")
+
     def __auto_download(self, channel: MessageChannel, source: str, cache_list: list[Context],
                         userid: Union[str, int], username: str,
                         no_exists: Optional[Dict[Union[int, str], Dict[int, NotExistMediaInfo]]] = None):
@@ -533,35 +682,185 @@ class MessageChain(ChainBase):
                                  note=note)
 
     def __post_medias_message(self, channel: MessageChannel, source: str,
-                              title: str, items: list, userid: str, total: int):
+                              title: str, items: list, userid: str, total: int,
+                              original_message_id: Optional[Union[str, int]] = None,
+                              original_chat_id: Optional[str] = None):
         """
         发送媒体列表消息
         """
-        if total > self._page_size:
-            title = f"【{title}】共找到{total}条相关信息，请回复对应数字选择（p: 上一页 n: 下一页）"
-        else:
-            title = f"【{title}】共找到{total}条相关信息，请回复对应数字选择"
-        self.post_medias_message(Notification(
-            channel=channel,
-            source=source,
-            title=title,
-            userid=userid
-        ), medias=items)
+        # 检查渠道是否支持按钮
+        supports_buttons = ChannelCapabilityManager.supports_buttons(channel)
 
-    def __post_torrents_message(self, channel: MessageChannel, source: str,
-                                title: str, items: list,
-                                userid: str, total: int):
-        """
-        发送种子列表消息
-        """
-        if total > self._page_size:
-            title = f"【{title}】共找到{total}条相关资源，请回复对应数字下载（0: 自动选择 p: 上一页 n: 下一页）"
+        if supports_buttons:
+            # 支持按钮的渠道
+            if total > self._page_size:
+                title = f"【{title}】共找到{total}条相关信息，请选择操作"
+            else:
+                title = f"【{title}】共找到{total}条相关信息，请选择操作"
+
+            buttons = self._create_media_buttons(channel=channel, items=items, total=total)
         else:
-            title = f"【{title}】共找到{total}条相关资源，请回复对应数字下载（0: 自动选择）"
-        self.post_torrents_message(Notification(
+            # 不支持按钮的渠道，使用文本提示
+            if total > self._page_size:
+                title = f"【{title}】共找到{total}条相关信息，请回复对应数字选择（p: 上一页 n: 下一页）"
+            else:
+                title = f"【{title}】共找到{total}条相关信息，请回复对应数字选择"
+            buttons = None
+
+        notification = Notification(
             channel=channel,
             source=source,
             title=title,
             userid=userid,
-            link=settings.MP_DOMAIN('#/resource')
-        ), torrents=items)
+            buttons=buttons,
+            original_message_id=original_message_id,
+            original_chat_id=original_chat_id
+        )
+
+        self.post_medias_message(notification, medias=items)
+
+    def _create_media_buttons(self, channel: MessageChannel, items: list, total: int) -> List[List[Dict]]:
+        """
+        创建媒体选择按钮
+        """
+        global _current_page
+
+        buttons = []
+        max_text_length = ChannelCapabilityManager.get_max_button_text_length(channel)
+        max_per_row = ChannelCapabilityManager.get_max_buttons_per_row(channel)
+
+        # 为每个媒体项创建选择按钮
+        current_row = []
+        for i in range(len(items)):
+            media = items[i]
+
+            if max_per_row == 1:
+                # 每行一个按钮，使用完整文本
+                button_text = f"{i + 1}. {media.title_year}"
+                if len(button_text) > max_text_length:
+                    button_text = button_text[:max_text_length - 3] + "..."
+
+                buttons.append([{
+                    "text": button_text,
+                    "callback_data": f"select_{_current_page * self._page_size + i}"
+                }])
+            else:
+                # 多按钮一行的情况，使用简化文本
+                button_text = f"{i + 1}"
+
+                current_row.append({
+                    "text": button_text,
+                    "callback_data": f"select_{_current_page * self._page_size + i}"
+                })
+
+                # 如果当前行已满或者是最后一个按钮，添加到按钮列表
+                if len(current_row) == max_per_row or i == len(items) - 1:
+                    buttons.append(current_row)
+                    current_row = []
+
+        # 添加翻页按钮
+        if total > self._page_size:
+            page_buttons = []
+            if _current_page > 0:
+                page_buttons.append({"text": "⬅️ 上一页", "callback_data": "select_p"})
+            if (_current_page + 1) * self._page_size < total:
+                page_buttons.append({"text": "下一页 ➡️", "callback_data": "select_n"})
+            if page_buttons:
+                buttons.append(page_buttons)
+
+        return buttons
+
+    def __post_torrents_message(self, channel: MessageChannel, source: str,
+                                title: str, items: list, userid: str, total: int,
+                                original_message_id: Optional[Union[str, int]] = None,
+                                original_chat_id: Optional[str] = None):
+        """
+        发送种子列表消息
+        """
+        # 检查渠道是否支持按钮
+        supports_buttons = ChannelCapabilityManager.supports_buttons(channel)
+
+        if supports_buttons:
+            # 支持按钮的渠道
+            if total > self._page_size:
+                title = f"【{title}】共找到{total}条相关资源，请选择下载"
+            else:
+                title = f"【{title}】共找到{total}条相关资源，请选择下载"
+
+            buttons = self._create_torrent_buttons(channel=channel, items=items, total=total)
+        else:
+            # 不支持按钮的渠道，使用文本提示
+            if total > self._page_size:
+                title = f"【{title}】共找到{total}条相关资源，请回复对应数字下载（0: 自动选择 p: 上一页 n: 下一页）"
+            else:
+                title = f"【{title}】共找到{total}条相关资源，请回复对应数字下载（0: 自动选择）"
+            buttons = None
+
+        notification = Notification(
+            channel=channel,
+            source=source,
+            title=title,
+            userid=userid,
+            link=settings.MP_DOMAIN('#/resource'),
+            buttons=buttons,
+            original_message_id=original_message_id,
+            original_chat_id=original_chat_id
+        )
+
+        self.post_torrents_message(notification, torrents=items)
+
+    def _create_torrent_buttons(self, channel: MessageChannel, items: list, total: int) -> List[List[Dict]]:
+        """
+        创建种子下载按钮
+        """
+
+        global _current_page
+
+        buttons = []
+        max_text_length = ChannelCapabilityManager.get_max_button_text_length(channel)
+        max_per_row = ChannelCapabilityManager.get_max_buttons_per_row(channel)
+
+        # 自动选择按钮
+        buttons.append([{"text": "🤖 自动选择下载", "callback_data": "download_auto"}])
+
+        # 为每个种子项创建下载按钮
+        current_row = []
+        for i in range(len(items)):
+            context = items[i]
+            torrent = context.torrent_info
+
+            if max_per_row == 1:
+                # 每行一个按钮，使用完整文本
+                button_text = f"{i + 1}. {torrent.site_name} - {torrent.seeders}↑"
+                if len(button_text) > max_text_length:
+                    button_text = button_text[:max_text_length - 3] + "..."
+
+                buttons.append([{
+                    "text": button_text,
+                    "callback_data": f"download_{_current_page * self._page_size + i}"
+                }])
+            else:
+                # 多按钮一行的情况，使用简化文本
+                button_text = f"{i + 1}"
+
+                current_row.append({
+                    "text": button_text,
+                    "callback_data": f"download_{_current_page * self._page_size + i}"
+                })
+
+                # 如果当前行已满或者是最后一个按钮，添加到按钮列表
+                if len(current_row) == max_per_row or i == len(items) - 1:
+                    buttons.append(current_row)
+                    current_row = []
+
+        # 添加翻页按钮
+        if total > self._page_size:
+            page_buttons = []
+            if _current_page > 0:
+                page_buttons.append({"text": "⬅️ 上一页", "callback_data": "select_p"})
+            if (_current_page + 1) * self._page_size < total:
+                page_buttons.append({"text": "下一页 ➡️", "callback_data": "select_n"})
+            if page_buttons:
+                buttons.append(page_buttons)
+
+        return buttons

app/chain/search.py

@@ -12,7 +12,6 @@ from app.core.context import MediaInfo, TorrentInfo
 from app.core.event import eventmanager, Event
 from app.core.metainfo import MetaInfo
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.memory import memory_optimized
 from app.helper.progress import ProgressHelper
 from app.helper.sites import SitesHelper
 from app.helper.torrent import TorrentHelper
@@ -98,7 +97,6 @@ class SearchChain(ChainBase):
             logger.error(f'加载搜索结果失败：{str(e)} - {traceback.format_exc()}')
             return []
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def process(self, mediainfo: MediaInfo,
                 keyword: Optional[str] = None,
                 no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,

app/chain/subscribe.py

@@ -24,7 +24,6 @@ from app.db.models.subscribe import Subscribe
 from app.db.site_oper import SiteOper
 from app.db.subscribe_oper import SubscribeOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.memory import memory_optimized
 from app.helper.subscribe import SubscribeHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
@@ -222,10 +221,13 @@ class SubscribeChain(ChainBase):
             # 订阅成功按规则发送消息
             self.post_message(
                 schemas.Notification(
+                    channel=channel,
+                    source=source,
                     mtype=NotificationType.Subscribe,
                     ctype=ContentType.SubscribeAdded,
                     image=mediainfo.get_message_image(),
                     link=link,
+                    userid=userid,
                     username=username
                 ),
                 meta=metainfo,
@@ -268,7 +270,6 @@ class SubscribeChain(ChainBase):
             return True
         return False
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def search(self, sid: Optional[int] = None, state: Optional[str] = 'N', manual: Optional[bool] = False):
         """
         订阅搜索
@@ -362,6 +363,8 @@ class SubscribeChain(ChainBase):
                     # 过滤搜索结果
                     matched_contexts = []
                     for context in contexts:
+                        if global_vars.is_system_stopped:
+                            break
                         torrent_meta = context.meta_info
                         torrent_info = context.torrent_info
                         torrent_mediainfo = context.media_info
@@ -396,7 +399,6 @@ class SubscribeChain(ChainBase):
                     downloads, lefts = DownloadChain().batch_download(
                         contexts=matched_contexts,
                         no_exists=no_exists,
-                        userid=subscribe.username,
                         username=subscribe.username,
                         save_path=subscribe.save_path,
                         downloader=subscribe.downloader,
@@ -540,7 +542,6 @@ class SubscribeChain(ChainBase):
 
         return ret_sites
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def match(self, torrents: Dict[str, List[Context]]):
         """
         从缓存中匹配订阅，并自动下载
@@ -557,8 +558,12 @@ class SubscribeChain(ChainBase):
             # 预识别所有未识别的种子
             processed_torrents: Dict[str, List[Context]] = {}
             for domain, contexts in torrents.items():
+                if global_vars.is_system_stopped:
+                    break
                 processed_torrents[domain] = []
                 for context in contexts:
+                    if global_vars.is_system_stopped:
+                        break
                     # 如果种子未识别，尝试识别
                     if not context.media_info or (not context.media_info.tmdb_id
                                                   and not context.media_info.douban_id):
@@ -629,6 +634,8 @@ class SubscribeChain(ChainBase):
                         continue
                     logger.debug(f'开始匹配站点：{domain}，共缓存了 {len(contexts)} 个种子...')
                     for context in contexts:
+                        if global_vars.is_system_stopped:
+                            break
                         # 提取信息
                         _context = copy.copy(context)
                         torrent_meta = _context.meta_info
@@ -770,10 +777,6 @@ class SubscribeChain(ChainBase):
                             torrent_mediainfo.episode_group = subscribe.episode_group
                         _match_context.append(_context)
 
-                    # 清理内存
-                    contexts.clear()
-                    del contexts
-
                 if not _match_context:
                     # 未匹配到资源
                     logger.info(f'{mediainfo.title_year} 未匹配到符合条件的资源')
@@ -785,7 +788,6 @@ class SubscribeChain(ChainBase):
                 logger.info(f'{mediainfo.title_year} 匹配完成，共匹配到{len(_match_context)}个资源')
                 downloads, lefts = DownloadChain().batch_download(contexts=_match_context,
                                                                   no_exists=no_exists,
-                                                                  userid=subscribe.username,
                                                                   username=subscribe.username,
                                                                   save_path=subscribe.save_path,
                                                                   downloader=subscribe.downloader,
@@ -874,6 +876,8 @@ class SubscribeChain(ChainBase):
         success_count = 0
         subscribeoper = SubscribeOper()
         for share_sub in share_subs:
+            if global_vars.is_system_stopped:
+                break
             uid = share_sub.get("share_uid")
             if uid and uid in follow_users:
                 # 订阅已存在则跳过
@@ -1182,6 +1186,9 @@ class SubscribeChain(ChainBase):
                     new_episodes = list(range(max(start_episode, start), total_episode + 1))
                     # 与原集列表取交集
                     episodes = list(set(episode_list).intersection(set(new_episodes)))
+                    # 交集为空时，说明订阅的剧集均已入库
+                    if not episodes:
+                        return True, {}
                 # 更新集合
                 no_exists[mediakey][begin_season] = schemas.NotExistMediaInfo(
                     season=begin_season,

app/chain/system.py

@@ -1,5 +1,6 @@
 import json
 import re
+import shutil
 from pathlib import Path
 from typing import Union, Optional
 
@@ -32,6 +33,8 @@ class SystemChain(ChainBase):
         """
         重启系统
         """
+        from app.core.config import global_vars
+        
         if channel and userid:
             self.post_message(Notification(channel=channel, source=source,
                                            title="系统正在重启，请耐心等候！", userid=userid))
@@ -40,9 +43,117 @@ class SystemChain(ChainBase):
                 "channel": channel.value,
                 "userid": userid
             }, self._restart_file)
+        # 主动备份一次插件
+        self.backup_plugins()
+        # 设置停止标志，通知所有模块准备停止
+        global_vars.stop_system()
         # 重启
         SystemHelper.restart()
 
+    @staticmethod
+    def backup_plugins():
+        """
+        备份插件到用户配置目录（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        try:
+            # 使用绝对路径确保准确性
+            plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+            backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+            if not plugins_dir.exists():
+                logger.info("插件目录不存在，跳过备份")
+                return
+
+            # 确保备份目录存在
+            backup_dir.mkdir(parents=True, exist_ok=True)
+
+            # 需要排除的文件和目录
+            exclude_items = {"__init__.py", "__pycache__", ".DS_Store"}
+
+            # 遍历插件目录，备份除排除项外的所有内容
+            for item in plugins_dir.iterdir():
+                if item.name in exclude_items:
+                    continue
+
+                target_path = backup_dir / item.name
+
+                # 如果是目录
+                if item.is_dir():
+                    if target_path.exists():
+                        continue
+                    shutil.copytree(item, target_path)
+                    logger.info(f"已备份插件目录: {item.name}")
+                # 如果是文件
+                elif item.is_file():
+                    if target_path.exists():
+                        continue
+                    shutil.copy2(item, target_path)
+                    logger.info(f"已备份插件文件: {item.name}")
+
+            logger.info(f"插件备份完成，备份位置: {backup_dir}")
+
+        except Exception as e:
+            logger.error(f"插件备份失败: {str(e)}")
+
+    @staticmethod
+    def restore_plugins():
+        """
+        从备份恢复插件到app/plugins目录，恢复完成后删除备份（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        # 使用绝对路径确保准确性
+        plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+        backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+        if not backup_dir.exists():
+            logger.info("插件备份目录不存在，跳过恢复")
+            return
+
+        # 系统被重置才恢复插件
+        if SystemHelper().is_system_reset():
+
+            # 确保插件目录存在
+            plugins_dir.mkdir(parents=True, exist_ok=True)
+
+            # 遍历备份目录，恢复所有内容
+            restored_count = 0
+            for item in backup_dir.iterdir():
+                target_path = plugins_dir / item.name
+                try:
+                    # 如果是目录，且目录内有内容
+                    if item.is_dir() and any(item.iterdir()):
+                        if target_path.exists():
+                            shutil.rmtree(target_path)
+                        shutil.copytree(item, target_path)
+                        logger.info(f"已恢复插件目录: {item.name}")
+                        restored_count += 1
+                    # 如果是文件
+                    elif item.is_file():
+                        shutil.copy2(item, target_path)
+                        logger.info(f"已恢复插件文件: {item.name}")
+                        restored_count += 1
+                except Exception as e:
+                    logger.error(f"恢复插件 {item.name} 时发生错误: {str(e)}")
+                    continue
+
+            logger.info(f"插件恢复完成，共恢复 {restored_count} 个项目")
+
+        # 删除备份目录
+        try:
+            shutil.rmtree(backup_dir)
+            logger.info(f"已删除插件备份目录: {backup_dir}")
+        except Exception as e:
+            logger.warning(f"删除备份目录失败: {str(e)}")
+
     def __get_version_message(self) -> str:
         """
         获取版本信息文本

app/chain/torrents.py

@@ -1,4 +1,3 @@
-import gc
 import re
 import traceback
 from typing import Dict, List, Union, Optional
@@ -10,7 +9,6 @@ from app.core.context import TorrentInfo, Context, MediaInfo
 from app.core.metainfo import MetaInfo
 from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.memory import memory_optimized, clear_large_objects
 from app.helper.rss import RssHelper
 from app.helper.sites import SitesHelper
 from app.helper.torrent import TorrentHelper
@@ -71,7 +69,6 @@ class TorrentsChain(ChainBase):
         self.remove_cache(self._rss_file)
         logger.info(f'种子缓存数据清理完成')
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def browse(self, domain: str, keyword: Optional[str] = None, cat: Optional[str] = None,
                page: Optional[int] = 0) -> List[TorrentInfo]:
         """
@@ -88,7 +85,6 @@ class TorrentsChain(ChainBase):
             return []
         return self.refresh_torrents(site=site, keyword=keyword, cat=cat, page=page)
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def rss(self, domain: str) -> List[TorrentInfo]:
         """
         获取站点RSS内容，返回种子清单，TTL缓存3分钟
@@ -134,7 +130,6 @@ class TorrentsChain(ChainBase):
 
         return ret_torrents
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def refresh(self, stype: Optional[str] = None, sites: List[int] = None) -> Dict[str, List[Context]]:
         """
         刷新站点最新资源，识别并缓存起来
@@ -180,7 +175,7 @@ class TorrentsChain(ChainBase):
             # 按pubdate降序排列
             torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
             # 取前N条
-            torrents = torrents[:settings.CACHE_CONF["refresh"]]
+            torrents = torrents[:settings.CONF["refresh"]]
             if torrents:
                 # 过滤出没有处理过的种子 - 优化：使用集合查找，避免重复创建字符串列表
                 cached_signatures = {f'{t.torrent_info.title}{t.torrent_info.description}'
@@ -220,18 +215,8 @@ class TorrentsChain(ChainBase):
                     else:
                         torrents_cache[domain].append(context)
                     # 如果超过了限制条数则移除掉前面的
-                    if len(torrents_cache[domain]) > settings.CACHE_CONF["torrents"]:
-                        # 优化：直接删除旧数据，无需重复清理（数据进缓存前已经clear过）
-                        old_contexts = torrents_cache[domain][:-settings.CACHE_CONF["torrents"]]
-                        torrents_cache[domain] = torrents_cache[domain][-settings.CACHE_CONF["torrents"]:]
-                        # 清理旧对象
-                        clear_large_objects(*old_contexts)
-                    # 优化：清理不再需要的临时变量
-                    del meta, mediainfo, context
-                # 回收资源
-                torrents.clear()
-                del torrents
-                gc.collect()
+                    if len(torrents_cache[domain]) > settings.CONF["torrents"]:
+                        torrents_cache[domain] = torrents_cache[domain][-settings.CONF["torrents"]:]
             else:
                 logger.info(f'{indexer.get("name")} 没有获取到种子')
 
@@ -243,17 +228,7 @@ class TorrentsChain(ChainBase):
 
         # 去除不在站点范围内的缓存种子
         if sites and torrents_cache:
-            old_cache = torrents_cache
             torrents_cache = {k: v for k, v in torrents_cache.items() if k in domains}
-            # 清理不再使用的缓存数据（数据进缓存前已经clear过，无需重复清理）
-            removed_contexts = []
-            for domain, contexts in old_cache.items():
-                if domain not in domains:
-                    removed_contexts.extend(contexts)
-            # 批量清理
-            if removed_contexts:
-                clear_large_objects(*removed_contexts)
-            del old_cache
 
         return torrents_cache
 

app/chain/transfer.py

@@ -25,7 +25,6 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.db.transferhistory_oper import TransferHistoryOper
 from app.helper.directory import DirectoryHelper
 from app.helper.format import FormatParser
-from app.helper.memory import memory_optimized
 from app.helper.progress import ProgressHelper
 from app.log import logger
 from app.schemas import TransferInfo, TransferTorrent, Notification, EpisodeFormat, FileItem, TransferDirectoryConf, \
@@ -938,7 +937,6 @@ class TransferChain(ChainBase, metaclass=Singleton):
 
         return trans_items
 
-    @memory_optimized(force_gc_after=True, log_memory=True)
     def do_transfer(self, fileitem: FileItem,
                     meta: MetaBase = None, mediainfo: MediaInfo = None,
                     target_directory: TransferDirectoryConf = None,

app/core/cache.py

@@ -196,7 +196,7 @@ class CacheToolsBackend(CacheBackend):
             return None
         return region_cache.get(key)
 
-    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION):
         """
         删除缓存
 
@@ -205,7 +205,7 @@ class CacheToolsBackend(CacheBackend):
         """
         region_cache = self.__get_region_cache(region)
         if region_cache is None:
-            return None
+            return
         with lock:
             del region_cache[key]
 

app/core/config.py

@@ -69,8 +69,8 @@ class ConfigModel(BaseModel):
     DB_MAX_OVERFLOW: int = 500
     # SQLite 的 busy_timeout 参数，默认为 60 秒
     DB_TIMEOUT: int = 60
-    # SQLite 是否启用 WAL 模式，默认关闭
-    DB_WAL_ENABLE: bool = False
+    # SQLite 是否启用 WAL 模式，默认开启
+    DB_WAL_ENABLE: bool = True
     # 缓存类型，支持 cachetools 和 redis，默认使用 cachetools
     CACHE_BACKEND_TYPE: str = "cachetools"
     # 缓存连接字符串，仅外部缓存（如 Redis、Memcached）需要
@@ -114,6 +114,8 @@ class ConfigModel(BaseModel):
     TVDB_V4_API_PIN: str = ""
     # Fanart开关
     FANART_ENABLE: bool = True
+    # Fanart语言
+    FANART_LANG: str = "zh,en"
     # Fanart API Key
     FANART_API_KEY: str = "d2d31f9ecabea050fc7d68aa3146015f"
     # 115 AppId
@@ -123,7 +125,7 @@ class ConfigModel(BaseModel):
     # 元数据识别缓存过期时间（小时）
     META_CACHE_EXPIRE: int = 0
     # 电视剧动漫的分类genre_ids
-    ANIME_GENREIDS: List[int] = [16]
+    ANIME_GENREIDS: List[int] = Field(default=[16])
     # 用户认证站点
     AUTH_SITE: str = ""
     # 重启自动升级
@@ -139,6 +141,7 @@ class ConfigModel(BaseModel):
                         "api.github.com,"
                         "github.com,"
                         "raw.githubusercontent.com,"
+                        "codeload.github.com,"
                         "api.telegram.org")
     # DOH 解析服务器列表
     DOH_RESOLVERS: str = "1.0.0.1,1.1.1.1,9.9.9.9,149.112.112.112"
@@ -241,12 +244,18 @@ class ConfigModel(BaseModel):
     GITHUB_TOKEN: Optional[str] = None
     # Github代理服务器，格式：https://mirror.ghproxy.com/
     GITHUB_PROXY: Optional[str] = ''
-    # pip镜像站点，格式：https://pypi.tuna.tsinghua.edu.cn/simple
+    # pip镜像站点，格式：https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
     PIP_PROXY: Optional[str] = ''
     # 指定的仓库Github token，多个仓库使用,分隔，格式：{user1}/{repo1}:ghp_****,{user2}/{repo2}:github_pat_****
     REPO_GITHUB_TOKEN: Optional[str] = None
     # 大内存模式
     BIG_MEMORY_MODE: bool = False
+    # 是否启用内存监控
+    MEMORY_ANALYSIS: bool = False
+    # 内存快照间隔（分钟）
+    MEMORY_SNAPSHOT_INTERVAL: int = 60
+    # 保留的内存快照文件数量
+    MEMORY_SNAPSHOT_KEEP_COUNT: int = 20
     # 全局图片缓存，将媒体图片缓存到本地
     GLOBAL_IMAGE_CACHE: bool = False
     # 是否启用编码探测的性能模式
@@ -274,14 +283,10 @@ class ConfigModel(BaseModel):
     SECURITY_IMAGE_SUFFIXES: list = Field(default=[".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg", ".avif"])
     # 重命名时支持的S0别名
     RENAME_FORMAT_S0_NAMES: list = Field(default=["Specials", "SPs"])
-    # 启用分词搜索
-    TOKENIZED_SEARCH: bool = False
     # 为指定默认字幕添加.default后缀
     DEFAULT_SUB: Optional[str] = "zh-cn"
     # Docker Client API地址
     DOCKER_CLIENT_API: Optional[str] = "tcp://127.0.0.1:38379"
-    # 剧集交集最小置信度  计算后的交集比例( len(torrent_episodes ∩ need_episodes) / len(torrent_episodes) 低于这个阈值表明包含过多不需要的剧集
-    EPISODE_INTERSECTION_MIN_CONFIDENCE: float = 0.0
 
 
 class Settings(BaseSettings, ConfigModel, LogConfigModel):
@@ -520,7 +525,7 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         return self.CONFIG_PATH / "cookies"
 
     @property
-    def CACHE_CONF(self):
+    def CONF(self):
         """
         {
             "torrents": "缓存种子数量",
@@ -529,7 +534,9 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             "douban": "豆瓣请求缓存数量",
             "fanart": "Fanart请求缓存数量",
             "meta": "元数据缓存过期时间（秒）",
-            "memory": "最大占用内存（MB）"
+            "memory": "最大占用内存（MB）",
+            "scheduler": "调度器缓存数量"
+            "threadpool": "线程池数量"
         }
         """
         if self.BIG_MEMORY_MODE:
@@ -541,7 +548,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                 "bangumi": 512,
                 "fanart": 512,
                 "meta": (self.META_CACHE_EXPIRE or 24) * 3600,
-                "memory": 2 * 1024
+                "scheduler": 100,
+                "threadpool": 100
             }
         return {
             "torrents": 100,
@@ -551,7 +559,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
             "bangumi": 256,
             "fanart": 128,
             "meta": (self.META_CACHE_EXPIRE or 2) * 3600,
-            "memory": 1024
+            "scheduler": 50,
+            "threadpool": 50
         }
 
     @property
@@ -578,7 +587,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
         """
         if self.GITHUB_TOKEN:
             return {
-                "Authorization": f"Bearer {self.GITHUB_TOKEN}"
+                "Authorization": f"Bearer {self.GITHUB_TOKEN}",
+                "User-Agent": self.USER_AGENT,
             }
         return {}
 
@@ -606,7 +616,8 @@ class Settings(BaseSettings, ConfigModel, LogConfigModel):
                     print(f"无效的令牌或仓库信息: {token_pair}")
                     continue
                 headers[repo_info] = {
-                    "Authorization": f"Bearer {token}"
+                    "Authorization": f"Bearer {token}",
+                    "User-Agent": self.USER_AGENT,
                 }
             except Exception as e:
                 print(f"处理令牌对 '{token_pair}' 时出错: {e}")

app/core/event.py

@@ -456,6 +456,9 @@ class EventManager(metaclass=Singleton):
             elif class_name.endswith("Chain"):
                 module_name = f"app.chain.{class_name[:-5].lower()}"
                 module = importlib.import_module(module_name)
+            elif class_name.endswith("Helper"):
+                module_name = f"app.helper.{class_name[:-6].lower()}"
+                module = importlib.import_module(module_name)
             else:
                 module_name = f"app.{class_name.lower()}"
                 module = importlib.import_module(module_name)
@@ -465,7 +468,7 @@ class EventManager(metaclass=Singleton):
             else:
                 logger.debug(f"事件处理出错：模块 {module_name} 中没有找到类 {class_name}")
         except Exception as e:
-            logger.error(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
+            logger.debug(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
         return None
 
     def __broadcast_consumer_loop(self):

app/core/plugin.py

@@ -122,6 +122,8 @@ class PluginManager(metaclass=Singleton):
                 return False
             return True
 
+        # 已安装插件
+        installed_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
         # 扫描插件目录
         if pid:
             # 加载指定插件
@@ -130,13 +132,11 @@ class PluginManager(metaclass=Singleton):
                 filter_func=lambda name, obj: check_module(obj) and name == pid
             )
         else:
-            # 加载所有插件
+            # 加载已安装插件
             plugins = ModuleHelper.load(
                 "app.plugins",
-                filter_func=lambda _, obj: check_module(obj)
+                filter_func=lambda name, obj: check_module(obj) and name in installed_plugins
             )
-        # 已安装插件
-        installed_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
         # 排序
         plugins.sort(key=lambda x: x.plugin_order if hasattr(x, "plugin_order") else 0)
         for plugin in plugins:
@@ -152,11 +152,6 @@ class PluginManager(metaclass=Singleton):
                     continue
                 # 存储Class
                 self._plugins[plugin_id] = plugin
-                # 未安装的不加载
-                if plugin_id not in installed_plugins:
-                    # 设置事件状态为不可用
-                    eventmanager.disable_event_handler(plugin)
-                    continue
                 # 生成实例
                 plugin_obj = plugin()
                 # 生效插件配置
@@ -201,7 +196,7 @@ class PluginManager(metaclass=Singleton):
             logger.info(f"正在停止插件 {pid}...")
             plugin_obj = self._running_plugins.get(pid)
             if not plugin_obj:
-                logger.warning(f"插件 {pid} 不存在或未加载")
+                logger.debug(f"插件 {pid} 不存在或未加载")
                 return
             plugins = {pid: plugin_obj}
         else:
@@ -213,6 +208,7 @@ class PluginManager(metaclass=Singleton):
         # 清空对像
         if pid:
             # 清空指定插件
+            self._plugins.pop(pid, None)
             self._running_plugins.pop(pid, None)
         else:
             # 清空
@@ -307,6 +303,13 @@ class PluginManager(metaclass=Singleton):
         """
         self.stop(plugin_id)
 
+        # 从模块列表中移除插件
+        from sys import modules
+        try:
+            del modules[f"app.plugins.{plugin_id.lower()}"]
+        except KeyError:
+            pass
+
     def reload_plugin(self, plugin_id: str):
         """
         将一个插件重新加载到内存
@@ -321,7 +324,7 @@ class PluginManager(metaclass=Singleton):
 
     def sync(self) -> List[str]:
         """
-        安装本地不存在的在线插件
+        安装本地不存在或需要更新的插件
         """
 
         def install_plugin(plugin):
@@ -347,7 +350,8 @@ class PluginManager(metaclass=Singleton):
         # 确定需要安装的插件
         plugins_to_install = [
             plugin for plugin in online_plugins
-            if plugin.id in install_plugins and not self.is_plugin_exists(plugin.id)
+            if plugin.id in install_plugins
+            and not self.is_plugin_exists(plugin.id, plugin.plugin_version)
         ]
 
         if not plugins_to_install:
@@ -412,13 +416,14 @@ class PluginManager(metaclass=Singleton):
             return {k: v for k, v in conf.items() if k}
         return {}
 
-    def save_plugin_config(self, pid: str, conf: dict) -> bool:
+    def save_plugin_config(self, pid: str, conf: dict, force: bool = False) -> bool:
         """
         保存插件配置
         :param pid: 插件ID
         :param conf: 配置
+        :param force: 强制保存
         """
-        if not self._plugins.get(pid):
+        if not force and not self._plugins.get(pid):
             return False
         SystemConfigOper().set(self._config_key % pid, conf)
         return True
@@ -462,7 +467,9 @@ class PluginManager(metaclass=Singleton):
         }]
         """
         ret_commands = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_command") and ObjectUtils.check_method(plugin.get_command):
@@ -522,7 +529,9 @@ class PluginManager(metaclass=Singleton):
         }]
         """
         ret_services = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_service") and ObjectUtils.check_method(plugin.get_service):
@@ -545,7 +554,9 @@ class PluginManager(metaclass=Singleton):
         }
         """
         ret_modules = {}
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_module") and ObjectUtils.check_method(plugin.get_module):
@@ -569,7 +580,9 @@ class PluginManager(metaclass=Singleton):
         }]
         """
         ret_actions = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_actions") and ObjectUtils.check_method(plugin.get_actions):
@@ -606,7 +619,9 @@ class PluginManager(metaclass=Singleton):
         获取插件联邦组件列表
         """
         remotes = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if pid and pid != plugin_id:
                 continue
             if hasattr(plugin, "get_render_mode"):
@@ -625,7 +640,9 @@ class PluginManager(metaclass=Singleton):
         获取所有插件仪表盘元信息
         """
         dashboard_meta = []
-        for plugin_id, plugin in self._running_plugins.items():
+        # 创建字典快照避免并发修改
+        running_plugins_snapshot = dict(self._running_plugins)
+        for plugin_id, plugin in running_plugins_snapshot.items():
             if not hasattr(plugin, "get_dashboard") or not ObjectUtils.check_method(plugin.get_dashboard):
                 continue
             try:
@@ -734,7 +751,7 @@ class PluginManager(metaclass=Singleton):
         """
         return list(self._running_plugins.keys())
 
-    def get_online_plugins(self) -> List[schemas.Plugin]:
+    def get_online_plugins(self, force: bool = False) -> List[schemas.Plugin]:
         """
         获取所有在线插件信息
         """
@@ -755,12 +772,13 @@ class PluginManager(metaclass=Singleton):
                 if not m:
                     continue
                 # 提交任务获取 v1 版本插件，存储 future 到 version 的映射
-                base_future = executor.submit(self.get_plugins_from_market, m, None)
+                base_future = executor.submit(self.get_plugins_from_market, m, None, force)
                 futures_to_version[base_future] = "base_version"
 
                 # 提交任务获取高版本插件（如 v2、v3），存储 future 到 version 的映射
                 if settings.VERSION_FLAG:
-                    higher_version_future = executor.submit(self.get_plugins_from_market, m, settings.VERSION_FLAG)
+                    higher_version_future = executor.submit(self.get_plugins_from_market, m,
+                                                            settings.VERSION_FLAG, force)
                     futures_to_version[higher_version_future] = "higher_version"
 
             # 按照完成顺序处理结果
@@ -868,10 +886,11 @@ class PluginManager(metaclass=Singleton):
         return plugins
 
     @staticmethod
-    def is_plugin_exists(pid: str) -> bool:
+    def is_plugin_exists(pid: str, version: str = None) -> bool:
         """
-        判断插件是否在本地包中存在
+        判断插件是否存在，并满足版本要求(有传入version时)
         :param pid: 插件ID
+        :param version: 插件版本
         """
         if not pid:
             return False
@@ -882,17 +901,30 @@ class PluginManager(metaclass=Singleton):
             spec = importlib.util.find_spec(package_name)
             package_exists = spec is not None and spec.origin is not None
             logger.debug(f"{pid} exists: {package_exists}")
-            return package_exists
+            if not package_exists:
+                return False
+
+            local_version = PluginManager().get_plugin_attr(pid=pid, attr="plugin_version")
+            if not local_version:
+                return False
+
+            if version and not StringUtils.compare_version(local_version, ">=", version):
+                logger.warn(f"Plugin {pid} version: {local_version} (older than version: {version})")
+                return False
+
+            return True
         except Exception as e:
             logger.debug(f"获取插件是否在本地包中存在失败，{e}")
             return False
 
     def get_plugins_from_market(self, market: str,
-                                package_version: Optional[str] = None) -> Optional[List[schemas.Plugin]]:
+                                package_version: Optional[str] = None,
+                                force: bool = False) -> Optional[List[schemas.Plugin]]:
         """
         从指定的市场获取插件信息
         :param market: 市场的 URL 或标识
         :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
+        :param force: 是否强制刷新（忽略缓存）
         :return: 返回插件的列表，若获取失败返回 []
         """
         if not market:
@@ -900,7 +932,7 @@ class PluginManager(metaclass=Singleton):
         # 已安装插件
         installed_apps = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
         # 获取在线插件
-        online_plugins = PluginHelper().get_plugins(market, package_version)
+        online_plugins = PluginHelper().get_plugins(market, package_version, force)
         if online_plugins is None:
             logger.warning(
                 f"获取{package_version if package_version else ''}插件库失败：{market}，请检查 GitHub 网络连接")
@@ -1086,7 +1118,7 @@ class PluginManager(metaclass=Singleton):
             success, msg = self._modify_plugin_files(
                 plugin_dir=clone_plugin_dir,
                 original_id=plugin_id,
-                suffix=suffix,
+                suffix=suffix.lower(),
                 name=name,
                 description=description,
                 version=version,
@@ -1116,7 +1148,7 @@ class PluginManager(metaclass=Singleton):
                 # 默认禁用分身插件，让用户手动配置
                 clone_config['enable'] = False
                 clone_config['enabled'] = False
-                self.save_plugin_config(clone_id, clone_config)
+                self.save_plugin_config(clone_id, clone_config, force=True)
                 logger.info(f"已为分身插件 {clone_id} 设置初始配置")
             else:
                 logger.info(f"原插件 {plugin_id} 没有配置，分身插件 {clone_id} 将使用默认配置")

app/db/__init__.py

@@ -236,7 +236,6 @@ class DbOper:
     """
     数据库操作基类
     """
-    _db: Session = None
 
     def __init__(self, db: Session = None):
         self._db = db

app/db/models/__init__.py

@@ -9,3 +9,4 @@ from .transferhistory import TransferHistory
 from .user import User
 from .userconfig import UserConfig
 from .workflow import Workflow
+from .userrequest import UserRequest

app/db/systemconfig_oper.py

@@ -1,4 +1,5 @@
-from typing import Any, Union, Optional
+import copy
+from typing import Any, Optional, Union
 
 from app.db import DbOper
 from app.db.models.systemconfig import SystemConfig
@@ -7,14 +8,15 @@ from app.utils.singleton import Singleton
 
 
 class SystemConfigOper(DbOper, metaclass=Singleton):
-    # 配置对象
-    __SYSTEMCONF: dict = {}
-
+    """
+    系统配置管理
+    """
     def __init__(self):
         """
         加载配置到内存
         """
         super().__init__()
+        self.__SYSTEMCONF = {}
         for item in SystemConfig.list(self._db):
             self.__SYSTEMCONF[item.key] = item.value
 
@@ -29,8 +31,8 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
             key = key.value
         # 旧值
         old_value = self.__SYSTEMCONF.get(key)
-        # 更新内存
-        self.__SYSTEMCONF[key] = value
+        # 更新内存(deepcopy避免内存共享)
+        self.__SYSTEMCONF[key] = copy.deepcopy(value)
         conf = SystemConfig.get_by_key(self._db, key)
         if conf:
             if old_value != value:
@@ -52,14 +54,16 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
         if isinstance(key, SystemConfigKey):
             key = key.value
         if not key:
-            return self.__SYSTEMCONF
-        return self.__SYSTEMCONF.get(key)
+            return self.all()
+        # 避免将__SYSTEMCONF内的值引用出去，会导致set时误判没有变动
+        return copy.deepcopy(self.__SYSTEMCONF.get(key))
 
     def all(self):
         """
         获取所有系统设置
         """
-        return self.__SYSTEMCONF or {}
+        # 避免将__SYSTEMCONF内的值引用出去，会导致set时误判没有变动
+        return copy.deepcopy(self.__SYSTEMCONF)
 
     def delete(self, key: Union[str, SystemConfigKey]) -> bool:
         """

app/db/userconfig_oper.py

@@ -7,14 +7,15 @@ from app.utils.singleton import Singleton
 
 
 class UserConfigOper(DbOper, metaclass=Singleton):
-    # 配置缓存
-    __USERCONF: Dict[str, Dict[str, Any]] = {}
-
+    """
+    用户配置管理
+    """
     def __init__(self):
         """
         加载配置到内存
         """
         super().__init__()
+        self.__USERCONF = {}
         for item in UserConfig.list(self._db):
             self.__set_config_cache(username=item.username, key=item.key, value=item.value)
 

app/helper/__init__.py

@@ -1,2 +1 @@
-from .doh import doh_query_json
 from .cloudflare import under_challenge

app/helper/browser.py

@@ -1,8 +1,8 @@
 from typing import Callable, Any, Optional
-import gc
 
-from playwright.sync_api import sync_playwright, Page
 from cf_clearance import sync_cf_retry, sync_stealth
+from playwright.sync_api import sync_playwright, Page
+
 from app.log import logger
 
 
@@ -67,8 +67,6 @@ class PlaywrightHelper:
                         context.close()
                     if browser:
                         browser.close()
-                    # 强制垃圾回收
-                    gc.collect()
         except Exception as e:
             logger.error(f"Playwright初始化失败: {str(e)}")
         
@@ -120,8 +118,6 @@ class PlaywrightHelper:
                         context.close()
                     if browser:
                         browser.close()
-                    # 强制垃圾回收
-                    gc.collect()
         except Exception as e:
             logger.error(f"Playwright初始化失败: {str(e)}")
         

app/helper/doh.py

@@ -10,10 +10,15 @@ import socket
 import struct
 import urllib
 import urllib.request
+from threading import Lock
 from typing import Dict, Optional
 
 from app.core.config import settings
+from app.core.event import Event, eventmanager
 from app.log import logger
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import EventType
+from app.utils.singleton import Singleton
 
 # 定义一个全局线程池执行器
 _executor = concurrent.futures.ThreadPoolExecutor()
@@ -21,41 +26,63 @@ _executor = concurrent.futures.ThreadPoolExecutor()
 # 定义默认的DoH配置
 _doh_timeout = 5
 _doh_cache: Dict[str, str] = {}
+_doh_lock = Lock()
+# 保存原始的 socket.getaddrinfo 方法
+_orig_getaddrinfo = socket.getaddrinfo
 
 
-def _patched_getaddrinfo(host, *args, **kwargs):
+def enable_doh(enable: bool):
     """
-    socket.getaddrinfo的补丁版本。
+    对 socket.getaddrinfo 进行补丁
     """
-    if host not in settings.DOH_DOMAINS.split(","):
+
+    def _patched_getaddrinfo(host, *args, **kwargs):
+        """
+        socket.getaddrinfo的补丁版本。
+        """
+        if host not in settings.DOH_DOMAINS.split(","):
+            return _orig_getaddrinfo(host, *args, **kwargs)
+        # 检查主机是否已解析
+        with _doh_lock:
+            ip = _doh_cache.get("host", None)
+        if ip is not None:
+            logger.info("已解析 [%s] 为 [%s] (缓存)", host, ip)
+            return _orig_getaddrinfo(ip, *args, **kwargs)
+        # 使用DoH解析主机
+        futures = []
+        for resolver in settings.DOH_RESOLVERS.split(","):
+            futures.append(_executor.submit(_doh_query, resolver, host))
+        for future in concurrent.futures.as_completed(futures):
+            ip = future.result()
+            if ip is not None:
+                logger.info("已解析 [%s] 为 [%s]", host, ip)
+                with _doh_lock:
+                    _doh_cache[host] = ip
+                host = ip
+                break
         return _orig_getaddrinfo(host, *args, **kwargs)
 
-    # 检查主机是否已解析
-    if host in _doh_cache:
-        ip = _doh_cache[host]
-        logger.info("已解析 [%s] 为 [%s] (缓存)", host, ip)
-        return _orig_getaddrinfo(ip, *args, **kwargs)
+    if enable:
+        # 替换 socket.getaddrinfo 方法
+        socket.getaddrinfo = _patched_getaddrinfo
+    else:
+        socket.getaddrinfo = _orig_getaddrinfo
 
-    # 使用DoH解析主机
-    futures = []
-    for resolver in settings.DOH_RESOLVERS.split(","):
-        futures.append(_executor.submit(_doh_query, resolver, host))
+class DohHelper(metaclass=Singleton):
+    def __init__(self):
+        enable_doh(settings.DOH_ENABLE)
 
-    for future in concurrent.futures.as_completed(futures):
-        ip = future.result()
-        if ip is not None:
-            logger.info("已解析 [%s] 为 [%s]", host, ip)
-            _doh_cache[host] = ip
-            host = ip
-            break
-
-    return _orig_getaddrinfo(host, *args, **kwargs)
-
-
-# 对 socket.getaddrinfo 进行补丁
-if settings.DOH_ENABLE:
-    _orig_getaddrinfo = socket.getaddrinfo
-    socket.getaddrinfo = _patched_getaddrinfo
+    @eventmanager.register(EventType.ConfigChanged)
+    def handle_config_changed(self, event: Event):
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ["DOH_ENABLE", "DOH_DOMAINS", "DOH_RESOLVERS"]:
+            return
+        with _doh_lock:
+            # DOH配置有变动的情况下，清空缓存
+            _doh_cache.clear()
+        enable_doh(settings.DOH_ENABLE)
 
 
 def _doh_query(resolver: str, host: str) -> Optional[str]:

app/helper/memory.py

@@ -1,93 +1,74 @@
 import gc
-import psutil
+import sys
 import threading
 import time
-from typing import Optional, Callable, Any
-from functools import wraps
+from datetime import datetime
+from typing import Optional
+
+import psutil
+from pympler import muppy, summary, asizeof
+
+from app.core.config import settings
+from app.core.event import eventmanager, Event
 from app.log import logger
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import EventType
 from app.utils.singleton import Singleton
 
 
-class MemoryManager(metaclass=Singleton):
+class MemoryHelper(metaclass=Singleton):
     """
     内存管理工具类，用于监控和优化内存使用
     """
-    
+
     def __init__(self):
-        self._memory_threshold = 512  # 内存使用阈值(MB)
-        self._check_interval = 300   # 检查间隔(秒)
+        # 检查间隔(秒) - 从配置获取，默认5分钟
+        self._check_interval = settings.MEMORY_SNAPSHOT_INTERVAL * 60
         self._monitoring = False
         self._monitor_thread: Optional[threading.Thread] = None
-        
-    @staticmethod
-    def get_memory_usage() -> dict:
-        """
-        获取当前内存使用情况
-        """
-        process = psutil.Process()
-        memory_info = process.memory_info()
-        system_memory = psutil.virtual_memory()
-        
-        return {
-            'rss': memory_info.rss / 1024 / 1024,  # MB
-            'vms': memory_info.vms / 1024 / 1024,  # MB
-            'percent': process.memory_percent(),
-            'system_percent': system_memory.percent,
-            'system_available': system_memory.available / 1024 / 1024 / 1024  # GB
-        }
-    
-    def force_gc(self, generation: Optional[int] = None) -> int:
-        """
-        强制执行垃圾回收
-        :param generation: 垃圾回收代数，None表示所有代数
-        :return: 回收的对象数量
-        """
-        before_memory = self.get_memory_usage()
-        logger.info(f"开始强制垃圾回收，当前内存使用: {before_memory['rss']:.2f}MB")
+        # 内存快照保存目录
+        self._memory_snapshot_dir = settings.LOG_PATH / "memory_snapshots"
+        # 保留的快照文件数量
+        self._keep_count = settings.MEMORY_SNAPSHOT_KEEP_COUNT
 
-        if generation is not None:
-            collected = gc.collect(generation)
-        else:
-            collected = gc.collect()
-            
-        after_memory = self.get_memory_usage()
-        memory_freed = before_memory['rss'] - after_memory['rss']
-        
-        if memory_freed > 0:
-            logger.info(f"垃圾回收完成: 回收对象 {collected} 个, 释放内存 {memory_freed:.2f}MB")
-            
-        return collected
-    
-    def check_memory_and_cleanup(self) -> bool:
+    @eventmanager.register(EventType.ConfigChanged)
+    def handle_config_changed(self, event: Event):
         """
-        检查内存使用量，如果超过阈值则执行清理
-        :return: 是否执行了清理
+        处理配置变更事件，更新内存监控设置
+        :param event: 事件对象
         """
-        memory_info = self.get_memory_usage()
-        current_memory_mb = memory_info['rss']
-        
-        if current_memory_mb > self._memory_threshold:
-            logger.warning(f"内存使用超过阈值: {current_memory_mb:.1f}MB > {self._memory_threshold:.1f}MB, 开始清理...")
-            self.force_gc()
-            
-            # 再次检查清理效果
-            after_memory = self.get_memory_usage()
-            logger.info(f"清理后内存: {after_memory['rss']:.1f}MB")
-            return True
-        return False
-    
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ['MEMORY_ANALYSIS', 'MEMORY_SNAPSHOT_INTERVAL', 'MEMORY_SNAPSHOT_KEEP_COUNT']:
+            return
+
+        # 更新配置
+        if event_data.key == 'MEMORY_SNAPSHOT_INTERVAL':
+            self._check_interval = settings.MEMORY_SNAPSHOT_INTERVAL * 60
+        elif event_data.key == 'MEMORY_SNAPSHOT_KEEP_COUNT':
+            self._keep_count = settings.MEMORY_SNAPSHOT_KEEP_COUNT
+        self.stop_monitoring()
+        self.start_monitoring()
+
     def start_monitoring(self):
         """
         开始内存监控
         """
+        if not settings.MEMORY_ANALYSIS:
+            return
         if self._monitoring:
             return
-            
+
+        # 创建内存快照目录
+        self._memory_snapshot_dir.mkdir(parents=True, exist_ok=True)
+
+        # 初始化内存分析器
         self._monitoring = True
         self._monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True)
         self._monitor_thread.start()
-        logger.info(f"内存监控已启动 - 阈值: {self._memory_threshold}MB, 检查间隔: {self._check_interval}秒")
-    
+        logger.info("内存监控已启动")
+
     def stop_monitoring(self):
         """
         停止内存监控
@@ -95,82 +76,382 @@ class MemoryManager(metaclass=Singleton):
         self._monitoring = False
         if self._monitor_thread:
             self._monitor_thread.join(timeout=5)
-        logger.info("内存监控已停止")
-    
+            logger.info("内存监控已停止")
+
     def _monitor_loop(self):
         """
         内存监控循环
         """
+        logger.info("内存监控循环开始")
         while self._monitoring:
             try:
-                self.check_memory_and_cleanup()
+                # 生成内存快照
+                self._create_memory_snapshot()
                 time.sleep(self._check_interval)
             except Exception as e:
                 logger.error(f"内存监控出错: {e}")
-                time.sleep(60)  # 出错后等待1分钟再继续
-    
-    def set_threshold(self, threshold_mb: int):
-        """
-        设置内存使用阈值
-        :param threshold_mb: 内存阈值，单位MB（500-4096之间）
-        """
-        self._memory_threshold = max(512, min(4096, threshold_mb))
-        logger.info(f"内存阈值已设置为: {self._memory_threshold}MB")
-    
-    def set_check_interval(self, interval: int):
-        """
-        设置检查间隔
-        :param interval: 检查间隔，单位秒（最少60秒）
-        """
-        self._check_interval = max(60, interval)
-        logger.info(f"内存检查间隔已设置为: {self._check_interval}秒")
-    
-    def get_threshold(self) -> int:
-        """
-        获取当前内存阈值
-        :return: 当前阈值(MB)
-        """
-        return self._memory_threshold
+                # 出错后等待1分钟再继续
+                time.sleep(60)
+        logger.info("内存监控循环结束")
 
+    def _create_memory_snapshot(self):
+        """
+        创建内存快照并保存到文件
+        """
+        try:
+            # 获取当前时间戳
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            snapshot_file = self._memory_snapshot_dir / f"memory_snapshot_{timestamp}.txt"
 
-def memory_optimized(force_gc_after: bool = False, log_memory: bool = False):
-    """
-    内存优化装饰器
-    :param force_gc_after: 函数执行后是否强制垃圾回收
-    :param log_memory: 是否记录内存使用情况
-    """
-    def decorator(func: Callable) -> Callable:
-        @wraps(func)
-        def wrapper(*args, **kwargs) -> Any:
-            memory_manager = MemoryManager()
-            
-            if log_memory:
-                before_memory = memory_manager.get_memory_usage()
-                logger.info(f"{func.__name__} 执行前内存: {before_memory['rss']:.1f}MB")
-            
+            # 获取系统内存使用情况
+            memory_usage = psutil.Process().memory_info().rss
+
+            logger.info(f"开始创建内存快照: {snapshot_file}")
+
+            # 第一步：写入基本信息和对象类型统计
+            self._write_basic_info(snapshot_file, memory_usage)
+
+            # 第二步：分析并写入类实例内存使用情况
+            self._append_class_analysis(snapshot_file)
+
+            # 第三步：分析并写入大内存变量详情
+            self._append_variable_analysis(snapshot_file)
+
+            logger.info(f"内存快照已保存: {snapshot_file}, 当前内存使用: {memory_usage / 1024 / 1024:.2f} MB")
+
+            # 清理过期的快照文件（保留最近30个）
+            self._cleanup_old_snapshots()
+
+        except Exception as e:
+            logger.error(f"创建内存快照失败: {e}")
+
+    @staticmethod
+    def _write_basic_info(snapshot_file, memory_usage):
+        """
+        写入基本信息和对象类型统计
+        """
+        # 获取当前进程的内存使用情况
+        all_objects = muppy.get_objects()
+        sum1 = summary.summarize(all_objects)
+
+        with open(snapshot_file, 'w', encoding='utf-8') as f:
+            f.write(f"内存快照时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"当前进程内存使用: {memory_usage / 1024 / 1024:.2f} MB\n")
+            f.write("=" * 80 + "\n")
+            f.write("对象类型统计:\n")
+            f.write("-" * 80 + "\n")
+
+            # 写入对象统计信息
+            for line in summary.format_(sum1):
+                f.write(line + "\n")
+
+            # 立即刷新到磁盘
+            f.flush()
+
+        logger.debug("基本信息已写入快照文件")
+
+    def _append_class_analysis(self, snapshot_file):
+        """
+        分析并追加类实例内存使用情况
+        """
+        with open(snapshot_file, 'a', encoding='utf-8') as f:
+            f.write("\n" + "=" * 80 + "\n")
+            f.write("类实例内存使用情况 (按内存大小排序):\n")
+            f.write("-" * 80 + "\n")
+            f.write("正在分析中...\n")
+            # 立即刷新，让用户知道这部分开始了
+            f.flush()
+
+        try:
+            logger.debug("开始分析类实例内存使用情况")
+            class_objects = self._get_class_memory_usage()
+
+            # 重新打开文件，移除"正在分析中..."并写入实际结果
+            with open(snapshot_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # 替换"正在分析中..."
+            content = content.replace("正在分析中...\n", "")
+
+            with open(snapshot_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+                if class_objects:
+                    # 只显示前100个类
+                    for i, class_info in enumerate(class_objects[:100], 1):
+                        f.write(f"{i:3d}. {class_info['name']:<50} "
+                                f"{class_info['size_mb']:>8.2f} MB ({class_info['count']} 个实例)\n")
+                else:
+                    f.write("未找到有效的类实例信息\n")
+
+                f.flush()
+
+        except Exception as e:
+            logger.error(f"获取类实例信息失败: {e}")
+
+            # 即使出错也要更新文件
+            with open(snapshot_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            content = content.replace("正在分析中...\n", f"获取类实例信息失败: {e}\n")
+
+            with open(snapshot_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+                f.flush()
+
+        logger.debug("类实例分析已完成并写入")
+
+    def _append_variable_analysis(self, snapshot_file):
+        """
+        分析并追加大内存变量详情
+        """
+        with open(snapshot_file, 'a', encoding='utf-8') as f:
+            f.write("\n" + "=" * 80 + "\n")
+            f.write("大内存变量详情 (前100个):\n")
+            f.write("-" * 80 + "\n")
+            f.write("正在分析中...\n")
+            # 立即刷新，让用户知道这部分开始了
+            f.flush()
+
+        try:
+            logger.debug("开始分析大内存变量")
+            large_variables = self._get_large_variables(100)
+
+            # 重新打开文件，移除"正在分析中..."并写入实际结果
+            with open(snapshot_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # 替换最后的"正在分析中..."
+            content = content.replace("正在分析中...\n", "")
+
+            with open(snapshot_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+                if large_variables:
+                    for i, var_info in enumerate(large_variables, 1):
+                        f.write(
+                            f"{i:3d}. {var_info['name']:<30} {var_info['type']:<15} {var_info['size_mb']:>8.2f} MB\n")
+                else:
+                    f.write("未找到大内存变量\n")
+
+                f.flush()
+
+        except Exception as e:
+            logger.error(f"获取大内存变量信息失败: {e}")
+
+            # 即使出错也要更新文件
+            with open(snapshot_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            content = content.replace("正在分析中...\n", f"获取变量信息失败: {e}\n")
+
+            with open(snapshot_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+                f.flush()
+
+        logger.debug("大内存变量分析已完成并写入")
+
+    def _cleanup_old_snapshots(self):
+        """
+        清理过期的内存快照文件，只保留最近的指定数量文件
+        """
+        try:
+            snapshot_files = list(self._memory_snapshot_dir.glob("memory_snapshot_*.txt"))
+            if len(snapshot_files) > self._keep_count:
+                # 按修改时间排序，删除最旧的文件
+                snapshot_files.sort(key=lambda x: x.stat().st_mtime)
+                for old_file in snapshot_files[:-self._keep_count]:
+                    old_file.unlink()
+                    logger.debug(f"已删除过期内存快照: {old_file}")
+        except Exception as e:
+            logger.error(f"清理过期快照失败: {e}")
+
+    @staticmethod
+    def _get_class_memory_usage():
+        """
+        获取所有类实例的内存使用情况，按内存大小排序
+        """
+        class_info = {}
+        processed_count = 0
+        error_count = 0
+
+        # 获取所有对象
+        all_objects = muppy.get_objects()
+        logger.debug(f"开始分析 {len(all_objects)} 个对象的类实例内存使用情况")
+
+        for obj in all_objects:
             try:
-                result = func(*args, **kwargs)
-                return result
-            finally:
-                if force_gc_after:
-                    memory_manager.force_gc()
+                # 跳过类对象本身，统计类的实例
+                if isinstance(obj, type):
+                    continue
+
+                # 获取对象的类名 - 这里可能会出错
+                obj_class = type(obj)
+
+                # 安全地获取类名
+                try:
+                    if hasattr(obj_class, '__module__') and hasattr(obj_class, '__name__'):
+                        class_name = f"{obj_class.__module__}.{obj_class.__name__}"
+                    else:
+                        class_name = str(obj_class)
+                except Exception as e:
+                    # 如果获取类名失败，使用简单的类型描述
+                    class_name = f"<unknown_class_{id(obj_class)}>"
+                    logger.debug(f"获取类名失败: {e}")
+
+                # 计算对象本身的内存使用（不包括引用对象，避免重复计算）
+                size_bytes = sys.getsizeof(obj)
+                if size_bytes < 100:  # 跳过太小的对象
+                    continue
+
+                size_mb = size_bytes / 1024 / 1024
+                processed_count += 1
+
+                if class_name in class_info:
+                    class_info[class_name]['size_mb'] += size_mb
+                    class_info[class_name]['count'] += 1
+                else:
+                    class_info[class_name] = {
+                        'name': class_name,
+                        'size_mb': size_mb,
+                        'count': 1
+                    }
+
+            except Exception as e:
+                # 捕获所有可能的异常，包括SQLAlchemy、ORM等框架的异常
+                error_count += 1
+                if error_count <= 5:  # 只记录前5个错误，避免日志过多
+                    logger.debug(f"分析对象时出错: {e}")
+                continue
+
+        logger.debug(f"类实例分析完成: 处理了 {processed_count} 个对象, 遇到 {error_count} 个错误")
+
+        # 按内存大小排序
+        sorted_classes = sorted(class_info.values(), key=lambda x: x['size_mb'], reverse=True)
+        return sorted_classes
+
+    def _get_large_variables(self, limit=100):
+        """
+        获取大内存变量信息，按内存大小排序
+        使用已计算对象集合避免重复计算
+        """
+        large_vars = []
+        processed_count = 0
+        calculated_objects = set()  # 避免重复计算
+
+        # 获取所有对象
+        all_objects = muppy.get_objects()
+        logger.debug(f"开始分析 {len(all_objects)} 个对象的内存使用情况")
+
+        for obj in all_objects:
+            # 跳过类对象
+            if isinstance(obj, type):
+                continue
+
+            # 跳过已经计算过的对象
+            obj_id = id(obj)
+            if obj_id in calculated_objects:
+                continue
+
+            try:
+                # 首先使用 sys.getsizeof 快速筛选
+                shallow_size = sys.getsizeof(obj)
+                if shallow_size < 1024:  # 只处理大于1KB的对象
+                    continue
+
+                # 对于较大的对象，使用 asizeof 进行深度计算
+                size_bytes = asizeof.asizeof(obj)
                 
-                if log_memory:
-                    after_memory = memory_manager.get_memory_usage()
-                    logger.info(f"{func.__name__} 执行后内存: {after_memory['rss']:.1f}MB")
-        
-        return wrapper
-    return decorator
+                # 只处理大于10KB的对象，提高分析效率
+                if size_bytes < 10240:
+                    continue
 
+                size_mb = size_bytes / 1024 / 1024
+                processed_count += 1
+                calculated_objects.add(obj_id)
 
-def clear_large_objects(*objects):
-    """
-    清理大型对象的辅助函数
-    """
-    for obj in objects:
-        if hasattr(obj, 'clear') and callable(obj.clear):
-            obj.clear()
-        elif hasattr(obj, '__dict__'):
-            obj.__dict__.clear()
-        del obj
-    gc.collect()
+                # 获取对象信息
+                var_info = self._get_variable_info(obj, size_mb)
+                if var_info:
+                    large_vars.append(var_info)
+
+                # 如果已经找到足够多的大对象，可以提前结束
+                if len(large_vars) >= limit * 2:  # 多收集一些，后面排序筛选
+                    break
+
+            except Exception as e:
+                # 更广泛的异常捕获
+                logger.debug(f"分析对象失败: {e}")
+                continue
+
+        logger.debug(f"处理了 {processed_count} 个大对象，找到 {len(large_vars)} 个有效变量")
+
+        # 按内存大小排序并返回前N个
+        large_vars.sort(key=lambda x: x['size_mb'], reverse=True)
+        return large_vars[:limit]
+
+    def _get_variable_info(self, obj, size_mb):
+        """
+        获取变量的描述信息
+        """
+        try:
+            obj_type = type(obj).__name__
+
+            # 尝试获取变量名
+            var_name = self._get_variable_name(obj)
+
+            # 生成描述性信息
+            if isinstance(obj, dict):
+                key_count = len(obj)
+                if key_count > 0:
+                    sample_keys = list(obj.keys())[:3]
+                    var_name += f" ({key_count}项, 键: {sample_keys})"
+            elif isinstance(obj, (list, tuple, set)):
+                var_name += f" ({len(obj)}个元素)"
+            elif isinstance(obj, str):
+                if len(obj) > 50:
+                    var_name += f" (长度: {len(obj)}, 内容: '{obj[:50]}...')"
+                else:
+                    var_name += f" ('{obj}')"
+            elif hasattr(obj, '__class__') and hasattr(obj.__class__, '__name__'):
+                if hasattr(obj, '__dict__'):
+                    attr_count = len(obj.__dict__)
+                    var_name += f" ({attr_count}个属性)"
+
+            return {
+                'name': var_name,
+                'type': obj_type,
+                'size_mb': size_mb
+            }
+
+        except Exception as e:
+            logger.debug(f"获取变量信息失败: {e}")
+            return None
+
+    @staticmethod
+    def _get_variable_name(obj):
+        """
+        尝试获取变量名
+        """
+        try:
+            # 尝试通过gc获取引用该对象的变量名
+            referrers = gc.get_referrers(obj)
+
+            for referrer in referrers:
+                if isinstance(referrer, dict):
+                    # 检查是否在某个模块的全局变量中
+                    for name, value in referrer.items():
+                        if value is obj and isinstance(name, str):
+                            return name
+                elif hasattr(referrer, '__dict__'):
+                    # 检查是否在某个实例的属性中
+                    for name, value in referrer.__dict__.items():
+                        if value is obj and isinstance(name, str):
+                            return f"{type(referrer).__name__}.{name}"
+
+            # 如果找不到变量名，返回对象类型和id
+            return f"{type(obj).__name__}_{id(obj)}"
+
+        except Exception as e:
+            logger.debug(f"获取变量名失败: {e}")
+            return f"{type(obj).__name__}_{id(obj)}"

app/helper/message.py

@@ -241,7 +241,7 @@ class TemplateContextBuilder:
             "total_size": StringUtils.str_filesize(transferinfo.total_size),
             "err_msg": transferinfo.message,
         }
-        self._context.update(ctx)
+        return self._context.update(ctx)
 
     def _add_file_info(self, file_extension: Optional[str]):
         """
@@ -363,7 +363,7 @@ class TemplateHelper(metaclass=SingletonClass):
                 self.set_cache_context(rendered, context)
                 # 返回渲染结果
                 return rendered
-
+            return None
         except Exception as e:
             logger.error(f"模板处理失败: {str(e)}")
             raise ValueError(f"模板处理失败: {str(e)}") from e
@@ -645,7 +645,8 @@ class MessageQueueManager(metaclass=SingletonClass):
         """
         发送消息（立即发送或加入队列）
         """
-        if self._is_in_scheduled_time(datetime.now()):
+        immediately = kwargs.pop("immediately", False)
+        if immediately or self._is_in_scheduled_time(datetime.now()):
             self._send(*args, **kwargs)
         else:
             self.queue.put({

app/helper/plugin.py

@@ -41,12 +41,35 @@ class PluginHelper(metaclass=Singleton):
                 if self.install_report():
                     self.systemconfig.set(SystemConfigKey.PluginInstallReport, "1")
 
-    @cached(maxsize=64, ttl=1800)
-    def get_plugins(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
+    def get_plugins(self, repo_url: str, package_version: Optional[str] = None,
+                    force: bool = False) -> Optional[Dict[str, dict]]:
         """
         获取Github所有最新插件列表
         :param repo_url: Github仓库地址
         :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
+        :param force: 是否强制刷新，忽略缓存
+        """
+        # 如果强制刷新，直接调用不带缓存的版本
+        if force:
+            return self._get_plugins_uncached(repo_url, package_version)
+        
+        # 正常情况下调用带缓存的版本
+        return self._get_plugins_cached(repo_url, package_version)
+    
+    @cached(maxsize=64, ttl=1800)
+    def _get_plugins_cached(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
+        """
+        获取Github所有最新插件列表（使用缓存）
+        :param repo_url: Github仓库地址
+        :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
+        """
+        return self._get_plugins_uncached(repo_url, package_version)
+    
+    def _get_plugins_uncached(self, repo_url: str, package_version: Optional[str] = None) -> Optional[Dict[str, dict]]:
+        """
+        获取Github所有最新插件列表（不使用缓存）
+        :param repo_url: Github仓库地址
+        :param package_version: 首选插件版本 (如 "v2", "v3")，如果不指定则获取 v1 版本
         """
         if not repo_url:
             return None

app/helper/rss.py

@@ -1,4 +1,3 @@
-import gc
 import re
 import traceback
 from typing import List, Tuple, Union, Optional
@@ -18,11 +17,11 @@ class RssHelper:
     """
     RSS帮助类，解析RSS报文、获取RSS地址等
     """
-    
+
     # RSS解析限制配置
     MAX_RSS_SIZE = 50 * 1024 * 1024  # 50MB最大RSS文件大小
     MAX_RSS_ITEMS = 1000  # 最大解析条目数
-    
+
     # 各站点RSS链接获取配置
     rss_link_conf = {
         "default": {
@@ -228,7 +227,8 @@ class RssHelper:
         },
     }
 
-    def parse(self, url, proxy: bool = False, timeout: Optional[int] = 15, headers: dict = None) -> Union[List[dict], None, bool]:
+    def parse(self, url, proxy: bool = False,
+              timeout: Optional[int] = 15, headers: dict = None) -> Union[List[dict], None, bool]:
         """
         解析RSS订阅URL，获取RSS中的种子信息
         :param url: RSS地址
@@ -241,7 +241,7 @@ class RssHelper:
         ret_array: list = []
         if not url:
             return False
-        
+
         try:
             ret = RequestUtils(proxies=settings.PROXY if proxy else None,
                                timeout=timeout, headers=headers).get_res(url)
@@ -250,7 +250,7 @@ class RssHelper:
         except Exception as err:
             logger.error(f"获取RSS失败：{str(err)} - {traceback.format_exc()}")
             return False
-        
+
         if ret:
             ret_xml = None
             root = None
@@ -258,9 +258,9 @@ class RssHelper:
                 # 检查响应大小，避免处理过大的RSS文件
                 raw_data = ret.content
                 if raw_data and len(raw_data) > self.MAX_RSS_SIZE:
-                    logger.warning(f"RSS文件过大: {len(raw_data)/1024/1024:.1f}MB，跳过解析")
+                    logger.warning(f"RSS文件过大: {len(raw_data) / 1024 / 1024:.1f}MB，跳过解析")
                     return False
-                
+
                 if raw_data:
                     try:
                         result = chardet.detect(raw_data)
@@ -279,7 +279,7 @@ class RssHelper:
                             ret.encoding = ret.apparent_encoding
                 if not ret_xml:
                     ret_xml = ret.text
-                
+
                 # 使用lxml.etree解析XML
                 parser = None
                 try:
@@ -307,42 +307,39 @@ class RssHelper:
                 finally:
                     if parser is not None:
                         del parser
-                
+
                 if root is None:
                     logger.error("无法解析RSS内容")
                     return False
-                
+
                 # 查找所有item或entry节点
                 items = root.xpath('.//item | .//entry')
-                
+
                 # 限制处理的条目数量
                 items_count = min(len(items), self.MAX_RSS_ITEMS)
                 if len(items) > self.MAX_RSS_ITEMS:
                     logger.warning(f"RSS条目过多: {len(items)}，仅处理前{self.MAX_RSS_ITEMS}个")
-                
-                for i, item in enumerate(items[:items_count]):
+
+                for item in items[:items_count]:
                     try:
-                        # 定期执行垃圾回收
-                        if i > 0 and i % 100 == 0:
-                            gc.collect()
-                        
                         # 使用xpath提取信息，更高效
                         title_nodes = item.xpath('.//title')
                         title = title_nodes[0].text if title_nodes and title_nodes[0].text else ""
                         if not title:
                             continue
-                        
+
                         # 描述
                         desc_nodes = item.xpath('.//description | .//summary')
                         description = desc_nodes[0].text if desc_nodes and desc_nodes[0].text else ""
-                        
+
                         # 种子页面
                         link_nodes = item.xpath('.//link')
                         if link_nodes:
-                            link = link_nodes[0].text if hasattr(link_nodes[0], 'text') and link_nodes[0].text else link_nodes[0].get('href', '')
+                            link = link_nodes[0].text if hasattr(link_nodes[0], 'text') and link_nodes[0].text else \
+                            link_nodes[0].get('href', '')
                         else:
                             link = ""
-                        
+
                         # 种子链接
                         enclosure_nodes = item.xpath('.//enclosure')
                         enclosure = enclosure_nodes[0].get('url', '') if enclosure_nodes else ""
@@ -351,24 +348,24 @@ class RssHelper:
                         # 部分RSS只有link没有enclosure
                         if not enclosure and link:
                             enclosure = link
-                        
+
                         # 大小
                         size = 0
                         if enclosure_nodes:
                             size_attr = enclosure_nodes[0].get('length', '0')
                             if size_attr and str(size_attr).isdigit():
                                 size = int(size_attr)
-                        
+
                         # 发布日期
                         pubdate_nodes = item.xpath('.//pubDate | .//published | .//updated')
                         pubdate = ""
                         if pubdate_nodes and pubdate_nodes[0].text:
                             pubdate = StringUtils.get_time(pubdate_nodes[0].text)
-                        
+
                         # 获取豆瓣昵称
                         nickname_nodes = item.xpath('.//*[local-name()="creator"]')
                         nickname = nickname_nodes[0].text if nickname_nodes and nickname_nodes[0].text else ""
-                        
+
                         # 返回对象
                         tmp_dict = {
                             'title': title,
@@ -382,11 +379,11 @@ class RssHelper:
                         if nickname:
                             tmp_dict['nickname'] = nickname
                         ret_array.append(tmp_dict)
-                        
+
                     except Exception as e1:
                         logger.debug(f"解析RSS条目失败：{str(e1)} - {traceback.format_exc()}")
                         continue
-                        
+
             except Exception as e2:
                 logger.error(f"解析RSS失败：{str(e2)} - {traceback.format_exc()}")
                 # RSS过期检查
@@ -403,8 +400,7 @@ class RssHelper:
                     del root
                 if ret_xml is not None:
                     del ret_xml
-                gc.collect()
-        
+
         return ret_array
 
     def get_rss_link(self, url: str, cookie: str, ua: str, proxy: bool = False) -> Tuple[str, str]:
@@ -446,7 +442,7 @@ class RssHelper:
                     return "", f"获取 {url} RSS链接失败，错误码：{res.status_code}，错误原因：{res.reason}"
                 else:
                     return "", f"获取RSS链接失败：无法连接 {url} "
-            
+
             # 解析HTML
             if html_text:
                 html = None
@@ -459,7 +455,7 @@ class RssHelper:
                 finally:
                     if html is not None:
                         del html
-                    
+
             return "", f"获取RSS链接失败：{url}"
         except Exception as e:
             return "", f"获取 {url} RSS链接失败：{str(e)}"

app/helper/system.py

@@ -1,9 +1,15 @@
+import os
+import signal
 from pathlib import Path
 from typing import Tuple
 
 import docker
 
 from app.core.config import settings
+from app.core.event import eventmanager, Event
+from app.log import logger
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import EventType
 from app.utils.system import SystemUtils
 
 
@@ -12,6 +18,22 @@ class SystemHelper:
     系统工具类，提供系统相关的操作和判断
     """
 
+    __system_flag_file = "/var/log/nginx/__moviepilot__"
+
+    @eventmanager.register(EventType.ConfigChanged)
+    def handle_config_changed(self, event: Event):
+        """
+        处理配置变更事件，更新日志设置
+        :param event: 事件对象
+        """
+        if not event:
+            return
+        event_data: ConfigChangeEventData = event.event_data
+        if event_data.key not in ['DEBUG', 'LOG_LEVEL', 'LOG_MAX_FILE_SIZE', 'LOG_BACKUP_COUNT',
+                                  'LOG_FILE_FORMAT', 'LOG_CONSOLE_FORMAT']:
+            return
+        logger.update_loggers()
+
     @staticmethod
     def can_restart() -> bool:
         """
@@ -23,17 +45,12 @@ class SystemHelper:
         )
 
     @staticmethod
-    def restart() -> Tuple[bool, str]:
+    def _get_container_id() -> str:
         """
-        执行Docker重启操作
+        获取当前容器ID
         """
-        if not SystemUtils.is_docker():
-            return False, "非Docker环境，无法重启！"
+        container_id = None
         try:
-            # 创建 Docker 客户端
-            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
-            # 获取当前容器的 ID
-            container_id = None
             with open("/proc/self/mountinfo", "r") as f:
                 data = f.read()
                 index_resolv_conf = data.find("resolv.conf")
@@ -49,11 +66,97 @@ class SystemHelper:
                                 data.rfind("/", 0, index_second_slash) + 1
                             )
                             container_id = data[index_first_slash:index_second_slash]
+        except Exception as e:
+            logger.debug(f"获取容器ID失败: {str(e)}")
+        return container_id.strip() if container_id else None
+
+    @staticmethod
+    def _check_restart_policy() -> bool:
+        """
+        检查当前容器是否配置了自动重启策略
+        """
+        try:
+            # 获取当前容器ID
+            container_id = SystemHelper._get_container_id()
+            if not container_id:
+                return False
+
+            # 创建 Docker 客户端
+            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
+            # 获取容器信息
+            container = client.containers.get(container_id)
+            restart_policy = container.attrs.get('HostConfig', {}).get('RestartPolicy', {})
+            policy_name = restart_policy.get('Name', 'no')
+            # 检查是否有有效的重启策略
+            auto_restart_policies = ['always', 'unless-stopped', 'on-failure']
+            has_restart_policy = policy_name in auto_restart_policies
+            
+            logger.info(f"容器重启策略: {policy_name}, 支持自动重启: {has_restart_policy}")
+            return has_restart_policy
+            
+        except Exception as e:
+            logger.warning(f"检查重启策略失败: {str(e)}")
+            return False
+
+    @staticmethod
+    def restart() -> Tuple[bool, str]:
+        """
+        执行Docker重启操作
+        """
+        if not SystemUtils.is_docker():
+            return False, "非Docker环境，无法重启！"
+        
+        try:
+            # 检查容器是否配置了自动重启策略
+            has_restart_policy = SystemHelper._check_restart_policy()
+            if has_restart_policy:
+                # 有重启策略，使用优雅退出方式
+                logger.info("检测到容器配置了自动重启策略，使用优雅重启方式...")
+                # 发送SIGTERM信号给当前进程，触发优雅停止
+                os.kill(os.getpid(), signal.SIGTERM)
+                return True, ""
+            else:
+                # 没有重启策略，使用Docker API强制重启
+                logger.info("容器未配置自动重启策略，使用Docker API重启...")
+                return SystemHelper._docker_api_restart()
+        except Exception as err:
+            logger.error(f"重启失败: {str(err)}")
+            # 降级为Docker API重启
+            logger.warning("降级为Docker API重启...")
+            return SystemHelper._docker_api_restart()
+
+    @staticmethod
+    def _docker_api_restart() -> Tuple[bool, str]:
+        """
+        使用Docker API重启容器，并尝试优雅停止
+        """
+        try:
+            # 创建 Docker 客户端
+            client = docker.DockerClient(base_url=settings.DOCKER_CLIENT_API)
+            container_id = SystemHelper._get_container_id()
             if not container_id:
                 return False, "获取容器ID失败！"
-            # 重启当前容器
-            client.containers.get(container_id.strip()).restart()
+            # 重启容器
+            client.containers.get(container_id).restart()
             return True, ""
-        except Exception as err:
-            print(str(err))
-            return False, f"重启时发生错误：{str(err)}"
+        except Exception as docker_err:
+            return False, f"重启时发生错误：{str(docker_err)}"
+
+    def set_system_modified(self):
+        """
+        设置系统已修改标志
+        """
+        try:
+            if SystemUtils.is_docker():
+                Path(self.__system_flag_file).touch(exist_ok=True)
+        except Exception as e:
+            print(f"设置系统修改标志失败: {str(e)}")
+
+    def is_system_reset(self) -> bool:
+        """
+        检查系统是否已被重置
+        :return: 如果系统已重置，返回 True；否则返回 False
+        """
+        if SystemUtils.is_docker():
+            return not Path(self.__system_flag_file).exists()
+        return False

app/helper/thread.py

@@ -2,14 +2,15 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import Optional
 
 from app.utils.singleton import Singleton
+from app.core.config import settings
 
 
 class ThreadHelper(metaclass=Singleton):
     """
     线程池管理
     """
-    def __init__(self, max_workers: Optional[int] = 50):
-        self.pool = ThreadPoolExecutor(max_workers=max_workers)
+    def __init__(self):
+        self.pool = ThreadPoolExecutor(max_workers=settings.CONF['threadpool'])
 
     def submit(self, func, *args, **kwargs):
         """

app/helper/wallpaper.py

@@ -47,7 +47,7 @@ class WallpaperHelper(metaclass=Singleton):
         """
         return TmdbChain().get_random_wallpager()
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_tmdb_wallpapers(self, num: int = 10) -> List[str]:
         """
         获取7天的TMDB每日壁纸
@@ -71,7 +71,7 @@ class WallpaperHelper(metaclass=Singleton):
                 print(str(err))
         return None
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_bing_wallpapers(self, num: int = 7) -> List[str]:
         """
         获取7天的Bing每日壁纸
@@ -94,7 +94,7 @@ class WallpaperHelper(metaclass=Singleton):
         """
         return MediaServerChain().get_latest_wallpaper()
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_mediaserver_wallpapers(self, num: int = 10) -> List[str]:
         """
         获取媒体服务器壁纸列表
@@ -111,7 +111,7 @@ class WallpaperHelper(metaclass=Singleton):
             return wallpaper_list[0]
         return None
 
-    @cached(maxsize=1, ttl=3600)
+    @cached(maxsize=1, ttl=3600, skip_empty=True)
     def get_customize_wallpapers(self) -> List[str]:
         """
         获取自定义壁纸api壁纸

app/log.py

@@ -99,6 +99,24 @@ class LoggerManager:
     # 线程锁
     _lock = threading.Lock()
 
+    def get_logger(self, name: str) -> logging.Logger:
+        """
+        获取一个指定名称的、独立的日志记录器。
+        创建一个独立的日志文件，例如 'diag_memory.log'。
+        :param name: 日志记录器的名称，也将用作文件名。
+        :return: 一个配置好的 logging.Logger 实例。
+        """
+        # 使用名称作为日志文件名
+        logfile = f"{name}.log"
+        with LoggerManager._lock:
+            # 检查是否已经创建过这个 logger
+            _logger = self._loggers.get(logfile)
+            if not _logger:
+                # 如果没有，就使用现有的 __setup_logger 来创建一个新的
+                _logger = self.__setup_logger(log_file=logfile)
+                self._loggers[logfile] = _logger
+        return _logger
+
     @staticmethod
     def __get_caller():
         """

app/main.py

@@ -1,5 +1,6 @@
 import multiprocessing
 import os
+import signal
 import sys
 import threading
 
@@ -21,7 +22,7 @@ from app.db.init import init_db, update_db
 # uvicorn服务
 Server = uvicorn.Server(Config(app, host=settings.HOST, port=settings.PORT,
                                reload=settings.DEV, workers=multiprocessing.cpu_count(),
-                               timeout_graceful_shutdown=5))
+                               timeout_graceful_shutdown=60))
 
 
 def start_tray():
@@ -70,7 +71,19 @@ def start_tray():
     threading.Thread(target=TrayIcon.run, daemon=True).start()
 
 
+def signal_handler(signum, frame):
+    """
+    信号处理函数，用于优雅停止服务
+    """
+    print(f"收到信号 {signum}，开始优雅停止服务...")
+    Server.should_exit = True
+
+
 if __name__ == '__main__':
+    # 注册信号处理器
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+    
     # 启动托盘
     start_tray()
     # 初始化数据库

app/modules/__init__.py

@@ -112,7 +112,7 @@ class ServiceBase(Generic[TService, TConf], metaclass=ABCMeta):
             # 通过服务类型或工厂函数来创建实例
             if isinstance(service_type, type):
                 # 如果传入的是类类型，调用构造函数实例化
-                self._instances[conf.name] = service_type(**conf.config)
+                self._instances[conf.name] = service_type(name=conf.name, **conf.config)
             else:
                 # 如果传入的是工厂函数，直接调用工厂函数
                 self._instances[conf.name] = service_type(conf)
@@ -191,8 +191,6 @@ class _MessageBase(ServiceBase[TService, NotificationConf]):
 
         :return: 返回消息通知的配置字典
         """
-        if self._configs is not None:
-            return self._configs
         configs = ServiceConfigHelper.get_notification_configs()
         if not self._service_name:
             return {}
@@ -212,8 +210,8 @@ class _MessageBase(ServiceBase[TService, NotificationConf]):
         # 检查消息来源
         if message.source and message.source != source:
             return False
-        # 检查消息类型开关
-        if message.mtype:
+        # 不是定向发送时，检查消息类型开关
+        if not message.userid and message.mtype:
             conf = self.get_config(source)
             if conf:
                 switchs = conf.switchs or []
@@ -260,8 +258,6 @@ class _DownloaderBase(ServiceBase[TService, DownloaderConf]):
 
         :return: 返回下载器配置字典
         """
-        if self._configs is not None:
-            return self._configs
         configs = ServiceConfigHelper.get_downloader_configs()
         if not self._service_name:
             return {}
@@ -279,8 +275,6 @@ class _MediaServerBase(ServiceBase[TService, MediaServerConf]):
 
         :return: 返回媒体服务器配置字典
         """
-        if self._configs is not None:
-            return self._configs
         configs = ServiceConfigHelper.get_mediaserver_configs()
         if not self._service_name:
             return {}

app/modules/bangumi/bangumi.py

@@ -30,7 +30,7 @@ class BangumiApi(object):
         self._session = requests.Session()
         self._req = RequestUtils(session=self._session)
 
-    @cached(maxsize=settings.CACHE_CONF["bangumi"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF["bangumi"], ttl=settings.CONF["meta"])
     def __invoke(self, url, key: Optional[str] = None, **kwargs):
         req_url = self._base_url + url
         params = {}

app/modules/douban/apiv2.py

@@ -171,14 +171,14 @@ class DoubanApi(metaclass=Singleton):
             ).digest()
         ).decode()
 
-    @cached(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF["douban"], ttl=settings.CONF["meta"])
     def __invoke_recommend(self, url: str, **kwargs) -> dict:
         """
         推荐/发现类API
         """
         return self.__invoke(url, **kwargs)
 
-    @cached(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF["douban"], ttl=settings.CONF["meta"])
     def __invoke_search(self, url: str, **kwargs) -> dict:
         """
         搜索类API
@@ -213,7 +213,7 @@ class DoubanApi(metaclass=Singleton):
             return resp.json()
         return resp.json() if resp else {}
 
-    @cached(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF["douban"], ttl=settings.CONF["meta"])
     def __post(self, url: str, **kwargs) -> dict:
         """
         POST请求

app/modules/douban/douban_cache.py

@@ -16,7 +16,7 @@ from app.schemas.types import MediaType
 lock = RLock()
 
 CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CACHE_CONF["meta"]
+EXPIRE_TIMESTAMP = settings.CONF["meta"]
 
 
 class DoubanCache(metaclass=Singleton):

app/modules/fanart/__init__.py

@@ -399,10 +399,28 @@ class FanartModule(_ModuleBase):
                         if not mediainfo.get_image(season_image):
                             mediainfo.set_image(season_image, image_obj.get('url'))
             else:
-                # 其他图片，按欢迎程度倒排
-                images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
-                # 取第一张图片
-                image_obj = images[0]
+                # 其他图片，优先环境变量指定语言，再like最多
+                def pick_best_image(images):
+                    lang_env = settings.FANART_LANG
+                    if lang_env:
+                        langs = [lang.strip() for lang in lang_env.split(",") if lang.strip()]
+                        for lang in langs:
+                            lang_images = [img for img in images if img.get('lang') == lang]
+                            if lang_images:
+                                lang_images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                                return lang_images[0]
+                    # 没设置或没找到，按原逻辑 zh、en、like最多
+                    zh_images = [img for img in images if img.get('lang') == 'zh']
+                    if zh_images:
+                        zh_images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                        return zh_images[0]
+                    en_images = [img for img in images if img.get('lang') == 'en']
+                    if en_images:
+                        en_images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                        return en_images[0]
+                    images.sort(key=lambda x: int(x.get('likes', 0)), reverse=True)
+                    return images[0]
+                image_obj = pick_best_image(images)
                 # 设置图片，没有图片才设置
                 if not mediainfo.get_image(image_name):
                     mediainfo.set_image(image_name, image_obj.get('url'))
@@ -420,7 +438,7 @@ class FanartModule(_ModuleBase):
         return result
 
     @classmethod
-    @cached(maxsize=settings.CACHE_CONF["fanart"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF["fanart"], ttl=settings.CONF["meta"])
     def __request_fanart(cls, media_type: MediaType, queryid: Union[str, int]) -> Optional[dict]:
         if media_type == MediaType.MOVIE:
             image_url = cls._movie_url % queryid

app/modules/filemanager/storages/alipan.py

@@ -5,7 +5,7 @@ import secrets
 import threading
 import time
 from pathlib import Path
-from typing import List, Dict, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import requests
 from tqdm import tqdm
@@ -52,9 +52,6 @@ class AliPan(StorageBase, metaclass=Singleton):
     # 基础url
     base_url = "https://openapi.alipan.com"
 
-    # CID和路径缓存
-    _id_cache: Dict[str, Tuple[str, str]] = {}
-
     def __init__(self):
         super().__init__()
         self.session = requests.Session()
@@ -279,61 +276,6 @@ class AliPan(StorageBase, metaclass=Singleton):
             return ret_data.get(result_key)
         return ret_data
 
-    def _path_to_id(self, drive_id: str, path: str) -> Tuple[str, str]:
-        """
-        路径转drive_id, file_id（带缓存机制）
-        """
-        # 根目录
-        if path == "/":
-            return drive_id, "root"
-        if len(path) > 1 and path.endswith("/"):
-            path = path[:-1]
-        # 检查缓存
-        if path in self._id_cache:
-            return self._id_cache[path]
-        # 逐级查找缓存
-        file_id = "root"
-        file_path = "/"
-        for p in Path(path).parents:
-            if str(p) in self._id_cache:
-                file_path = str(p)
-                file_id = self._id_cache[file_path]
-                break
-        # 计算相对路径
-        rel_path = Path(path).relative_to(file_path)
-        for part in Path(rel_path).parts:
-            find_part = False
-            next_marker = None
-            while True:
-                resp = self._request_api(
-                    "POST",
-                    "/adrive/v1.0/openFile/list",
-                    json={
-                        "drive_id": drive_id,
-                        "limit": 100,
-                        "marker": next_marker,
-                        "parent_file_id": file_id,
-                    }
-                )
-                if not resp:
-                    break
-                for item in resp.get("items", []):
-                    if item["name"] == part:
-                        file_id = item["file_id"]
-                        find_part = True
-                        break
-                if find_part:
-                    break
-                if len(resp.get("items")) < 100:
-                    break
-            if not find_part:
-                raise FileNotFoundError(f"【阿里云盘】{path} 不存在")
-        if file_id == "root":
-            raise FileNotFoundError(f"【阿里云盘】{path} 不存在")
-        # 缓存路径
-        self._id_cache[path] = (drive_id, file_id)
-        return drive_id, file_id
-
     def __get_fileitem(self, fileinfo: dict, parent: str = "/") -> schemas.FileItem:
         """
         获取文件信息
@@ -427,9 +369,6 @@ class AliPan(StorageBase, metaclass=Singleton):
                 break
             next_marker = resp.get("next_marker")
             for item in resp.get("items", []):
-                # 更新缓存
-                path = f"{fileitem.path}{item.get('name')}"
-                self._id_cache[path] = (drive_id, item.get("file_id"))
                 items.append(self.__get_fileitem(item, parent=fileitem.path))
             if len(resp.get("items")) < 100:
                 break
@@ -467,7 +406,6 @@ class AliPan(StorageBase, metaclass=Singleton):
             return None
         # 缓存新目录
         new_path = Path(parent_item.path) / name
-        self._id_cache[str(new_path)] = (resp.get("drive_id"), resp.get("file_id"))
         return self._delay_get_item(new_path)
 
     @staticmethod
@@ -837,15 +775,9 @@ class AliPan(StorageBase, metaclass=Singleton):
         if resp.get("code"):
             logger.warn(f"【阿里云盘】重命名失败: {resp.get('message')}")
             return False
-        if fileitem.path in self._id_cache:
-            del self._id_cache[fileitem.path]
-            for key in list(self._id_cache.keys()):
-                if key.startswith(fileitem.path):
-                    del self._id_cache[key]
-        self._id_cache[str(Path(fileitem.path).parent / name)] = (resp.get("drive_id"), resp.get("file_id"))
         return True
 
-    def get_item(self, path: Path) -> Optional[schemas.FileItem]:
+    def get_item(self, path: Path, drive_id: str = None) -> Optional[schemas.FileItem]:
         """
         获取指定路径的文件/目录项
         """
@@ -854,7 +786,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                 "POST",
                 "/adrive/v1.0/openFile/get_by_path",
                 json={
-                    "drive_id": self._default_drive_id,
+                    "drive_id": drive_id or self._default_drive_id,
                     "file_path": str(path)
                 }
             )
@@ -910,9 +842,15 @@ class AliPan(StorageBase, metaclass=Singleton):
 
     def copy(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
-        企业级复制实现（支持目录递归复制）
+        复制文件到指定路径
+        :param fileitem: 要复制的文件项
+        :param path: 目标目录路径
+        :param new_name: 新文件名
         """
-        dest_cid = self._path_to_id(fileitem.drive_id, str(path))
+        dest_fileitem = self.get_item(path, drive_id=fileitem.drive_id)
+        if not dest_fileitem or dest_fileitem.type != "dir":
+            logger.warn(f"【阿里云盘】目标路径 {path} 不存在或不是目录！")
+            return False
         resp = self._request_api(
             "POST",
             "/adrive/v1.0/openFile/copy",
@@ -920,7 +858,7 @@ class AliPan(StorageBase, metaclass=Singleton):
                 "drive_id": fileitem.drive_id,
                 "file_id": fileitem.fileid,
                 "to_drive_id": fileitem.drive_id,
-                "to_parent_file_id": dest_cid
+                "to_parent_file_id": dest_fileitem.fileid,
             }
         )
         if not resp:
@@ -932,18 +870,20 @@ class AliPan(StorageBase, metaclass=Singleton):
         new_path = Path(path) / fileitem.name
         new_file = self._delay_get_item(new_path)
         self.rename(new_file, new_name)
-        # 更新缓存
-        del self._id_cache[fileitem.path]
-        rename_new_path = Path(path) / new_name
-        self._id_cache[str(rename_new_path)] = (resp.get("drive_id"), resp.get("file_id"))
         return True
 
     def move(self, fileitem: schemas.FileItem, path: Path, new_name: str) -> bool:
         """
-        原子性移动操作实现
+        移动文件到指定路径
+        :param fileitem: 要移动的文件项
+        :param path: 目标目录路径
+        :param new_name: 新文件名
         """
         src_fid = fileitem.fileid
-        target_id = self._path_to_id(fileitem.drive_id, str(path))
+        target_fileitem = self.get_item(path, drive_id=fileitem.drive_id)
+        if not target_fileitem or target_fileitem.type != "dir":
+            logger.warn(f"【阿里云盘】目标路径 {path} 不存在或不是目录！")
+            return False
 
         resp = self._request_api(
             "POST",
@@ -951,7 +891,7 @@ class AliPan(StorageBase, metaclass=Singleton):
             json={
                 "drive_id": fileitem.drive_id,
                 "file_id": src_fid,
-                "to_parent_file_id": target_id,
+                "to_parent_file_id": target_fileitem.fileid,
                 "new_name": new_name
             }
         )
@@ -960,10 +900,6 @@ class AliPan(StorageBase, metaclass=Singleton):
         if resp.get("code"):
             logger.warn(f"【阿里云盘】移动文件失败: {resp.get('message')}")
             return False
-        # 更新缓存
-        del self._id_cache[fileitem.path]
-        rename_new_path = Path(path) / new_name
-        self._id_cache[str(rename_new_path)] = (resp.get("drive_id"), resp.get("file_id"))
         return True
 
     def link(self, fileitem: schemas.FileItem, target_file: Path) -> bool:

app/modules/filemanager/storages/u115.py

@@ -5,7 +5,7 @@ import secrets
 import threading
 import time
 from pathlib import Path
-from typing import List, Dict, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union
 
 import oss2
 import requests
@@ -51,9 +51,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
     # 基础url
     base_url = "https://proapi.115.com"
 
-    # CID和路径缓存
-    _id_cache: Dict[str, str] = {}
-
     def __init__(self):
         super().__init__()
         self.session = requests.Session()
@@ -238,58 +235,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             return ret_data.get(result_key)
         return ret_data
 
-    def _path_to_id(self, path: str) -> str:
-        """
-        路径转FID（带缓存机制）
-        """
-        # 根目录
-        if path == "/":
-            return '0'
-        if len(path) > 1 and path.endswith("/"):
-            path = path[:-1]
-        # 检查缓存
-        if path in self._id_cache:
-            return self._id_cache[path]
-        # 逐级查找缓存
-        current_id = 0
-        parent_path = "/"
-        for p in Path(path).parents:
-            if str(p) in self._id_cache:
-                parent_path = str(p)
-                current_id = self._id_cache[parent_path]
-                break
-        # 计算相对路径
-        rel_path = Path(path).relative_to(parent_path)
-        for part in Path(rel_path).parts:
-            offset = 0
-            find_part = False
-            while True:
-                resp = self._request_api(
-                    "GET",
-                    "/open/ufile/files",
-                    "data",
-                    params={"cid": current_id, "limit": 1000, "offset": offset, "cur": True, "show_dir": 1}
-                )
-                if not resp:
-                    break
-                for item in resp:
-                    if item["fn"] == part:
-                        current_id = item["fid"]
-                        find_part = True
-                        break
-                if find_part:
-                    break
-                if len(resp) < 1000:
-                    break
-                offset += len(resp)
-            if not find_part:
-                raise FileNotFoundError(f"【115】{path} 不存在")
-        if not current_id:
-            raise FileNotFoundError(f"【115】{path} 不存在")
-        # 缓存路径
-        self._id_cache[path] = str(current_id)
-        return str(current_id)
-
     @staticmethod
     def _calc_sha1(filepath: Path, size: Optional[int] = None) -> str:
         """
@@ -335,7 +280,11 @@ class U115Pan(StorageBase, metaclass=Singleton):
         else:
             cid = fileitem.fileid
             if not cid:
-                cid = self._path_to_id(fileitem.path)
+                _fileitem = self.get_item(Path(fileitem.path))
+                if not _fileitem:
+                    logger.warn(f"【115】获取目录 {fileitem.path} 失败！")
+                    return []
+                cid = _fileitem.fileid
 
         items = []
         offset = 0
@@ -354,8 +303,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             for item in resp:
                 # 更新缓存
                 path = f"{fileitem.path}{item['fn']}"
-                self._id_cache[path] = str(item["fid"])
-
                 file_path = path + ("/" if item["fc"] == "0" else "")
                 items.append(schemas.FileItem(
                     storage=self.schema.value,
@@ -398,8 +345,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
                 return self.get_item(new_path)
             logger.warn(f"【115】创建目录失败: {resp.get('error')}")
             return None
-        # 缓存新目录
-        self._id_cache[str(new_path)] = str(resp["data"]["file_id"])
         return schemas.FileItem(
             storage=self.schema.value,
             fileid=str(resp["data"]["file_id"]),
@@ -716,13 +661,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
         if not resp:
             return False
         if resp["state"]:
-            if fileitem.path in self._id_cache:
-                del self._id_cache[fileitem.path]
-                for key in list(self._id_cache.keys()):
-                    if key.startswith(fileitem.path):
-                        del self._id_cache[key]
-            new_path = Path(fileitem.path).parent / name
-            self._id_cache[str(new_path)] = fileitem.fileid
             return True
         return False
 
@@ -731,15 +669,12 @@ class U115Pan(StorageBase, metaclass=Singleton):
         获取指定路径的文件/目录项
         """
         try:
-            file_id = self._path_to_id(str(path))
-            if not file_id:
-                return None
             resp = self._request_api(
-                "GET",
+                "POST",
                 "/open/folder/get_info",
                 "data",
-                params={
-                    "file_id": int(file_id)
+                data={
+                    "path": str(path)
                 }
             )
             if not resp:
@@ -753,7 +688,7 @@ class U115Pan(StorageBase, metaclass=Singleton):
                 basename=Path(resp["file_name"]).stem,
                 extension=Path(resp["file_name"]).suffix[1:] if resp["file_category"] == "1" else None,
                 pickcode=resp["pick_code"],
-                size=StringUtils.num_filesize(resp['size']) if resp["file_category"] == "1" else None,
+                size=resp['size_byte'] if resp["file_category"] == "1" else None,
                 modify_time=resp["utime"]
             )
         except Exception as e:
@@ -805,14 +740,17 @@ class U115Pan(StorageBase, metaclass=Singleton):
         企业级复制实现（支持目录递归复制）
         """
         src_fid = fileitem.fileid
-        dest_cid = self._path_to_id(str(path))
+        dest_fileitem = self.get_item(path)
+        if not dest_fileitem or dest_fileitem.type != "dir":
+            logger.warn(f"【115】目标路径 {path} 不是一个有效的目录！")
+            return False
 
         resp = self._request_api(
             "POST",
             "/open/ufile/copy",
             data={
                 "file_id": int(src_fid),
-                "pid": int(dest_cid)
+                "pid": int(dest_fileitem.fileid),
             }
         )
         if not resp:
@@ -821,10 +759,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             new_path = Path(path) / fileitem.name
             new_item = self._delay_get_item(new_path)
             self.rename(new_item, new_name)
-            # 更新缓存
-            del self._id_cache[fileitem.path]
-            rename_new_path = Path(path) / new_name
-            self._id_cache[str(rename_new_path)] = new_item.fileid
             return True
         return False
 
@@ -833,14 +767,16 @@ class U115Pan(StorageBase, metaclass=Singleton):
         原子性移动操作实现
         """
         src_fid = fileitem.fileid
-        dest_cid = self._path_to_id(str(path))
-
+        dest_fileitem = self.get_item(path)
+        if not dest_fileitem or dest_fileitem.type != "dir":
+            logger.warn(f"【115】目标路径 {path} 不是一个有效的目录！")
+            return False
         resp = self._request_api(
             "POST",
             "/open/ufile/move",
             data={
                 "file_ids": int(src_fid),
-                "to_cid": int(dest_cid)
+                "to_cid": int(dest_fileitem.fileid),
             }
         )
         if not resp:
@@ -849,10 +785,6 @@ class U115Pan(StorageBase, metaclass=Singleton):
             new_path = Path(path) / fileitem.name
             new_file = self._delay_get_item(new_path)
             self.rename(new_file, new_name)
-            # 更新缓存
-            del self._id_cache[fileitem.path]
-            rename_new_path = Path(path) / new_name
-            self._id_cache[str(rename_new_path)] = src_fid
             return True
         return False
 

app/modules/qbittorrent/__init__.py

@@ -306,7 +306,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
                     ))
         else:
             return None
-        return ret_torrents
+        return ret_torrents # noqa
 
     def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """
@@ -318,6 +318,7 @@ class QbittorrentModule(_ModuleBase, _DownloaderBase[Qbittorrent]):
         if not server:
             return None
         server.set_torrents_tag(ids=hashs, tags=['已整理'])
+        return None
 
     def remove_torrents(self, hashs: Union[str, list], delete_file: Optional[bool] = True,
                         downloader: Optional[str] = None) -> Optional[bool]:

app/modules/slack/__init__.py

@@ -81,8 +81,7 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
     def init_setting(self) -> Tuple[str, Union[str, bool]]:
         pass
 
-    def message_parser(self, source: str, body: Any, form: Any,
-                       args: Any) -> Optional[CommingMessage]:
+    def message_parser(self, source: str, body: Any, form: Any, args: Any) -> Optional[CommingMessage]:
         """
         解析消息内容，返回字典，注意以下约定值：
         userid: 用户ID
@@ -219,8 +218,32 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
                 username = msg_json.get("user")
             elif msg_json.get("type") == "block_actions":
                 userid = msg_json.get("user", {}).get("id")
-                text = msg_json.get("actions")[0].get("value")
+                callback_data = msg_json.get("actions")[0].get("value")
+                # 使用CALLBACK前缀标识按钮回调
+                text = f"CALLBACK:{callback_data}"
                 username = msg_json.get("user", {}).get("name")
+                
+                # 获取原消息信息用于编辑
+                message_info = msg_json.get("message", {})
+                # Slack消息的时间戳作为消息ID
+                message_ts = message_info.get("ts")
+                channel_id = msg_json.get("channel", {}).get("id") or msg_json.get("container", {}).get("channel_id")
+                
+                logger.info(f"收到来自 {client_config.name} 的Slack按钮回调："
+                            f"userid={userid}, username={username}, callback_data={callback_data}")
+
+                # 创建包含回调信息的CommingMessage
+                return CommingMessage(
+                    channel=MessageChannel.Slack,
+                    source=client_config.name,
+                    userid=userid,
+                    username=username,
+                    text=text,
+                    is_callback=True,
+                    callback_data=callback_data,
+                    message_id=message_ts,
+                    chat_id=channel_id
+                )
             elif msg_json.get("type") == "event_callback":
                 userid = msg_json.get('event', {}).get('user')
                 text = re.sub(r"<@[0-9A-Z]+>", "", msg_json.get("event", {}).get("text"), flags=re.IGNORECASE).strip()
@@ -259,7 +282,10 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
             client: Slack = self.get_instance(conf.name)
             if client:
                 client.send_msg(title=message.title, text=message.text,
-                                image=message.image, userid=userid, link=message.link)
+                                image=message.image, userid=userid, link=message.link,
+                                buttons=message.buttons,
+                                original_message_id=message.original_message_id,
+                                original_chat_id=message.original_chat_id)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
@@ -273,7 +299,10 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
                 continue
             client: Slack = self.get_instance(conf.name)
             if client:
-                client.send_medias_msg(title=message.title, medias=medias, userid=message.userid)
+                client.send_medias_msg(title=message.title, medias=medias, userid=message.userid,
+                                       buttons=message.buttons,
+                                       original_message_id=message.original_message_id,
+                                       original_chat_id=message.original_chat_id)
 
     def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
@@ -288,4 +317,6 @@ class SlackModule(_ModuleBase, _MessageBase[Slack]):
             client: Slack = self.get_instance(conf.name)
             if client:
                 client.send_torrents_msg(title=message.title, torrents=torrents,
-                                         userid=message.userid)
+                                         userid=message.userid, buttons=message.buttons,
+                                         original_message_id=message.original_message_id,
+                                         original_chat_id=message.original_chat_id)

app/modules/slack/slack.py

@@ -52,7 +52,7 @@ class Slack:
             with requests.post(self._ds_url, json=message, timeout=10) as local_res:
                 logger.debug("message: %s processed, response is: %s" % (message, local_res.text))
 
-        @slack_app.action(re.compile(r"actionId-\d+"))
+        @slack_app.action(re.compile(r"actionId-.*"))
         def slack_action(ack, body):
             ack()
             with requests.post(self._ds_url, json=body, timeout=60) as local_res:
@@ -101,15 +101,21 @@ class Slack:
         """
         return True if self._client else False
 
-    def send_msg(self, title: str, text: Optional[str] = None, image: Optional[str] = None, link: Optional[str] = None, userid: Optional[str] = None):
+    def send_msg(self, title: str, text: Optional[str] = None,
+                 image: Optional[str] = None, link: Optional[str] = None,
+                 userid: Optional[str] = None, buttons: Optional[List[List[dict]]] = None,
+                 original_message_id: Optional[str] = None,
+                 original_chat_id: Optional[str] = None):
         """
-        发送Telegram消息
+        发送Slack消息
         :param title: 消息标题
         :param text: 消息内容
         :param image: 消息图片地址
         :param link: 点击消息转转的URL
         :param userid: 用户ID，如有则只发消息给该用户
-        :user_id: 发送消息的目标用户ID，为空则发给管理员
+        :param buttons: 消息按钮列表，格式为 [[{"text": "按钮文本", "callback_data": "回调数据", "url": "链接"}]]
+        :param original_message_id: 原消息的时间戳，如果提供则编辑原消息
+        :param original_chat_id: 原消息的频道ID，编辑消息时需要
         """
         if not self._client:
             return False, "消息客户端未就绪"
@@ -139,8 +145,42 @@ class Slack:
                         "image_url": f"{image}",
                         "alt_text": f"{title}"
                     }})
-                # 链接
-                if link:
+                # 自定义按钮
+                if buttons:
+                    for button_row in buttons:
+                        elements = []
+                        for button in button_row:
+                            if "url" in button:
+                                # URL按钮
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "url": button["url"],
+                                    "action_id": f"actionId-url-{len(elements)}"
+                                })
+                            else:
+                                # 回调按钮
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "value": button["callback_data"],
+                                    "action_id": f"actionId-{button['callback_data']}"
+                                })
+                        if elements:
+                            blocks.append({
+                                "type": "actions",
+                                "elements": elements
+                            })
+                elif link:
+                    # 默认链接按钮
                     blocks.append({
                         "type": "actions",
                         "elements": [
@@ -157,21 +197,41 @@ class Slack:
                             }
                         ]
                     })
-            # 发送
-            result = self._client.chat_postMessage(
-                channel=channel,
-                text=message_text[:1000],
-                blocks=blocks,
-                mrkdwn=True
-            )
+            
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                result = self._client.chat_update(
+                    channel=original_chat_id,
+                    ts=original_message_id,
+                    text=message_text[:1000],
+                    blocks=blocks or []
+                )
+            else:
+                # 发送新消息
+                result = self._client.chat_postMessage(
+                    channel=channel,
+                    text=message_text[:1000],
+                    blocks=blocks,
+                    mrkdwn=True
+                )
             return True, result
         except Exception as msg_e:
             logger.error(f"Slack消息发送失败: {msg_e}")
             return False, str(msg_e)
 
-    def send_medias_msg(self, medias: List[MediaInfo], userid: Optional[str] = None, title: Optional[str] = None) -> Optional[bool]:
+    def send_medias_msg(self, medias: List[MediaInfo], userid: Optional[str] = None, title: Optional[str] = None,
+                        buttons: Optional[List[List[dict]]] = None,
+                        original_message_id: Optional[str] = None,
+                        original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
-        发送列表类消息
+        发送媒体列表消息
+        :param medias: 媒体信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息的时间戳，如果提供则编辑原消息
+        :param original_chat_id: 原消息的频道ID，编辑消息时需要
         """
         if not self._client:
             return False
@@ -198,64 +258,148 @@ class Slack:
                     "type": "divider"
                 })
                 index = 1
-                for media in medias:
-                    if media.get_poster_image():
-                        if media.vote_star:
-                            text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
-                                   f"\n类型：{media.type.value}" \
-                                   f"\n{media.vote_star}" \
-                                   f"\n{media.get_overview_string(50)}"
-                        else:
-                            text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
-                                   f"\n类型：{media.type.value}" \
-                                   f"\n{media.get_overview_string(50)}"
-                        blocks.append(
-                            {
-                                "type": "section",
-                                "text": {
-                                    "type": "mrkdwn",
-                                    "text": text
-                                },
-                                "accessory": {
-                                    "type": "image",
-                                    "image_url": f"{media.get_poster_image()}",
-                                    "alt_text": f"{media.title_year}"
-                                }
-                            }
-                        )
-                        blocks.append(
-                            {
-                                "type": "actions",
-                                "elements": [
-                                    {
-                                        "type": "button",
-                                        "text": {
-                                            "type": "plain_text",
-                                            "text": "选择",
-                                            "emoji": True
-                                        },
-                                        "value": f"{index}",
-                                        "action_id": f"actionId-{index}"
+                
+                # 如果有自定义按钮，先添加所有媒体项，然后添加统一的按钮
+                if buttons:
+                    # 添加媒体列表（不带单独的选择按钮）
+                    for media in medias:
+                        if media.get_poster_image():
+                            if media.vote_star:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.vote_star}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            else:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            blocks.append(
+                                {
+                                    "type": "section",
+                                    "text": {
+                                        "type": "mrkdwn",
+                                        "text": text
+                                    },
+                                    "accessory": {
+                                        "type": "image",
+                                        "image_url": f"{media.get_poster_image()}",
+                                        "alt_text": f"{media.title_year}"
                                     }
-                                ]
-                            }
-                        )
-                        index += 1
-            # 发送
-            result = self._client.chat_postMessage(
-                channel=channel,
-                text=title,
-                blocks=blocks
-            )
+                                }
+                            )
+                            index += 1
+                    
+                    # 添加统一的自定义按钮（在所有媒体项之后）
+                    for button_row in buttons:
+                        elements = []
+                        for button in button_row:
+                            if "url" in button:
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "url": button["url"],
+                                    "action_id": f"actionId-url-{len(elements)}"
+                                })
+                            else:
+                                elements.append({
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": button["text"],
+                                        "emoji": True
+                                    },
+                                    "value": button["callback_data"],
+                                    "action_id": f"actionId-{button['callback_data']}"
+                                })
+                        if elements:
+                            blocks.append({
+                                "type": "actions",
+                                "elements": elements
+                            })
+                else:
+                    # 使用默认的每个媒体项单独按钮
+                    for media in medias:
+                        if media.get_poster_image():
+                            if media.vote_star:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.vote_star}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            else:
+                                text = f"{index}. *<{media.detail_link}|{media.title_year}>*" \
+                                       f"\n类型：{media.type.value}" \
+                                       f"\n{media.get_overview_string(50)}"
+                            blocks.append(
+                                {
+                                    "type": "section",
+                                    "text": {
+                                        "type": "mrkdwn",
+                                        "text": text
+                                    },
+                                    "accessory": {
+                                        "type": "image",
+                                        "image_url": f"{media.get_poster_image()}",
+                                        "alt_text": f"{media.title_year}"
+                                    }
+                                }
+                            )
+                            # 使用默认选择按钮
+                            blocks.append(
+                                {
+                                    "type": "actions",
+                                    "elements": [
+                                        {
+                                            "type": "button",
+                                            "text": {
+                                                "type": "plain_text",
+                                                "text": "选择",
+                                                "emoji": True
+                                            },
+                                            "value": f"{index}",
+                                            "action_id": f"actionId-{index}"
+                                        }
+                                    ]
+                                }
+                            )
+                            index += 1
+            
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                result = self._client.chat_update(
+                    channel=original_chat_id,
+                    ts=original_message_id,
+                    text=title,
+                    blocks=blocks or []
+                )
+            else:
+                # 发送新消息
+                result = self._client.chat_postMessage(
+                    channel=channel,
+                    text=title,
+                    blocks=blocks
+                )
             return True if result else False
         except Exception as msg_e:
             logger.error(f"Slack消息发送失败: {msg_e}")
             return False
 
-    def send_torrents_msg(self, torrents: List[Context],
-                          userid: Optional[str] = None, title: Optional[str] = None) -> Optional[bool]:
+    def send_torrents_msg(self, torrents: List[Context], userid: Optional[str] = None, title: Optional[str] = None,
+                          buttons: Optional[List[List[dict]]] = None,
+                          original_message_id: Optional[str] = None,
+                          original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
-        发送列表消息
+        发送种子列表消息
+        :param torrents: 种子信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息的时间戳，如果提供则编辑原消息
+        :param original_chat_id: 原消息的频道ID，编辑消息时需要
         """
         if not self._client:
             return None
@@ -279,55 +423,130 @@ class Slack:
             }]
             # 列表
             index = 1
-            for context in torrents:
-                torrent = context.torrent_info
-                site_name = torrent.site_name
-                meta = MetaInfo(torrent.title, torrent.description)
-                link = torrent.page_url
-                title = f"{meta.season_episode} " \
-                        f"{meta.resource_term} " \
-                        f"{meta.video_term} " \
-                        f"{meta.release_group}"
-                title = re.sub(r"\s+", " ", title).strip()
-                free = torrent.volume_factor
-                seeder = f"{torrent.seeders}↑"
-                description = torrent.description
-                text = f"{index}. 【{site_name}】<{link}|{title}> " \
-                       f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
-                       f"{description}"
-                blocks.append(
-                    {
-                        "type": "section",
-                        "text": {
-                            "type": "mrkdwn",
-                            "text": text
+            
+            # 如果有自定义按钮，先添加种子列表，然后添加统一的按钮
+            if buttons:
+                # 添加种子列表（不带单独的选择按钮）
+                for context in torrents:
+                    torrent = context.torrent_info
+                    site_name = torrent.site_name
+                    meta = MetaInfo(torrent.title, torrent.description)
+                    link = torrent.page_url
+                    title_text = f"{meta.season_episode} " \
+                            f"{meta.resource_term} " \
+                            f"{meta.video_term} " \
+                            f"{meta.release_group}"
+                    title_text = re.sub(r"\s+", " ", title_text).strip()
+                    free = torrent.volume_factor
+                    seeder = f"{torrent.seeders}↑"
+                    description = torrent.description
+                    text = f"{index}. 【{site_name}】<{link}|{title_text}> " \
+                           f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
+                           f"{description}"
+                    blocks.append(
+                        {
+                            "type": "section",
+                            "text": {
+                                "type": "mrkdwn",
+                                "text": text
+                            }
                         }
-                    }
-                )
-                blocks.append(
-                    {
-                        "type": "actions",
-                        "elements": [
-                            {
+                    )
+                    index += 1
+                
+                # 添加统一的自定义按钮
+                for button_row in buttons:
+                    elements = []
+                    for button in button_row:
+                        if "url" in button:
+                            elements.append({
                                 "type": "button",
                                 "text": {
                                     "type": "plain_text",
-                                    "text": "选择",
+                                    "text": button["text"],
                                     "emoji": True
                                 },
-                                "value": f"{index}",
-                                "action_id": f"actionId-{index}"
+                                "url": button["url"],
+                                "action_id": f"actionId-url-{len(elements)}"
+                            })
+                        else:
+                            elements.append({
+                                "type": "button",
+                                "text": {
+                                    "type": "plain_text",
+                                    "text": button["text"],
+                                    "emoji": True
+                                },
+                                "value": button["callback_data"],
+                                "action_id": f"actionId-{button['callback_data']}"
+                            })
+                    if elements:
+                        blocks.append({
+                            "type": "actions",
+                            "elements": elements
+                        })
+            else:
+                # 使用默认的每个种子单独按钮
+                for context in torrents:
+                    torrent = context.torrent_info
+                    site_name = torrent.site_name
+                    meta = MetaInfo(torrent.title, torrent.description)
+                    link = torrent.page_url
+                    title_text = f"{meta.season_episode} " \
+                            f"{meta.resource_term} " \
+                            f"{meta.video_term} " \
+                            f"{meta.release_group}"
+                    title_text = re.sub(r"\s+", " ", title_text).strip()
+                    free = torrent.volume_factor
+                    seeder = f"{torrent.seeders}↑"
+                    description = torrent.description
+                    text = f"{index}. 【{site_name}】<{link}|{title_text}> " \
+                           f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
+                           f"{description}"
+                    blocks.append(
+                        {
+                            "type": "section",
+                            "text": {
+                                "type": "mrkdwn",
+                                "text": text
                             }
-                        ]
-                    }
+                        }
+                    )
+                    blocks.append(
+                        {
+                            "type": "actions",
+                            "elements": [
+                                {
+                                    "type": "button",
+                                    "text": {
+                                        "type": "plain_text",
+                                        "text": "选择",
+                                        "emoji": True
+                                    },
+                                    "value": f"{index}",
+                                    "action_id": f"actionId-{index}"
+                                }
+                            ]
+                        }
+                    )
+                    index += 1
+            
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                result = self._client.chat_update(
+                    channel=original_chat_id,
+                    ts=original_message_id,
+                    text=title,
+                    blocks=blocks or []
+                )
+            else:
+                # 发送新消息
+                result = self._client.chat_postMessage(
+                    channel=channel,
+                    text=title,
+                    blocks=blocks
                 )
-                index += 1
-            # 发送
-            result = self._client.chat_postMessage(
-                channel=channel,
-                text=title,
-                blocks=blocks
-            )
             return True if result else False
         except Exception as msg_e:
             logger.error(f"Slack消息发送失败: {msg_e}")

app/modules/telegram/__init__.py

@@ -9,7 +9,8 @@ from app.core.event import eventmanager
 from app.log import logger
 from app.modules import _ModuleBase, _MessageBase
 from app.modules.telegram.telegram import Telegram
-from app.schemas import MessageChannel, CommingMessage, Notification, CommandRegisterEventData, ConfigChangeEventData
+from app.schemas import MessageChannel, CommingMessage, Notification, CommandRegisterEventData, ConfigChangeEventData, \
+    NotificationConf
 from app.schemas.types import ModuleType, ChainEventType, SystemConfigKey, EventType
 from app.utils.structures import DictUtils
 
@@ -98,6 +99,7 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
         :return: 渠道、消息体
         """
         """
+            普通消息格式：
             {
                 'update_id': ,
                 'message': {
@@ -119,6 +121,16 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
                     'text': ''
                 }
             }
+            
+            按钮回调格式：
+            {
+                'callback_query': {
+                    'id': '',
+                    'from': {...},
+                    'message': {...},
+                    'data': 'callback_data'
+                }
+            }
         """
         # 获取服务配置
         client_config = self.get_config(source)
@@ -130,32 +142,88 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
         except Exception as err:
             logger.debug(f"解析Telegram消息失败：{str(err)}")
             return None
+
         if message:
-            text = message.get("text")
-            user_id = message.get("from", {}).get("id")
-            # 获取用户名
-            user_name = message.get("from", {}).get("username")
-            if text:
-                logger.info(f"收到来自 {client_config.name} 的Telegram消息："
-                            f"userid={user_id}, username={user_name}, text={text}")
-                # 检查权限
-                admin_users = client_config.config.get("TELEGRAM_ADMINS")
-                user_list = client_config.config.get("TELEGRAM_USERS")
-                chat_id = client_config.config.get("TELEGRAM_CHAT_ID")
-                if text.startswith("/"):
-                    if admin_users \
-                            and str(user_id) not in admin_users.split(',') \
-                            and str(user_id) != chat_id:
-                        client.send_msg(title="只有管理员才有权限执行此命令", userid=user_id)
-                        return None
-                else:
-                    if user_list \
-                            and not str(user_id) in user_list.split(','):
-                        logger.info(f"用户{user_id}不在用户白名单中，无法使用此机器人")
-                        client.send_msg(title="你不在用户白名单中，无法使用此机器人", userid=user_id)
-                        return None
-                return CommingMessage(channel=MessageChannel.Telegram, source=client_config.name,
-                                      userid=user_id, username=user_name, text=text)
+            # 处理按钮回调
+            if "callback_query" in message:
+                return self._handle_callback_query(message, client_config)
+
+            # 处理普通消息
+            return self._handle_text_message(message, client_config, client)
+
+        return None
+
+    @staticmethod
+    def _handle_callback_query(message: dict, client_config: NotificationConf) -> Optional[CommingMessage]:
+        """
+        处理按钮回调查询
+        """
+        callback_query = message.get("callback_query", {})
+        user_info = callback_query.get("from", {})
+        callback_data = callback_query.get("data", "")
+        user_id = user_info.get("id")
+        user_name = user_info.get("username")
+
+        if callback_data and user_id:
+            logger.info(f"收到来自 {client_config.name} 的Telegram按钮回调："
+                        f"userid={user_id}, username={user_name}, callback_data={callback_data}")
+
+            # 将callback_data作为特殊格式的text返回，以便主程序识别这是按钮回调
+            callback_text = f"CALLBACK:{callback_data}"
+
+            # 创建包含完整回调信息的CommingMessage
+            return CommingMessage(
+                channel=MessageChannel.Telegram,
+                source=client_config.name,
+                userid=user_id,
+                username=user_name,
+                text=callback_text,
+                is_callback=True,
+                callback_data=callback_data,
+                message_id=callback_query.get("message", {}).get("message_id"),
+                chat_id=str(callback_query.get("message", {}).get("chat", {}).get("id", "")),
+                callback_query=callback_query
+            )
+        return None
+
+    @staticmethod
+    def _handle_text_message(msg: dict, client_config: NotificationConf, client: Telegram) -> Optional[CommingMessage]:
+        """
+        处理普通文本消息
+        """
+        text = msg.get("text")
+        user_id = msg.get("from", {}).get("id")
+        user_name = msg.get("from", {}).get("username")
+
+        if text and user_id:
+            logger.info(f"收到来自 {client_config.name} 的Telegram消息："
+                        f"userid={user_id}, username={user_name}, text={text}")
+
+            # 检查权限
+            admin_users = client_config.config.get("TELEGRAM_ADMINS")
+            user_list = client_config.config.get("TELEGRAM_USERS")
+            chat_id = client_config.config.get("TELEGRAM_CHAT_ID")
+
+            if text.startswith("/"):
+                if admin_users \
+                        and str(user_id) not in admin_users.split(',') \
+                        and str(user_id) != chat_id:
+                    client.send_msg(title="只有管理员才有权限执行此命令", userid=user_id)
+                    return None
+            else:
+                if user_list \
+                        and str(user_id) not in user_list.split(','):
+                    logger.info(f"用户{user_id}不在用户白名单中，无法使用此机器人")
+                    client.send_msg(title="你不在用户白名单中，无法使用此机器人", userid=user_id)
+                    return None
+
+            return CommingMessage(
+                channel=MessageChannel.Telegram,
+                source=client_config.name,
+                userid=user_id,
+                username=user_name,
+                text=text
+            )
         return None
 
     def post_message(self, message: Notification) -> None:
@@ -177,7 +245,10 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
             client: Telegram = self.get_instance(conf.name)
             if client:
                 client.send_msg(title=message.title, text=message.text,
-                                image=message.image, userid=userid, link=message.link)
+                                image=message.image, userid=userid, link=message.link,
+                                buttons=message.buttons,
+                                original_message_id=message.original_message_id,
+                                original_chat_id=message.original_chat_id)
 
     def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
@@ -192,7 +263,10 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
             client: Telegram = self.get_instance(conf.name)
             if client:
                 client.send_medias_msg(title=message.title, medias=medias,
-                                       userid=message.userid, link=message.link)
+                                       userid=message.userid, link=message.link,
+                                       buttons=message.buttons,
+                                       original_message_id=message.original_message_id,
+                                       original_chat_id=message.original_chat_id)
 
     def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
@@ -207,7 +281,10 @@ class TelegramModule(_ModuleBase, _MessageBase[Telegram]):
             client: Telegram = self.get_instance(conf.name)
             if client:
                 client.send_torrents_msg(title=message.title, torrents=torrents,
-                                         userid=message.userid, link=message.link)
+                                         userid=message.userid, link=message.link,
+                                         buttons=message.buttons,
+                                         original_message_id=message.original_message_id,
+                                         original_chat_id=message.original_chat_id)
 
     def register_commands(self, commands: Dict[str, dict]):
         """

app/modules/telegram/telegram.py

@@ -3,11 +3,13 @@ import threading
 import uuid
 from pathlib import Path
 from threading import Event
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Callable
+from urllib.parse import urljoin
 
 import telebot
 from telebot import apihelper
-from telebot.types import InputFile
+from telebot.types import InputFile, InlineKeyboardMarkup, InlineKeyboardButton
+from telebot.types import InputMediaPhoto
 
 from app.core.config import settings
 from app.core.context import MediaInfo, Context
@@ -17,13 +19,12 @@ from app.utils.common import retry
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
-apihelper.proxy = settings.PROXY
-
 
 class Telegram:
     _ds_url = f"http://127.0.0.1:{settings.PORT}/api/v1/message?token={settings.API_TOKEN}"
     _event = Event()
     _bot: telebot.TeleBot = None
+    _callback_handlers: Dict[str, Callable] = {}  # 存储回调处理器
 
     def __init__(self, TELEGRAM_TOKEN: Optional[str] = None, TELEGRAM_CHAT_ID: Optional[str] = None, **kwargs):
         """
@@ -38,6 +39,12 @@ class Telegram:
         self._telegram_chat_id = TELEGRAM_CHAT_ID
         # 初始化机器人
         if self._telegram_token and self._telegram_chat_id:
+            # telegram bot api 地址，格式：https://api.telegram.org
+            if kwargs.get("API_URL"):
+                apihelper.API_URL = urljoin(kwargs["API_URL"], '/bot{0}/{1}')
+                apihelper.FILE_URL = urljoin(kwargs["API_URL"], '/file/bot{0}/{1}')
+            else:
+                apihelper.proxy = settings.PROXY
             # bot
             _bot = telebot.TeleBot(self._telegram_token, parse_mode="Markdown")
             # 记录句柄
@@ -52,7 +59,44 @@ class Telegram:
 
             @_bot.message_handler(func=lambda message: True)
             def echo_all(message):
-                RequestUtils(timeout=5).post_res(self._ds_url, json=message.json)
+                RequestUtils(timeout=15).post_res(self._ds_url, json=message.json)
+
+            @_bot.callback_query_handler(func=lambda call: True)
+            def callback_query(call):
+                """
+                处理按钮点击回调
+                """
+                try:
+                    # 解析回调数据
+                    callback_data = call.data
+                    user_id = str(call.from_user.id)
+
+                    logger.info(f"收到按钮回调：{callback_data}，用户：{user_id}")
+
+                    # 发送回调数据给主程序处理
+                    callback_json = {
+                        "callback_query": {
+                            "id": call.id,
+                            "from": call.from_user.to_dict(),
+                            "message": {
+                                "message_id": call.message.message_id,
+                                "chat": {
+                                    "id": call.message.chat.id,
+                                }
+                            },
+                            "data": callback_data
+                        }
+                    }
+
+                    # 先确认回调，避免用户看到loading状态
+                    _bot.answer_callback_query(call.id)
+
+                    # 发送给主程序处理
+                    RequestUtils(timeout=15).post_res(self._ds_url, json=callback_json)
+
+                except Exception as e:
+                    logger.error(f"处理按钮回调失败：{str(e)}")
+                    _bot.answer_callback_query(call.id, "处理失败，请重试")
 
             def run_polling():
                 """
@@ -75,7 +119,10 @@ class Telegram:
         return self._bot is not None
 
     def send_msg(self, title: str, text: Optional[str] = None, image: Optional[str] = None,
-                 userid: Optional[str] = None, link: Optional[str] = None) -> Optional[bool]:
+                 userid: Optional[str] = None, link: Optional[str] = None,
+                 buttons: Optional[List[List[dict]]] = None,
+                 original_message_id: Optional[int] = None,
+                 original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
         发送Telegram消息
         :param title: 消息标题
@@ -83,6 +130,9 @@ class Telegram:
         :param image: 消息图片地址
         :param userid: 用户ID，如有则只发消息给该用户
         :param link: 跳转链接
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息ID，如果提供则编辑原消息
+        :param original_chat_id: 原消息的聊天ID，编辑消息时需要
         :userid: 发送消息的目标用户ID，为空则发给管理员
         """
         if not self._telegram_token or not self._telegram_chat_id:
@@ -108,16 +158,37 @@ class Telegram:
             else:
                 chat_id = self._telegram_chat_id
 
-            return self.__send_request(userid=chat_id, image=image, caption=caption)
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                return self.__edit_message(original_chat_id, original_message_id, caption, buttons, image)
+            else:
+                # 发送新消息
+                return self.__send_request(userid=chat_id, image=image, caption=caption, reply_markup=reply_markup)
 
         except Exception as msg_e:
             logger.error(f"发送消息失败：{msg_e}")
             return False
 
     def send_medias_msg(self, medias: List[MediaInfo], userid: Optional[str] = None,
-                        title: Optional[str] = None, link: Optional[str] = None) -> Optional[bool]:
+                        title: Optional[str] = None, link: Optional[str] = None,
+                        buttons: Optional[List[List[Dict]]] = None,
+                        original_message_id: Optional[int] = None,
+                        original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
         发送媒体列表消息
+        :param medias: 媒体信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param link: 跳转链接
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息ID，如果提供则编辑原消息
+        :param original_chat_id: 原消息的聊天ID，编辑消息时需要
         """
         if not self._telegram_token or not self._telegram_chat_id:
             return None
@@ -150,26 +221,44 @@ class Telegram:
             else:
                 chat_id = self._telegram_chat_id
 
-            return self.__send_request(userid=chat_id, image=image, caption=caption)
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息
+                return self.__edit_message(original_chat_id, original_message_id, caption, buttons, image)
+            else:
+                # 发送新消息
+                return self.__send_request(userid=chat_id, image=image, caption=caption, reply_markup=reply_markup)
 
         except Exception as msg_e:
             logger.error(f"发送消息失败：{msg_e}")
             return False
 
     def send_torrents_msg(self, torrents: List[Context],
-                          userid: Optional[str] = None, title: Optional[str] = None, link: Optional[str] = None) -> Optional[bool]:
+                          userid: Optional[str] = None, title: Optional[str] = None,
+                          link: Optional[str] = None, buttons: Optional[List[List[Dict]]] = None,
+                          original_message_id: Optional[int] = None,
+                          original_chat_id: Optional[str] = None) -> Optional[bool]:
         """
-        发送列表消息
+        发送种子列表消息
+        :param torrents: 种子信息列表
+        :param userid: 用户ID，如有则只发消息给该用户
+        :param title: 消息标题
+        :param link: 跳转链接
+        :param buttons: 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据"}]]
+        :param original_message_id: 原消息ID，如果提供则编辑原消息
+        :param original_chat_id: 原消息的聊天ID，编辑消息时需要
         """
         if not self._telegram_token or not self._telegram_chat_id:
             return None
 
-        if not torrents:
-            return False
-
         try:
             index, caption = 1, "*%s*" % title
-            mediainfo = torrents[0].media_info
+            image = torrents[0].media_info.get_message_image()
             for context in torrents:
                 torrent = context.torrent_info
                 site_name = torrent.site_name
@@ -194,20 +283,113 @@ class Telegram:
             else:
                 chat_id = self._telegram_chat_id
 
-            return self.__send_request(userid=chat_id, caption=caption,
-                                       image=mediainfo.get_message_image())
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            # 判断是编辑消息还是发送新消息
+            if original_message_id and original_chat_id:
+                # 编辑消息（种子消息通常没有图片）
+                return self.__edit_message(original_chat_id, original_message_id, caption, buttons, image)
+            else:
+                # 发送新消息
+                return self.__send_request(userid=chat_id, image=image, caption=caption, reply_markup=reply_markup)
 
         except Exception as msg_e:
             logger.error(f"发送消息失败：{msg_e}")
             return False
 
+    @staticmethod
+    def _create_inline_keyboard(buttons: List[List[Dict]]) -> InlineKeyboardMarkup:
+        """
+        创建内联键盘
+        :param buttons: 按钮配置，格式：[[{"text": "按钮文本", "callback_data": "回调数据", "url": "链接"}]]
+        :return: InlineKeyboardMarkup对象
+        """
+        keyboard = []
+        for row in buttons:
+            button_row = []
+            for button in row:
+                if "url" in button:
+                    # URL按钮
+                    btn = InlineKeyboardButton(text=button["text"], url=button["url"])
+                else:
+                    # 回调按钮
+                    btn = InlineKeyboardButton(text=button["text"], callback_data=button["callback_data"])
+                button_row.append(btn)
+            keyboard.append(button_row)
+        return InlineKeyboardMarkup(keyboard)
+
+    def answer_callback_query(self, callback_query_id: int, text: Optional[str] = None,
+                              show_alert: bool = False) -> Optional[bool]:
+        """
+        回应回调查询
+        """
+        if not self._bot:
+            return None
+
+        try:
+            self._bot.answer_callback_query(callback_query_id, text=text, show_alert=show_alert)
+            return True
+        except Exception as e:
+            logger.error(f"回应回调查询失败：{str(e)}")
+            return False
+
+    def __edit_message(self, chat_id: str, message_id: int, text: str,
+                       buttons: Optional[List[List[dict]]] = None,
+                       image: Optional[str] = None) -> Optional[bool]:
+        """
+        编辑已发送的消息
+        :param chat_id: 聊天ID
+        :param message_id: 消息ID
+        :param text: 新的消息内容
+        :param buttons: 按钮列表
+        :param image: 图片URL或路径
+        :return: 编辑是否成功
+        """
+        if not self._bot:
+            return None
+
+        try:
+            
+            # 创建按钮键盘
+            reply_markup = None
+            if buttons:
+                reply_markup = self._create_inline_keyboard(buttons)
+
+            if image:
+                # 如果有图片，使用edit_message_media
+                media = InputMediaPhoto(media=image, caption=text, parse_mode="Markdown")
+                self._bot.edit_message_media(
+                    chat_id=chat_id,
+                    message_id=message_id,
+                    media=media,
+                    reply_markup=reply_markup
+                )
+            else:
+                # 如果没有图片，使用edit_message_text
+                self._bot.edit_message_text(
+                    chat_id=chat_id,
+                    message_id=message_id,
+                    text=text,
+                    parse_mode="Markdown",
+                    reply_markup=reply_markup
+                )
+            return True
+        except Exception as e:
+            logger.error(f"编辑消息失败：{str(e)}")
+            return False
+
     @retry(Exception, logger=logger)
-    def __send_request(self, userid: Optional[str] = None, image="", caption="") -> bool:
+    def __send_request(self, userid: Optional[str] = None, image="", caption="",
+                       reply_markup: Optional[InlineKeyboardMarkup] = None) -> bool:
         """
         向Telegram发送报文
+        :param reply_markup: 内联键盘
         """
         if image:
-            res = RequestUtils(proxies=settings.PROXY).get_res(image)
+            res = RequestUtils(proxies=settings.PROXY, ua=settings.USER_AGENT).get_res(image)
             if res is None:
                 raise Exception("获取图片失败")
             if res.content:
@@ -221,7 +403,8 @@ class Telegram:
                 ret = self._bot.send_photo(chat_id=userid or self._telegram_chat_id,
                                            photo=photo,
                                            caption=caption,
-                                           parse_mode="Markdown")
+                                           parse_mode="Markdown",
+                                           reply_markup=reply_markup)
                 if ret is None:
                     raise Exception("发送图片消息失败")
                 return True
@@ -231,11 +414,13 @@ class Telegram:
             for i in range(0, len(caption), 4095):
                 ret = self._bot.send_message(chat_id=userid or self._telegram_chat_id,
                                              text=caption[i:i + 4095],
-                                             parse_mode="Markdown")
+                                             parse_mode="Markdown",
+                                             reply_markup=reply_markup if i == 0 else None)
         else:
             ret = self._bot.send_message(chat_id=userid or self._telegram_chat_id,
                                          text=caption,
-                                         parse_mode="Markdown")
+                                         parse_mode="Markdown",
+                                         reply_markup=reply_markup)
         if ret is None:
             raise Exception("发送文本消息失败")
         return True if ret else False

app/modules/themoviedb/tmdb_cache.py

@@ -15,7 +15,7 @@ from app.schemas.types import MediaType
 lock = RLock()
 
 CACHE_EXPIRE_TIMESTAMP_STR = "cache_expire_timestamp"
-EXPIRE_TIMESTAMP = settings.CACHE_CONF["meta"]
+EXPIRE_TIMESTAMP = settings.CONF["meta"]
 
 
 class TmdbCache(metaclass=Singleton):

app/modules/themoviedb/tmdbapi.py

@@ -500,7 +500,7 @@ class TmdbApi:
 
             return ret_info
 
-    @cached(maxsize=settings.CACHE_CONF["tmdb"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF["tmdb"], ttl=settings.CONF["meta"])
     @rate_limit_exponential(source="match_tmdb_web", base_wait=5, max_wait=1800, enable_logging=True)
     def match_web(self, name: str, mtype: MediaType) -> Optional[dict]:
         """

app/modules/themoviedb/tmdbv3api/tmdb.py

@@ -124,7 +124,7 @@ class TMDb(object):
     def cache(self, cache):
         self._cache_enabled = bool(cache)
 
-    @cached(maxsize=settings.CACHE_CONF["tmdb"], ttl=settings.CACHE_CONF["meta"])
+    @cached(maxsize=settings.CONF["tmdb"], ttl=settings.CONF["meta"])
     def cached_request(self, method, url, data, json,
                        _ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """

app/modules/transmission/__init__.py

@@ -292,7 +292,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
                     ))
         else:
             return None
-        return ret_torrents
+        return ret_torrents # noqa
 
     def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """
@@ -312,6 +312,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         else:
             tags = ['已整理']
         server.set_torrent_tag(ids=hashs, tags=tags)
+        return None
 
     def remove_torrents(self, hashs: Union[str, list], delete_file: Optional[bool] = True,
                         downloader: Optional[str] = None) -> Optional[bool]:
@@ -354,7 +355,7 @@ class TransmissionModule(_ModuleBase, _DownloaderBase[Transmission]):
         server: Transmission = self.get_instance(downloader)
         if not server:
             return None
-        return server.start_torrents(ids=hashs)
+        return server.stop_torrents(ids=hashs)
 
     def torrent_files(self, tid: str, downloader: Optional[str] = None) -> Optional[List[File]]:
         """

app/scheduler.py

@@ -166,7 +166,7 @@ class Scheduler(metaclass=Singleton):
             # 创建定时服务
             self._scheduler = BackgroundScheduler(timezone=settings.TZ,
                                                   executors={
-                                                      'default': ThreadPoolExecutor(100)
+                                                      'default': ThreadPoolExecutor(settings.CONF['scheduler'])
                                                   })
 
             # CookieCloud定时同步
@@ -323,7 +323,7 @@ class Scheduler(metaclass=Singleton):
                 "interval",
                 id="clear_cache",
                 name="缓存清理",
-                hours=settings.CACHE_CONF["meta"] / 3600,
+                hours=settings.CONF["meta"] / 3600,
                 kwargs={
                     'job_id': 'clear_cache'
                 }

app/schemas/message.py

@@ -1,4 +1,6 @@
-from typing import Optional, Union
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional, Union, List, Dict, Set
 
 from pydantic import BaseModel, Field
 
@@ -23,6 +25,16 @@ class CommingMessage(BaseModel):
     date: Optional[str] = None
     # 消息方向
     action: Optional[int] = 0
+    # 是否为回调消息
+    is_callback: Optional[bool] = False
+    # 回调数据
+    callback_data: Optional[str] = None
+    # 消息ID（用于回调时定位原消息）
+    message_id: Optional[Union[str, int]] = None
+    # 聊天ID（用于回调时定位聊天）
+    chat_id: Optional[str] = None
+    # 完整的回调查询信息（原始数据）
+    callback_query: Optional[Dict] = None
 
     def to_dict(self):
         """
@@ -65,6 +77,12 @@ class Notification(BaseModel):
     action: Optional[int] = 1
     # 消息目标用户ID字典，未指定用户ID时使用
     targets: Optional[dict] = None
+    # 按钮列表，格式：[[{"text": "按钮文本", "callback_data": "回调数据", "url": "链接"}]]
+    buttons: Optional[List[List[dict]]] = None
+    # 原消息ID，用于编辑消息
+    original_message_id: Optional[Union[str, int]] = None
+    # 原消息的聊天ID，用于编辑消息
+    original_chat_id: Optional[str] = None
 
     def to_dict(self):
         """
@@ -115,3 +133,191 @@ class SubscriptionMessage(BaseModel):
     icon: Optional[str] = None
     url: Optional[str] = None
     data: Optional[dict] = Field(default_factory=dict)
+
+
+class ChannelCapability(Enum):
+    """
+    渠道能力枚举
+    """
+    # 支持内联按钮
+    INLINE_BUTTONS = "inline_buttons"
+    # 支持菜单命令
+    MENU_COMMANDS = "menu_commands"
+    # 支持消息编辑
+    MESSAGE_EDITING = "message_editing"
+    # 支持回调查询
+    CALLBACK_QUERIES = "callback_queries"
+    # 支持富文本
+    RICH_TEXT = "rich_text"
+    # 支持图片
+    IMAGES = "images"
+    # 支持链接
+    LINKS = "links"
+    # 支持文件发送
+    FILE_SENDING = "file_sending"
+
+
+@dataclass
+class ChannelCapabilities:
+    """
+    渠道能力配置
+    """
+    channel: MessageChannel
+    capabilities: Set[ChannelCapability]
+    max_buttons_per_row: int = 5
+    max_button_rows: int = 10
+    max_button_text_length: int = 30
+    fallback_enabled: bool = True
+
+
+class ChannelCapabilityManager:
+    """
+    渠道能力管理器
+    """
+
+    _capabilities: Dict[MessageChannel, ChannelCapabilities] = {
+        MessageChannel.Telegram: ChannelCapabilities(
+            channel=MessageChannel.Telegram,
+            capabilities={
+                ChannelCapability.INLINE_BUTTONS,
+                ChannelCapability.MENU_COMMANDS,
+                ChannelCapability.MESSAGE_EDITING,
+                ChannelCapability.CALLBACK_QUERIES,
+                ChannelCapability.RICH_TEXT,
+                ChannelCapability.IMAGES,
+                ChannelCapability.LINKS,
+                ChannelCapability.FILE_SENDING
+            },
+            max_buttons_per_row=4,
+            max_button_rows=10,
+            max_button_text_length=30
+        ),
+        MessageChannel.Wechat: ChannelCapabilities(
+            channel=MessageChannel.Wechat,
+            capabilities={
+                ChannelCapability.IMAGES,
+                ChannelCapability.LINKS,
+                ChannelCapability.MENU_COMMANDS
+            },
+            fallback_enabled=True
+        ),
+        MessageChannel.Slack: ChannelCapabilities(
+            channel=MessageChannel.Slack,
+            capabilities={
+                ChannelCapability.INLINE_BUTTONS,
+                ChannelCapability.CALLBACK_QUERIES,
+                ChannelCapability.RICH_TEXT,
+                ChannelCapability.IMAGES,
+                ChannelCapability.LINKS,
+                ChannelCapability.MENU_COMMANDS
+            },
+            max_buttons_per_row=3,
+            max_button_rows=8,
+            max_button_text_length=25,
+            fallback_enabled=True
+        ),
+        MessageChannel.SynologyChat: ChannelCapabilities(
+            channel=MessageChannel.SynologyChat,
+            capabilities={
+                ChannelCapability.RICH_TEXT,
+                ChannelCapability.IMAGES,
+                ChannelCapability.LINKS
+            },
+            fallback_enabled=True
+        ),
+        MessageChannel.VoceChat: ChannelCapabilities(
+            channel=MessageChannel.VoceChat,
+            capabilities={
+                ChannelCapability.RICH_TEXT,
+                ChannelCapability.IMAGES,
+                ChannelCapability.LINKS
+            },
+            fallback_enabled=True
+        ),
+        MessageChannel.WebPush: ChannelCapabilities(
+            channel=MessageChannel.WebPush,
+            capabilities={
+                ChannelCapability.LINKS
+            },
+            fallback_enabled=True
+        ),
+        MessageChannel.Web: ChannelCapabilities(
+            channel=MessageChannel.Web,
+            capabilities={
+                ChannelCapability.RICH_TEXT,
+                ChannelCapability.IMAGES,
+                ChannelCapability.LINKS
+            },
+            fallback_enabled=True
+        )
+    }
+
+    @classmethod
+    def get_capabilities(cls, channel: MessageChannel) -> Optional[ChannelCapabilities]:
+        """
+        获取渠道能力
+        """
+        return cls._capabilities.get(channel)
+
+    @classmethod
+    def supports_capability(cls, channel: MessageChannel, capability: ChannelCapability) -> bool:
+        """
+        检查渠道是否支持某项能力
+        """
+        channel_caps = cls.get_capabilities(channel)
+        if not channel_caps:
+            return False
+        return capability in channel_caps.capabilities
+
+    @classmethod
+    def supports_buttons(cls, channel: MessageChannel) -> bool:
+        """
+        检查渠道是否支持按钮
+        """
+        return cls.supports_capability(channel, ChannelCapability.INLINE_BUTTONS)
+
+    @classmethod
+    def supports_callbacks(cls, channel: MessageChannel) -> bool:
+        """
+        检查渠道是否支持回调
+        """
+        return cls.supports_capability(channel, ChannelCapability.CALLBACK_QUERIES)
+
+    @classmethod
+    def supports_editing(cls, channel: MessageChannel) -> bool:
+        """
+        检查渠道是否支持消息编辑
+        """
+        return cls.supports_capability(channel, ChannelCapability.MESSAGE_EDITING)
+
+    @classmethod
+    def get_max_buttons_per_row(cls, channel: MessageChannel) -> int:
+        """
+        获取每行最大按钮数
+        """
+        channel_caps = cls.get_capabilities(channel)
+        return channel_caps.max_buttons_per_row if channel_caps else 2
+
+    @classmethod
+    def get_max_button_rows(cls, channel: MessageChannel) -> int:
+        """
+        获取最大按钮行数
+        """
+        channel_caps = cls.get_capabilities(channel)
+        return channel_caps.max_button_rows if channel_caps else 5
+
+    @classmethod
+    def get_max_button_text_length(cls, channel: MessageChannel) -> int:
+        """
+        获取按钮文本最大长度
+        """
+        channel_caps = cls.get_capabilities(channel)
+        return channel_caps.max_button_text_length if channel_caps else 20
+
+    @classmethod
+    def should_use_fallback(cls, channel: MessageChannel) -> bool:
+        """
+        是否应该使用降级策略
+        """
+        channel_caps = cls.get_capabilities(channel)
+        return channel_caps.fallback_enabled if channel_caps else True

app/schemas/token.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class Token(BaseModel):
@@ -18,6 +18,8 @@ class Token(BaseModel):
     avatar: Optional[str] = None
     # 权限级别
     level: int = 1
+    # 详细权限
+    permissions: Optional[dict] = Field(default_factory=dict)
 
 
 class TokenPayload(BaseModel):

app/schemas/types.py

@@ -63,6 +63,8 @@ class EventType(Enum):
     ModuleReload = "module.reload"
     # 配置项更新
     ConfigChanged = "config.updated"
+    # 消息交互动作
+    MessageAction = "message.action"
 
 
 # 同步链式事件
@@ -157,6 +159,8 @@ class SystemConfigKey(Enum):
     NotificationSendTime = "NotificationSendTime"
     # 通知消息格式模板
     NotificationTemplates = "NotificationTemplates"
+    # 刮削开关设置
+    ScrapingSwitchs = "ScrapingSwitchs"
 
 
 # 处理进度Key字典

app/schemas/user.py

@@ -32,6 +32,7 @@ class UserCreate(UserBase):
     email: Optional[str] = None
     password: Optional[str] = None
     settings: Optional[dict] = Field(default_factory=dict)
+    permissions: Optional[dict] = Field(default_factory=dict)
 
 
 # Properties to receive via API on update
@@ -41,6 +42,7 @@ class UserUpdate(UserBase):
     email: Optional[str] = None
     password: Optional[str] = None
     settings: Optional[dict] = Field(default_factory=dict)
+    permissions: Optional[dict] = Field(default_factory=dict)
 
 
 class UserInDBBase(UserBase):

app/startup/lifecycle.py

@@ -4,7 +4,6 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI
 
 from app.chain.system import SystemChain
-from app.core.config import global_vars
 from app.startup.command_initializer import init_command, stop_command, restart_command
 from app.startup.memory_initializer import init_memory_manager, stop_memory_manager
 from app.startup.modules_initializer import init_modules, stop_modules
@@ -13,9 +12,10 @@ from app.startup.plugins_initializer import init_plugins, stop_plugins, sync_plu
 from app.startup.routers_initializer import init_routers
 from app.startup.scheduler_initializer import stop_scheduler, init_scheduler, init_plugin_scheduler
 from app.startup.workflow_initializer import init_workflow, stop_workflow
+from app.helper.system import SystemHelper
 
 
-async def init_plugin_system():
+async def init_extra():
     """
     同步插件及重启相关依赖服务
     """
@@ -24,6 +24,8 @@ async def init_plugin_system():
         init_plugin_scheduler()
         # 重新注册命令
         restart_command()
+    # 设置系统已修改标志
+    SystemHelper().set_system_modified()
     # 重启完成
     SystemChain().restart_finish()
 
@@ -38,6 +40,8 @@ async def lifespan(app: FastAPI):
     init_modules()
     # 初始化路由
     init_routers(app)
+    # 恢复插件备份
+    SystemChain().restore_plugins()
     # 初始化插件
     init_plugins()
     # 初始化定时器
@@ -51,14 +55,12 @@ async def lifespan(app: FastAPI):
     # 初始化内存管理
     init_memory_manager()
     # 插件同步到本地
-    sync_plugins_task = asyncio.create_task(init_plugin_system())
+    sync_plugins_task = asyncio.create_task(init_extra())
     try:
         # 在此处 yield，表示应用已经启动，控制权交回 FastAPI 主事件循环
         yield
     finally:
         print("Shutting down...")
-        # 停止信号
-        global_vars.stop_system()
         # 取消同步插件任务
         try:
             sync_plugins_task.cancel()
@@ -67,6 +69,8 @@ async def lifespan(app: FastAPI):
             pass
         except Exception as e:
             print(str(e))
+        # 备份插件
+        SystemChain().backup_plugins()
         # 停止内存管理器
         stop_memory_manager()
         # 停止工作流

app/startup/memory_initializer.py

@@ -1,19 +1,15 @@
-from app.core.config import settings
-from app.helper.memory import MemoryManager
+from app.helper.memory import MemoryHelper
 
 
 def init_memory_manager():
     """
     初始化内存监控器
     """
-    memory_manager = MemoryManager()
-    # 设置内存阈值和启动监控
-    memory_manager.set_threshold(settings.CACHE_CONF['memory'])
-    memory_manager.start_monitoring()
+    MemoryHelper().start_monitoring()
 
 
 def stop_memory_manager():
     """
     停止内存监控器
     """
-    MemoryManager().stop_monitoring()
+    MemoryHelper().stop_monitoring()

app/startup/modules_initializer.py

@@ -19,6 +19,7 @@ except ImportError as e:
 from app.core.event import EventManager
 from app.helper.thread import ThreadHelper
 from app.helper.display import DisplayHelper
+from app.helper.doh import DohHelper
 from app.helper.resource import ResourceHelper
 from app.helper.message import MessageHelper
 from app.schemas import Notification, NotificationType
@@ -132,6 +133,8 @@ def init_modules():
     """
     # 虚拟显示
     DisplayHelper()
+    # DoH
+    DohHelper()
     # 站点管理
     SitesHelper()
     # 资源包检测

app/utils/system.py

@@ -17,6 +17,9 @@ from app import schemas
 
 
 class SystemUtils:
+    """
+    系统工具类，提供系统相关的操作和信息获取方法。
+    """
 
     @staticmethod
     def execute(cmd: str) -> str:
@@ -439,7 +442,7 @@ class SystemUtils:
         current_process = psutil.Process()
         process_memory = current_process.memory_info().rss
         system_memory = psutil.virtual_memory().total
-        process_memory_percent = (process_memory / system_memory) * 100 
+        process_memory_percent = (process_memory / system_memory) * 100
         return [process_memory, int(process_memory_percent)]
 
     @staticmethod

config/app.env

@@ -5,18 +5,8 @@
 HOST=0.0.0.0
 # 【*】超级管理员，设置后一但重启将固化到数据库中，修改将无效（初始化超级管理员密码仅会生成一次，请在日志中查看并自行登录系统修改）
 SUPERUSER=admin
-# 重启自动升级 release/dev/true/false
-MOVIEPILOT_AUTO_UPDATE=release
-# 自动检查和更新站点资源包（索引、认证等）
-AUTO_UPDATE_RESOURCE=true
-# 网络代理服务器地址 http(s)://ip:port、socks5://user:pass@host:port、socks5h://user:pass@host:port
-PROXY_HOST=
-# 媒体识别来源 themoviedb/douban，使用themoviedb时需要确保能正常连接api.themoviedb.org，使用douban时不支持二级分类
-RECOGNIZE_SOURCE=themoviedb
-# OCR服务器地址
-OCR_HOST=https://movie-pilot.org
-# 搜索多个名称，true/false，为true时搜索时会同时搜索中英文及原始名称，搜索结果会更全面，但会增加搜索时间；为false时其中一个名称搜索到结果或全部名称搜索完毕即停止
-SEARCH_MULTIPLE_NAME=false
+# 开发调试模式，仅开发人员使用，打开后将停止后台服务
+DEV=false
 # 为指定字幕添加.default后缀设置为默认字幕，支持为'zh-cn'，'zh-tw'，'eng'添加默认字幕，未定义或设置为None则不添加
 DEFAULT_SUB=zh-cn
 # 数据库连接池的大小，可适当降低如20-50以减少I/O压力
@@ -25,5 +15,9 @@ DB_POOL_SIZE=100
 DB_MAX_OVERFLOW=500
 # SQLite 的 busy_timeout 参数，可适当增加如180以减少锁定错误
 DB_TIMEOUT=60
-# 是否开发调试模式，仅开发人员使用，打开后将停止后台服务
-DEV=false
+# 是否启用内存监控，开启后将定期生成内存快照文件
+MEMORY_ANALYSIS=false
+# 内存快照间隔（分钟）
+MEMORY_SNAPSHOT_INTERVAL=60
+# 保留的内存快照文件数量
+MEMORY_SNAPSHOT_KEEP_COUNT=20

database/versions/3df653756eec_2_1_6.py

@@ -0,0 +1,42 @@
+"""2.1.6
+
+Revision ID: 3df653756eec
+Revises: 486e56a62dcb
+Create Date: 2025-06-11 19:52:57.185355
+
+"""
+import json
+
+from app.db import SessionFactory
+from app.db.models import User
+
+# revision identifiers, used by Alembic.
+revision = '3df653756eec'
+down_revision = '486e56a62dcb'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with SessionFactory() as db:
+        # 所有用户
+        users = User.list(db)
+        for user in users:
+            if user.is_superuser:
+                continue
+            if not user.permissions:
+                permissions = {
+                    "discovery": True,
+                    "search": True,
+                    "subscribe": True,
+                    "manage": False,
+                }
+                user.update(db, {
+                    "permissions": permissions,
+                })
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    pass

requirements.in

@@ -61,7 +61,6 @@ Pinyin2Hanzi~=0.1.1
 pywebpush~=2.0.0
 python-cookietools==0.0.2.1
 aiofiles~=24.1.0
-jieba~=0.42.1
 rsa~=4.9
 redis~=5.2.1
 async_timeout~=5.0.1; python_full_version < "3.11.3"
@@ -70,3 +69,4 @@ cf_clearance~=0.31.0
 oss2~=2.19.1
 tqdm~=4.67.1
 setuptools~=78.1.0
+pympler~=1.1

version.py

@@ -1,2 +1,2 @@
-APP_VERSION = 'v2.5.3'
-FRONTEND_VERSION = 'v2.5.3'
+APP_VERSION = 'v2.5.7'
+FRONTEND_VERSION = 'v2.5.7'