v1.9.11

- 支持环境变量配置DOH域名和DNS服务器 - 问题修复
Merge pull request #2534 from InfinityPacer/main
2026-05-11 01:49:49 +08:00 · 2024-07-09 08:09:58 +08:00 · 2024-07-08 12:23:16 +08:00 · 2024-07-08 12:22:50 +08:00 · 2024-07-07 23:03:34 +08:00 · 2024-07-07 18:27:06 +08:00
451 changed files with 17564 additions and 67596 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,84 +1,3 @@
-# Git
+# Ignore git
 .github
-.git
-.gitignore
-
-# Documentation
-docs/
-README.md
-LICENSE
-
-# Development files
-.pylintrc
-*.pyc
-__pycache__/
-*.pyo
-*.pyd
-.Python
-*.so
-.pytest_cache/
-.coverage
-htmlcov/
-.tox/
-.nox/
-.hypothesis/
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Virtual environments
-venv/
-env/
-ENV/
-env.bak/
-venv.bak/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-
-# Logs
-*.log
-logs/
-
-# Temporary files
-*.tmp
-*.temp
-tmp/
-temp/
-
-# Database
-*.db
-*.sqlite
-*.sqlite3
-
-# Test files
-tests/
-test_*
-*_test.py
-
-# Build artifacts
-build/
-dist/
-*.egg-info/
-
-# Docker
-Dockerfile*
-docker-compose*
-.dockerignore
-
-# Other
-app.ico
-frozen.spec
+.git
--- a/.github/ISSUE_TEMPLATE/rfc.yml
+++ b/.github/ISSUE_TEMPLATE/rfc.yml
@@ -1,45 +0,0 @@
-name: 功能提案
-description: Request for Comments
-title: "[RFC]"
-labels: ["RFC"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        一份提案(RFC)定位为 **「在某功能/重构的具体开发前，用于开发者间 review 技术设计/方案的文档」**，
-        目的是让协作的开发者间清晰的知道「要做什么」和「具体会怎么做」，以及所有的开发者都能公开透明的参与讨论；
-        以便评估和讨论产生的影响 (遗漏的考虑、向后兼容性、与现有功能的冲突)，
-        因此提案侧重在对解决问题的 **方案、设计、步骤** 的描述上。
-
-        如果仅希望讨论是否添加或改进某功能本身，请使用 -> [Issue: 功能改进](https://github.com/jxxghp/MoviePilot/issues/new?assignees=&labels=feature+request&projects=&template=feature_request.yml&title=%5BFeature+Request%5D%3A+)
-  - type: textarea
-    id: background
-    attributes:
-      label: 背景 or 问题
-      description: 简单描述遇到的什么问题或需要改动什么。可以引用其他 issue、讨论、文档等。
-    validations:
-      required: true
-  - type: textarea
-    id: goal
-    attributes:
-      label: "目标 & 方案简述"
-      description: 简单描述提案此提案实现后，**预期的目标效果**，以及简单大致描述会采取的方案/步骤，可能会/不会产生什么影响。
-    validations:
-      required: true
-  - type: textarea
-    id: design
-    attributes:
-      label: "方案设计 & 实现步骤"
-      description: |
-        详细描述你设计的具体方案，可以考虑拆分列表或要点，一步步描述具体打算如何实现的步骤和相关细节。
-        这部份不需要一次性写完整，即使在创建完此提案 issue 后，依旧可以再次编辑修改。
-    validations:
-      required: false
-  - type: textarea
-    id: alternative
-    attributes:
-      label: "替代方案 & 对比"
-      description: |
-        [可选] 为来实现目标效果，还考虑过什么其他方案，有什么对比？
-    validations:
-      required: false
--- a/.github/workflows/beta.yml
+++ b/.github/workflows/beta.yml
@@ -1,60 +0,0 @@
-name: MoviePilot Builder Beta
-on:
-  workflow_dispatch:
-
-jobs:
-  Docker-build:
-    runs-on: ubuntu-latest
-    name: Build Docker Image
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Release version
-        id: release_version
-        run: |
-          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
-          echo "app_version=$app_version" >> $GITHUB_ENV
-
-      - name: Docker Meta
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: |
-            ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
-            ghcr.io/${{ github.repository }}
-          tags: |
-            type=raw,value=beta
-
-      - name: Set Up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set Up Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Login DockerHub
-        uses: docker/login-action@v3
-        with:
-          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:
-          context: .
-          file: docker/Dockerfile
-          platforms: |
-            linux/amd64
-            linux/arm64/v8
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha, scope=${{ github.workflow }}-docker
-          cache-to: type=gha, scope=${{ github.workflow }}-docker
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,11 +1,11 @@
-name: MoviePilot Builder v2
+name: MoviePilot Builder
 on:
  workflow_dispatch:
  push:
    branches:
-      - v2
+      - main
    paths:
-      - 'version.py'
+      - version.py

 jobs:
  Docker-build:
@@ -25,10 +25,7 @@ jobs:
        id: meta
        uses: docker/metadata-action@v5
        with:
-          images: |
-            ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
-            ${{ secrets.DOCKER_USERNAME }}/moviepilot
-            ghcr.io/${{ github.repository }}
+          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot
          tags: |
            type=raw,value=${{ env.app_version }}
            type=raw,value=latest
@@ -45,54 +42,190 @@ 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:
          context: .
-          file: docker/Dockerfile
+          file: Dockerfile
          platforms: |
            linux/amd64
            linux/arm64/v8
          push: true
+          build-args: |
+            MOVIEPILOT_VERSION=${{ env.app_version }}
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha, scope=${{ github.workflow }}-docker
          cache-to: type=gha, scope=${{ github.workflow }}-docker

-      - name: Get existing release body
-        id: get_release_body
-        continue-on-error: true
+  Windows-build:
+    runs-on: windows-latest
+    name: Build Windows Binary
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Init Python 3.11.4
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11.4'
+          cache: 'pip'
+
+      - name: Install Dependent Packages
        run: |
-          release_body=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
-            "https://api.github.com/repos/${{ github.repository }}/releases/tags/v${{ env.app_version }}" | \
-            jq -r '.body // ""')
-          echo "RELEASE_BODY<<EOF" >> $GITHUB_ENV
-          echo "$release_body" >> $GITHUB_ENV
-          echo "EOF" >> $GITHUB_ENV
+          python -m pip install --upgrade pip
+          pip install wheel pyinstaller
+          pip install -r requirements.txt
+        shell: pwsh

-      - name: Delete Release
-        uses: dev-drprasad/delete-tag-and-release@v1.1
-        continue-on-error: true
-        with:
-          tag_name: v${{ env.app_version }}
-          delete_release: true
-          github_token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Prepare Frontend
+        run: |
+          # 下载nginx
+          Invoke-WebRequest -Uri "http://nginx.org/download/nginx-1.25.2.zip" -OutFile "nginx.zip"
+          Expand-Archive -Path "nginx.zip" -DestinationPath "nginx-1.25.2"
+          Move-Item -Path "nginx-1.25.2/nginx-1.25.2" -Destination "nginx"
+          Remove-Item -Path "nginx.zip"
+          Remove-Item -Path "nginx-1.25.2" -Recurse -Force
+          # 下载前端
+          $FRONTEND_VERSION = (Invoke-WebRequest -Uri "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" | ConvertFrom-Json).tag_name
+          Invoke-WebRequest -Uri "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/$FRONTEND_VERSION/dist.zip" -OutFile "dist.zip"
+          Expand-Archive -Path "dist.zip" -DestinationPath "dist"
+          Move-Item -Path "dist/dist/*" -Destination "nginx/html" -Force
+          Remove-Item -Path "dist.zip"
+          Remove-Item -Path "dist" -Recurse -Force
+          Move-Item -Path "nginx/html/nginx.conf" -Destination "nginx/conf/nginx.conf" -Force
+          New-Item -Path "nginx/temp" -ItemType Directory -Force          
+          New-Item -Path "nginx/temp/__keep__.txt" -ItemType File -Force
+          New-Item -Path "nginx/logs" -ItemType Directory -Force
+          New-Item -Path "nginx/logs/__keep__.txt" -ItemType File -Force
+          # 下载插件 jxxghp
+          Invoke-WebRequest -Uri "https://github.com/jxxghp/MoviePilot-Plugins/archive/refs/heads/main.zip" -OutFile "MoviePilot-Plugins-main.zip"
+          Expand-Archive -Path "MoviePilot-Plugins-main.zip" -DestinationPath "MoviePilot-Plugins-main"
+          Move-Item -Path "MoviePilot-Plugins-main/MoviePilot-Plugins-main/plugins/*" -Destination "app/plugins/" -Force -ErrorAction SilentlyContinue
+          Remove-Item -Path "MoviePilot-Plugins-main.zip"
+          Remove-Item -Path "MoviePilot-Plugins-main" -Recurse -Force
+          # 下载插件 thsrite
+          Invoke-WebRequest -Uri "https://github.com/thsrite/MoviePilot-Plugins/archive/refs/heads/main.zip" -OutFile "MoviePilot-Plugins-main.zip"
+          Expand-Archive -Path "MoviePilot-Plugins-main.zip" -DestinationPath "MoviePilot-Plugins-main"
+          Move-Item -Path "MoviePilot-Plugins-main/MoviePilot-Plugins-main/plugins/*" -Destination "app/plugins/" -Force -ErrorAction SilentlyContinue
+          Remove-Item -Path "MoviePilot-Plugins-main.zip"
+          Remove-Item -Path "MoviePilot-Plugins-main" -Recurse -Force
+          # 下载插件 honue
+          Invoke-WebRequest -Uri "https://github.com/honue/MoviePilot-Plugins/archive/refs/heads/main.zip" -OutFile "MoviePilot-Plugins-main.zip"
+          Expand-Archive -Path "MoviePilot-Plugins-main.zip" -DestinationPath "MoviePilot-Plugins-main"
+          Move-Item -Path "MoviePilot-Plugins-main/MoviePilot-Plugins-main/plugins/*" -Destination "app/plugins/" -Force -ErrorAction SilentlyContinue
+          Remove-Item -Path "MoviePilot-Plugins-main.zip"
+          Remove-Item -Path "MoviePilot-Plugins-main" -Recurse -Force
+          # 下载插件 InfinityPacer
+          Invoke-WebRequest -Uri "https://github.com/InfinityPacer/MoviePilot-Plugins/archive/refs/heads/main.zip" -OutFile "MoviePilot-Plugins-main.zip"
+          Expand-Archive -Path "MoviePilot-Plugins-main.zip" -DestinationPath "MoviePilot-Plugins-main"
+          Move-Item -Path "MoviePilot-Plugins-main/MoviePilot-Plugins-main/plugins/*" -Destination "app/plugins/" -Force -ErrorAction SilentlyContinue
+          Remove-Item -Path "MoviePilot-Plugins-main.zip"
+          Remove-Item -Path "MoviePilot-Plugins-main" -Recurse -Force
+          # 下载资源
+          Invoke-WebRequest -Uri "https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip" -OutFile "MoviePilot-Resources-main.zip"
+          Expand-Archive -Path "MoviePilot-Resources-main.zip" -DestinationPath "MoviePilot-Resources-main"
+          Move-Item -Path "MoviePilot-Resources-main/MoviePilot-Resources-main/resources/*" -Destination "app/helper/" -Force
+          Remove-Item -Path "MoviePilot-Resources-main.zip"
+          Remove-Item -Path "MoviePilot-Resources-main" -Recurse -Force
+        shell: pwsh

-      - name: Generate Release
-        uses: softprops/action-gh-release@v2
+      - name: Pyinstaller
+        run: |
+          pyinstaller frozen.spec
+        shell: pwsh
+
+      - name: Upload Windows File
+        uses: actions/upload-artifact@v3
        with:
-          tag_name: v${{ env.app_version }}
-          name: v${{ env.app_version }}
-          body: ${{ env.RELEASE_BODY }}
-          draft: false
-          prerelease: false
-          make_latest: true
+          name: windows
+          path: dist/MoviePilot.exe
+
+  Linux-build-amd64:
+    runs-on: ubuntu-latest
+    name: Build Linux Amd64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Init Python 3.11.4
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11.4'
+          cache: 'pip'
+
+      - name: Install Dependent Packages
+        run: |
+          python -m pip install --upgrade pip
+          pip install wheel pyinstaller
+          pip install -r requirements.txt
+          find app/plugins -name requirements.txt -exec pip install -r {} \;
+
+      - name: Prepare Frontend
+        run: |
+          wget https://github.com/jxxghp/MoviePilot-Plugins/archive/refs/heads/main.zip
+          unzip main.zip
+          mv MoviePilot-Plugins-main/plugins/* app/plugins/
+          rm main.zip
+          rm -rf MoviePilot-Plugins-main
+          
+          wget https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip
+          unzip main.zip
+          mv MoviePilot-Resources-main/resources/* app/helper/
+          rm main.zip
+          rm -rf MoviePilot-Resources-main
+
+      - name: Pyinstaller
+        run: |
+          pyinstaller frozen.spec
+          mv dist/MoviePilot dist/MoviePilot_Amd64
+
+      - name: Upload Linux File
+        uses: actions/upload-artifact@v3
+        with:
+          name: linux-amd64
+          path: dist/MoviePilot_Amd64
+
+  Create-release:
+    permissions: write-all
+    runs-on: ubuntu-latest
+    needs: [ Windows-build, Docker-build, Linux-build-amd64]
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Release Version
+        id: release_version
+        run: |
+          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
+          echo "app_version=$app_version" >> $GITHUB_ENV
+
+      - name: Download Artifact
+        uses: actions/download-artifact@v3
+
+      - name: get release_informations
+        shell: bash
+        run: |
+          mkdir releases
+          mv ./windows/MoviePilot.exe ./releases/MoviePilot_Win_v${{ env.app_version }}.exe
+          mv ./linux-amd64/MoviePilot_Amd64 ./releases/MoviePilot_Amd64_v${{ env.app_version }}
+
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@latest
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: v${{ env.app_version }}
+          release_name: v${{ env.app_version }}
+          body: ${{ github.event.commits[0].message }}
+          draft: false
+          prerelease: false
+
+      - name: Upload Release Asset
+        uses: dwenegar/upload-release-assets@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          release_id: ${{ steps.create_release.outputs.id }}
+          assets_path: |
+            ./releases/
--- a/.github/workflows/issues.yml
+++ b/.github/workflows/issues.yml
@@ -1,32 +0,0 @@
-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
-         # 排除带有RFC标签的issue
-         exempt-issue-labels: "RFC"
-         repo-token: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/pylint.yml
+++ b/.github/workflows/pylint.yml
@@ -1,91 +0,0 @@
-name: Pylint Code Quality Check
-
-on:
-  # 允许手动触发
-  workflow_dispatch:
-
-jobs:
-  pylint:
-    runs-on: ubuntu-latest
-    name: Pylint Code Quality Check
-
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.12'
-        cache: 'pip'
-
-    - name: Cache pip dependencies
-      uses: actions/cache@v4
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt', '**/requirements.in') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-
-
-    - name: Install dependencies
-      run: |
-        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
-      run: |
-        # 检查项目中的pylint配置文件是否存在
-        if [ -f .pylintrc ]; then
-          echo "✅ 找到项目配置文件: .pylintrc"
-          echo "配置文件内容预览:"
-          head -10 .pylintrc
-        else
-          echo "❌ 未找到 .pylintrc 配置文件"
-          exit 1
-        fi
-    - name: Run pylint
-      run: |
-        # 运行pylint，检查主要的Python文件
-        echo "🚀 运行 Pylint 错误检查..."
-
-        # 检查主要目录 - 只关注错误，如果有错误则退出
-        echo "📂 检查 app/ 目录..."
-        pylint app/ --output-format=colorized --reports=yes --score=yes
-
-        # 检查根目录的Python文件
-        echo "📂 检查根目录 Python 文件..."
-        for file in $(find . -name "*.py" -not -path "./.*" -not -path "./.venv/*" -not -path "./build/*" -not -path "./dist/*" -not -path "./tests/*" -not -path "./docs/*" -not -path "./__pycache__/*" -maxdepth 1); do
-          echo "检查文件: $file"
-          pylint "$file" --output-format=colorized || exit 1
-        done
-
-        # 生成详细报告
-        echo "📊 生成 Pylint 详细报告..."
-        pylint app/ --output-format=json > pylint-report.json || true
-
-        # 显示评分（仅供参考）
-        echo "📈 Pylint 评分（仅供参考）:"
-        pylint app/ --score=yes --reports=no | tail -2 || true
-
-    - name: Upload pylint report
-      uses: actions/upload-artifact@v4
-      if: always()
-      with:
-        name: pylint-report
-        path: pylint-report.json
-
-    - name: Summary
-      run: |
-        echo "🎉 Pylint 检查完成！"
-        echo "✅ 没有发现语法错误或严重问题"
-        echo "📊 详细报告已保存为构建工件"
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,9 @@
 .idea/
 *.c
-*.so
-*.pyd
 build/
-cython_cache/
 dist/
 nginx/
 test.py
-safety_report.txt
 app/helper/sites.py
 app/helper/*.so
 app/helper/*.pyd
@@ -15,16 +11,9 @@ app/helper/*.bin
 app/plugins/**
 !app/plugins/__init__.py
 config/cookies/**
-config/user.db*
+config/user.db
 config/sites/**
-config/logs/
-config/temp/
-config/cache/
 *.pyc
 *.log
 .vscode
-venv
-
-# Pylint
-pylint-report.json
-.pylint.d/
+venv
--- a/.pylintrc
+++ b/.pylintrc
@@ -1,83 +0,0 @@
-[MASTER]
-# 指定Python路径
-init-hook='import sys; sys.path.append(".")'
-
-# 忽略的文件和目录
-ignore=.git,__pycache__,.venv,build,dist,tests,docs
-
-# 并行作业数量
-jobs=0
-
-[MESSAGES CONTROL]
-# 只关注错误级别的问题，禁用警告、约定和重构建议
-# E = Error (错误) - 会导致构建失败
-# W = Warning (警告) - 仅显示，不会失败
-# R = Refactor (重构建议) - 仅显示，不会失败
-# C = Convention (约定) - 仅显示，不会失败
-# I = Information (信息) - 仅显示，不会失败
-
-# 禁用大部分警告、约定和重构建议，只保留错误和重要警告
-disable=all
-enable=error,
-       syntax-error,
-       undefined-variable,
-       used-before-assignment,
-       unreachable,
-       return-outside-function,
-       yield-outside-function,
-       continue-in-finally,
-       nonlocal-without-binding,
-       undefined-loop-variable,
-       redefined-builtin,
-       not-callable,
-       assignment-from-no-return,
-       no-value-for-parameter,
-       too-many-function-args,
-       unexpected-keyword-arg,
-       redundant-keyword-arg,
-       import-error,
-       relative-beyond-top-level
-
-[REPORTS]
-# 设置报告格式
-output-format=colorized
-reports=yes
-score=yes
-
-[FORMAT]
-# 最大行长度
-max-line-length=120
-# 缩进大小
-indent-string='    '
-
-[DESIGN]
-# 最大参数数量
-max-args=10
-# 最大本地变量数量
-max-locals=20
-# 最大分支数量
-max-branches=15
-# 最大语句数量
-max-statements=50
-# 最大父类数量
-max-parents=7
-# 最大属性数量
-max-attributes=10
-# 最小公共方法数量
-min-public-methods=1
-# 最大公共方法数量
-max-public-methods=25
-
-[SIMILARITIES]
-# 最小相似行数
-min-similarity-lines=6
-# 忽略注释
-ignore-comments=yes
-# 忽略文档字符串
-ignore-docstrings=yes
-# 忽略导入
-ignore-imports=yes
-
-[TYPECHECK]
-# 生成缺失成员提示的类列表
-generated-members=requests.packages.urllib3
--- a/90
+++ b/90
@@ -0,0 +1,90 @@
+FROM python:3.11.4-slim-bookworm
+ARG MOVIEPILOT_VERSION
+ENV LANG="C.UTF-8" \
+    TZ="Asia/Shanghai" \
+    HOME="/moviepilot" \
+    CONFIG_DIR="/config" \
+    TERM="xterm" \
+    PUID=0 \
+    PGID=0 \
+    UMASK=000 \
+    PORT=3001 \
+    NGINX_PORT=3000 \
+    PROXY_HOST="" \
+    MOVIEPILOT_AUTO_UPDATE=release \
+    AUTH_SITE="iyuu" \
+    IYUU_SIGN=""
+WORKDIR "/app"
+RUN apt-get update -y \
+    && apt-get upgrade -y \
+    && apt-get -y install \
+        musl-dev \
+        nginx \
+        gettext-base \
+        locales \
+        procps \
+        gosu \
+        bash \
+        wget \
+        curl \
+        busybox \
+        dumb-init \
+        jq \
+        haproxy \
+        fuse3 \
+        rsync \
+        ffmpeg \
+        nano \
+    && \
+    if [ "$(uname -m)" = "x86_64" ]; \
+        then ln -s /usr/lib/x86_64-linux-musl/libc.so /lib/libc.musl-x86_64.so.1; \
+    elif [ "$(uname -m)" = "aarch64" ]; \
+        then ln -s /usr/lib/aarch64-linux-musl/libc.so /lib/libc.musl-aarch64.so.1; \
+    fi \
+    && curl https://rclone.org/install.sh | bash \
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf \
+        /tmp/* \
+        /moviepilot/.cache \
+        /var/lib/apt/lists/* \
+        /var/tmp/*
+COPY requirements.txt requirements.txt
+RUN apt-get update -y \
+    && apt-get install -y build-essential \
+    && pip install --upgrade pip \
+    && pip install Cython \
+    && pip install -r requirements.txt \
+    && playwright install-deps chromium \
+    && apt-get remove -y build-essential \
+    && apt-get autoremove -y \
+    && apt-get clean -y \
+    && rm -rf \
+        /tmp/* \
+        /moviepilot/.cache \
+        /var/lib/apt/lists/* \
+        /var/tmp/*
+COPY . .
+RUN cp -f /app/nginx.conf /etc/nginx/nginx.template.conf \
+    && cp -f /app/update /usr/local/bin/mp_update \
+    && cp -f /app/entrypoint /entrypoint \
+    && chmod +x /entrypoint /usr/local/bin/mp_update \
+    && mkdir -p ${HOME} /var/lib/haproxy/server-state \
+    && groupadd -r moviepilot -g 911 \
+    && useradd -r moviepilot -g moviepilot -d ${HOME} -s /bin/bash -u 911 \
+    && python_ver=$(python3 -V | awk '{print $2}') \
+    && echo "/app/" > /usr/local/lib/python${python_ver%.*}/site-packages/app.pth \
+    && echo 'fs.inotify.max_user_watches=5242880' >> /etc/sysctl.conf \
+    && echo 'fs.inotify.max_user_instances=5242880' >> /etc/sysctl.conf \
+    && locale-gen zh_CN.UTF-8 \
+    && FRONTEND_VERSION=$(curl -sL "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" | jq -r .tag_name) \
+    && curl -sL "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${FRONTEND_VERSION}/dist.zip" | busybox unzip -d / - \
+    && mv /dist /public \
+    && curl -sL "https://github.com/jxxghp/MoviePilot-Plugins/archive/refs/heads/main.zip" | busybox unzip -d /tmp - \
+    && mv -f /tmp/MoviePilot-Plugins-main/plugins/* /app/app/plugins/ \
+    && curl -sL "https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip" | busybox unzip -d /tmp - \
+    && mv -f /tmp/MoviePilot-Resources-main/resources/* /app/app/helper/ \
+    && rm -rf /tmp/*
+EXPOSE 3000
+VOLUME [ "/config" ]
+ENTRYPOINT [ "/entrypoint" ]
--- a/README.md
+++ b/README.md
@@ -6,7 +6,6 @@
 ![GitHub repo size](https://img.shields.io/github/repo-size/jxxghp/MoviePilot?style=for-the-badge)
 ![GitHub issues](https://img.shields.io/github/issues/jxxghp/MoviePilot?style=for-the-badge)
 ![Docker Pulls](https://img.shields.io/docker/pulls/jxxghp/moviepilot?style=for-the-badge)
-![Docker Pulls V2](https://img.shields.io/docker/pulls/jxxghp/moviepilot-v2?style=for-the-badge)
 ![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20Synology-blue?style=for-the-badge)


@@ -18,60 +17,13 @@

 ## 主要特性

- 前后端分离，基于FastApi + Vue3。
+- 前后端分离，基于FastApi + Vue3，前端项目地址：[MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)，API：http://localhost:3001/docs
 - 聚焦核心需求，简化功能和设置，部分设置项可直接使用默认值。
 - 重新设计了用户界面，更加美观易用。

 ## 安装使用

-官方Wiki：https://wiki.movie-pilot.org
-
-## 参与开发
-
-API文档：https://api.movie-pilot.org
-
-MCP工具API文档：详见 [docs/mcp-api.md](docs/mcp-api.md)
-
-本地运行需要 `Python 3.12`、`Node JS v20.12.1`
-
- 克隆主项目 [MoviePilot](https://github.com/jxxghp/MoviePilot) 
-```shell
-git clone https://github.com/jxxghp/MoviePilot
-```
- 克隆资源项目 [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources) ，将 `resources` 目录下对应平台及版本的库 `.so`/`.pyd`/`.bin` 文件复制到 `app/helper` 目录
-```shell
-git clone https://github.com/jxxghp/MoviePilot-Resources
-```
- 安装后端依赖，运行 `main.py` 启动后端服务，默认监听端口：`3001`，API文档地址：`http://localhost:3001/docs`
-```shell
-cd MoviePilot
-pip install -r requirements.txt
-python3 -m app.main
-```
- 克隆前端项目 [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
-```shell
-git clone https://github.com/jxxghp/MoviePilot-Frontend
-```
- 安装前端依赖，运行前端项目，访问：`http://localhost:5173`
-```shell
-yarn
-yarn dev
-```
- 参考 [插件开发指引](https://wiki.movie-pilot.org/zh/plugindev) 在 `app/plugins` 目录下开发插件代码
-
-## 相关项目
-
- [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
- [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources)
- [MoviePilot-Plugins](https://github.com/jxxghp/MoviePilot-Plugins)
- [MoviePilot-Server](https://github.com/jxxghp/MoviePilot-Server)
- [MoviePilot-Wiki](https://github.com/jxxghp/MoviePilot-Wiki)
-
-## 免责申明
-
- 本软件仅供学习交流使用，任何人不得将本软件用于商业用途，任何人不得将本软件用于违法犯罪活动，软件对用户行为不知情，一切责任由使用者承担。
- 本软件代码开源，基于开源代码进行修改，人为去除相关限制导致软件被分发、传播并造成责任事件的，需由代码修改发布者承担全部责任，不建议对用户认证机制进行规避或修改并公开发布。
- 本项目不接受捐赠，没有在任何地方发布捐赠信息页面，软件本身不收费也不提供任何收费相关服务，请仔细辨别避免误导。
+访问官方Wiki：https://wiki.movie-pilot.org

 ## 贡献者

--- a/app/agent/init.py
+++ b/app/agent/init.py
@@ -1,373 +0,0 @@
-"""MoviePilot AI智能体实现"""
-
-import asyncio
-from typing import Dict, List, Any
-
-from langchain.agents import AgentExecutor, create_openai_tools_agent
-from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_community.callbacks import get_openai_callback
-from langchain_core.chat_history import InMemoryChatMessageHistory
-from langchain_core.messages import HumanMessage, AIMessage, ToolCall
-from langchain_core.runnables.history import RunnableWithMessageHistory
-
-from app.agent.callback import StreamingCallbackHandler
-from app.agent.memory import ConversationMemoryManager
-from app.agent.prompt import PromptManager
-from app.agent.tools.factory import MoviePilotToolFactory
-from app.chain import ChainBase
-from app.core.config import settings
-from app.helper.message import MessageHelper
-from app.log import logger
-from app.schemas import Notification
-
-
-class AgentChain(ChainBase):
-    pass
-
-
-class MoviePilotAgent:
-    """MoviePilot AI智能体"""
-
-    def __init__(self, session_id: str, user_id: str = None,
-                 channel: str = None, source: str = None, username: str = None):
-        self.session_id = session_id
-        self.user_id = user_id
-        self.channel = channel  # 消息渠道
-        self.source = source  # 消息来源
-        self.username = username  # 用户名
-
-        # 消息助手
-        self.message_helper = MessageHelper()
-
-        # 记忆管理器
-        self.memory_manager = ConversationMemoryManager()
-
-        # 提示词管理器
-        self.prompt_manager = PromptManager()
-
-        # 回调处理器
-        self.callback_handler = StreamingCallbackHandler(
-            session_id=session_id
-        )
-
-        # LLM模型
-        self.llm = self._initialize_llm()
-
-        # 工具
-        self.tools = self._initialize_tools()
-
-        # 会话存储
-        self.session_store = self._initialize_session_store()
-
-        # 提示词模板
-        self.prompt = self._initialize_prompt()
-
-        # Agent执行器
-        self.agent_executor = self._create_agent_executor()
-
-    def _initialize_llm(self):
-        """初始化LLM模型"""
-        provider = settings.LLM_PROVIDER.lower()
-        api_key = settings.LLM_API_KEY
-
-        if provider == "google":
-            if settings.PROXY_HOST:
-                from langchain_openai import ChatOpenAI
-                return ChatOpenAI(
-                    model=settings.LLM_MODEL,
-                    api_key=api_key,
-                    max_retries=3,
-                    base_url="https://generativelanguage.googleapis.com/v1beta/openai",
-                    temperature=settings.LLM_TEMPERATURE,
-                    streaming=True,
-                    callbacks=[self.callback_handler],
-                    stream_usage=True,
-                    openai_proxy=settings.PROXY_HOST
-                )
-            else:
-                from langchain_google_genai import ChatGoogleGenerativeAI
-                return ChatGoogleGenerativeAI(
-                    model=settings.LLM_MODEL,
-                    google_api_key=api_key,
-                    max_retries=3,
-                    temperature=settings.LLM_TEMPERATURE,
-                    streaming=True,
-                    callbacks=[self.callback_handler]
-                )
-        elif provider == "deepseek":
-            from langchain_deepseek import ChatDeepSeek
-            return ChatDeepSeek(
-                model=settings.LLM_MODEL,
-                api_key=api_key,
-                max_retries=3,
-                temperature=settings.LLM_TEMPERATURE,
-                streaming=True,
-                callbacks=[self.callback_handler],
-                stream_usage=True
-            )
-        else:
-            from langchain_openai import ChatOpenAI
-            return ChatOpenAI(
-                model=settings.LLM_MODEL,
-                api_key=api_key,
-                max_retries=3,
-                base_url=settings.LLM_BASE_URL,
-                temperature=settings.LLM_TEMPERATURE,
-                streaming=True,
-                callbacks=[self.callback_handler],
-                stream_usage=True,
-                openai_proxy=settings.PROXY_HOST
-            )
-
-    def _initialize_tools(self) -> List:
-        """初始化工具列表"""
-        return MoviePilotToolFactory.create_tools(
-            session_id=self.session_id,
-            user_id=self.user_id,
-            channel=self.channel,
-            source=self.source,
-            username=self.username,
-            callback_handler=self.callback_handler
-        )
-
-    @staticmethod
-    def _initialize_session_store() -> Dict[str, InMemoryChatMessageHistory]:
-        """初始化内存存储"""
-        return {}
-
-    def get_session_history(self, session_id: str) -> InMemoryChatMessageHistory:
-        """获取会话历史"""
-        if session_id not in self.session_store:
-            chat_history = InMemoryChatMessageHistory()
-            messages: List[dict] = self.memory_manager.get_recent_messages_for_agent(
-                session_id=session_id,
-                user_id=self.user_id
-            )
-            if messages:
-                for msg in messages:
-                    if msg.get("role") == "user":
-                        chat_history.add_user_message(HumanMessage(content=msg.get("content", "")))
-                    elif msg.get("role") == "agent":
-                        chat_history.add_ai_message(AIMessage(content=msg.get("content", "")))
-                    elif msg.get("role") == "tool_call":
-                        metadata = msg.get("metadata", {})
-                        chat_history.add_ai_message(AIMessage(
-                            content=msg.get("content", ""),
-                            tool_calls=[ToolCall(
-                                id=metadata.get("call_id"),
-                                name=metadata.get("tool_name"),
-                                args=metadata.get("parameters"),
-                            )]
-                        ))
-                    elif msg.get("role") == "tool_result":
-                        chat_history.add_ai_message(AIMessage(content=msg.get("content", "")))
-                    elif msg.get("role") == "system":
-                        chat_history.add_ai_message(AIMessage(content=msg.get("content", "")))
-            self.session_store[session_id] = chat_history
-        return self.session_store[session_id]
-
-    @staticmethod
-    def _initialize_prompt() -> ChatPromptTemplate:
-        """初始化提示词模板"""
-        try:
-            prompt_template = ChatPromptTemplate.from_messages([
-                ("system", "{system_prompt}"),
-                MessagesPlaceholder(variable_name="chat_history"),
-                ("user", "{input}"),
-                MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ])
-            logger.info("LangChain提示词模板初始化成功")
-            return prompt_template
-        except Exception as e:
-            logger.error(f"初始化提示词失败: {e}")
-            raise e
-
-    def _create_agent_executor(self) -> RunnableWithMessageHistory:
-        """创建Agent执行器"""
-        try:
-            agent = create_openai_tools_agent(
-                llm=self.llm,
-                tools=self.tools,
-                prompt=self.prompt
-            )
-            executor = AgentExecutor(
-                agent=agent,
-                tools=self.tools,
-                verbose=settings.LLM_VERBOSE,
-                max_iterations=settings.LLM_MAX_ITERATIONS,
-                return_intermediate_steps=True,
-                handle_parsing_errors=True,
-                early_stopping_method="force"
-            )
-            return RunnableWithMessageHistory(
-                executor,
-                self.get_session_history,
-                input_messages_key="input",
-                history_messages_key="chat_history"
-            )
-        except Exception as e:
-            logger.error(f"创建Agent执行器失败: {e}")
-            raise e
-
-    async def process_message(self, message: str) -> str:
-        """处理用户消息"""
-        try:
-            # 添加用户消息到记忆
-            await self.memory_manager.add_memory(
-                self.session_id,
-                user_id=self.user_id,
-                role="user",
-                content=message
-            )
-
-            # 构建输入上下文
-            input_context = {
-                "system_prompt": self.prompt_manager.get_agent_prompt(channel=self.channel),
-                "input": message
-            }
-
-            # 执行Agent
-            logger.info(f"Agent执行推理: session_id={self.session_id}, input={message}")
-            await self._execute_agent(input_context)
-
-            # 获取Agent回复
-            agent_message = await self.callback_handler.get_message()
-
-            # 发送Agent回复给用户（通过原渠道）
-            if agent_message:
-                # 发送回复
-                await self.send_agent_message(agent_message)
-
-                # 添加Agent回复到记忆
-                await self.memory_manager.add_memory(
-                    session_id=self.session_id,
-                    user_id=self.user_id,
-                    role="agent",
-                    content=agent_message
-                )
-            else:
-                agent_message = "很抱歉，智能体出错了，未能生成回复内容。"
-                await self.send_agent_message(agent_message)
-
-            return agent_message
-
-        except Exception as e:
-            error_message = f"处理消息时发生错误: {str(e)}"
-            logger.error(error_message)
-            # 发送错误消息给用户（通过原渠道）
-            await self.send_agent_message(error_message)
-            return error_message
-
-    async def _execute_agent(self, input_context: Dict[str, Any]) -> Dict[str, Any]:
-        """执行LangChain Agent"""
-        try:
-            with get_openai_callback() as cb:
-                result = await self.agent_executor.ainvoke(
-                    input_context,
-                    config={"configurable": {"session_id": self.session_id}},
-                    callbacks=[self.callback_handler]
-                )
-                logger.info(f"LLM调用消耗: \n{cb}")
-
-                if cb.total_tokens > 0:
-                    result["token_usage"] = {
-                        "prompt_tokens": cb.prompt_tokens,
-                        "completion_tokens": cb.completion_tokens,
-                        "total_tokens": cb.total_tokens
-                    }
-            return result
-        except asyncio.CancelledError:
-            logger.info(f"Agent执行被取消: session_id={self.session_id}")
-            return {
-                "output": "任务已取消",
-                "intermediate_steps": [],
-                "token_usage": {}
-            }
-        except Exception as e:
-            logger.error(f"Agent执行失败: {e}")
-            return {
-                "output": f"执行过程中发生错误: {str(e)}",
-                "intermediate_steps": [],
-                "token_usage": {}
-            }
-
-    async def send_agent_message(self, message: str, title: str = "MoviePilot助手"):
-        """通过原渠道发送消息给用户"""
-        await AgentChain().async_post_message(
-            Notification(
-                channel=self.channel,
-                source=self.source,
-                userid=self.user_id,
-                username=self.username,
-                title=title,
-                text=message
-            )
-        )
-
-    async def cleanup(self):
-        """清理智能体资源"""
-        if self.session_id in self.session_store:
-            del self.session_store[self.session_id]
-        logger.info(f"MoviePilot智能体已清理: session_id={self.session_id}")
-
-
-class AgentManager:
-    """AI智能体管理器"""
-
-    def __init__(self):
-        self.active_agents: Dict[str, MoviePilotAgent] = {}
-        self.memory_manager = ConversationMemoryManager()
-
-    async def initialize(self):
-        """初始化管理器"""
-        await self.memory_manager.initialize()
-
-    async def close(self):
-        """关闭管理器"""
-        await self.memory_manager.close()
-        # 清理所有活跃的智能体
-        for agent in self.active_agents.values():
-            await agent.cleanup()
-        self.active_agents.clear()
-
-    async def process_message(self, session_id: str, user_id: str, message: str,
-                              channel: str = None, source: str = None, username: str = None) -> str:
-        """处理用户消息"""
-        # 获取或创建Agent实例
-        if session_id not in self.active_agents:
-            logger.info(f"创建新的AI智能体实例，session_id: {session_id}, user_id: {user_id}")
-            agent = MoviePilotAgent(
-                session_id=session_id,
-                user_id=user_id,
-                channel=channel,
-                source=source,
-                username=username
-            )
-            agent.memory_manager = self.memory_manager
-            self.active_agents[session_id] = agent
-        else:
-            agent = self.active_agents[session_id]
-            agent.user_id = user_id  # 确保user_id是最新的
-            # 更新渠道信息
-            if channel:
-                agent.channel = channel
-            if source:
-                agent.source = source
-            if username:
-                agent.username = username
-
-        # 处理消息
-        return await agent.process_message(message)
-
-    async def clear_session(self, session_id: str, user_id: str):
-        """清空会话"""
-        if session_id in self.active_agents:
-            agent = self.active_agents[session_id]
-            await agent.cleanup()
-            del self.active_agents[session_id]
-            await self.memory_manager.clear_memory(session_id, user_id)
-            logger.info(f"会话 {session_id} 的记忆已清空")
-
-
-# 全局智能体管理器实例
-agent_manager = AgentManager()
--- a/app/agent/callback/init.py
+++ b/app/agent/callback/init.py
@@ -1,33 +0,0 @@
-import threading
-
-from langchain_core.callbacks import AsyncCallbackHandler
-
-from app.log import logger
-
-
-class StreamingCallbackHandler(AsyncCallbackHandler):
-    """流式输出回调处理器"""
-
-    def __init__(self, session_id: str):
-        self._lock = threading.Lock()
-        self.session_id = session_id
-        self.current_message = ""
-
-    async def get_message(self):
-        """获取当前消息内容，获取后清空"""
-        with self._lock:
-            if not self.current_message:
-                return ""
-            msg = self.current_message
-            logger.info(f"Agent消息: {msg}")
-            self.current_message = ""
-            return msg
-
-    async def on_llm_new_token(self, token: str, **kwargs):
-        """处理新的token"""
-        if not token:
-            return
-        with self._lock:
-            # 缓存当前消息
-            self.current_message += token
-
--- a/app/agent/memory/init.py
+++ b/app/agent/memory/init.py
@@ -1,280 +0,0 @@
-"""对话记忆管理器"""
-
-import asyncio
-import json
-from datetime import datetime, timedelta
-from typing import Dict, List, Optional, Any
-
-from app.core.config import settings
-from app.helper.redis import AsyncRedisHelper
-from app.log import logger
-from app.schemas.agent import ConversationMemory
-
-
-class ConversationMemoryManager:
-    """对话记忆管理器"""
-
-    def __init__(self):
-        # 内存中的会话记忆缓存
-        self.memory_cache: Dict[str, ConversationMemory] = {}
-        # 使用现有的Redis助手
-        self.redis_helper = AsyncRedisHelper()
-        # 内存缓存清理任务（Redis通过TTL自动过期）
-        self.cleanup_task: Optional[asyncio.Task] = None
-
-    async def initialize(self):
-        """初始化记忆管理器"""
-        try:
-            # 启动内存缓存清理任务（Redis通过TTL自动过期）
-            self.cleanup_task = asyncio.create_task(self._cleanup_expired_memories())
-            logger.info("对话记忆管理器初始化完成")
-
-        except Exception as e:
-            logger.warning(f"Redis连接失败，将使用内存存储: {e}")
-
-    async def close(self):
-        """关闭记忆管理器"""
-        if self.cleanup_task:
-            self.cleanup_task.cancel()
-            try:
-                await self.cleanup_task
-            except asyncio.CancelledError:
-                pass
-
-        await self.redis_helper.close()
-
-        logger.info("对话记忆管理器已关闭")
-
-    async def get_memory(self, session_id: str, user_id: str) -> ConversationMemory:
-        """获取会话记忆"""
-        # 首先检查缓存
-        cache_key = f"{user_id}:{session_id}" if user_id else session_id
-        if cache_key in self.memory_cache:
-            return self.memory_cache[cache_key]
-
-        # 尝试从Redis加载
-        if settings.CACHE_BACKEND_TYPE == "redis":
-            try:
-                redis_key = f"agent_memory:{user_id}:{session_id}" if user_id else f"agent_memory:{session_id}"
-                memory_data = await self.redis_helper.get(redis_key, region="AI_AGENT")
-                if memory_data:
-                    memory_dict = json.loads(memory_data) if isinstance(memory_data, str) else memory_data
-                    memory = ConversationMemory(**memory_dict)
-                    self.memory_cache[cache_key] = memory
-                    return memory
-            except Exception as e:
-                logger.warning(f"从Redis加载记忆失败: {e}")
-
-        # 创建新的记忆
-        memory = ConversationMemory(session_id=session_id, user_id=user_id)
-        self.memory_cache[cache_key] = memory
-        await self._save_memory(memory)
-
-        return memory
-
-    async def set_title(self, session_id: str, user_id: str, title: str):
-        """设置会话标题"""
-        memory = await self.get_memory(session_id=session_id, user_id=user_id)
-        memory.title = title
-        memory.updated_at = datetime.now()
-        await self._save_memory(memory)
-
-    async def get_title(self, session_id: str, user_id: str) -> Optional[str]:
-        """获取会话标题"""
-        memory = await self.get_memory(session_id=session_id, user_id=user_id)
-        return memory.title
-
-    async def list_sessions(self, user_id: str, limit: int = 100) -> List[Dict[str, Any]]:
-        """列出历史会话摘要（按更新时间倒序）
-
-        - 当启用Redis时：遍历 `agent_memory:*` 键并读取摘要
-        - 当未启用Redis时：基于内存缓存返回
-        """
-        sessions: List[ConversationMemory] = []
-        # 从Redis遍历
-        if settings.CACHE_BACKEND_TYPE == "redis":
-            try:
-                # 使用Redis助手的items方法遍历所有键
-                async for key, value in self.redis_helper.items(region="AI_AGENT"):
-                    if key.startswith("agent_memory:"):
-                        try:
-                            # 解析键名获取user_id和session_id
-                            key_parts = key.split(":")
-                            if len(key_parts) >= 3:
-                                key_user_id = key_parts[2] if len(key_parts) > 3 else None
-                                if not user_id or key_user_id == user_id:
-                                    data = value if isinstance(value, dict) else json.loads(value)
-                                    memory = ConversationMemory(**data)
-                                    sessions.append(memory)
-                        except Exception as err:
-                            logger.warning(f"解析Redis记忆数据失败: {err}")
-                            continue
-            except Exception as e:
-                logger.warning(f"遍历Redis会话失败: {e}")
-
-        # 合并内存缓存（确保包含近期的会话）
-        for cache_key, memory in self.memory_cache.items():
-            # 如果指定了user_id，只返回该用户的会话
-            if not user_id or memory.user_id == user_id:
-                sessions.append(memory)
-
-        # 去重（以 session_id 为键，取最近updated）
-        uniq: Dict[str, ConversationMemory] = {}
-        for mem in sessions:
-            existed = uniq.get(mem.session_id)
-            if (not existed) or (mem.updated_at > existed.updated_at):
-                uniq[mem.session_id] = mem
-
-        # 排序并裁剪
-        sorted_list = sorted(uniq.values(), key=lambda m: m.updated_at, reverse=True)[:limit]
-        return [
-            {
-                "session_id": m.session_id,
-                "title": m.title or "新会话",
-                "message_count": len(m.messages),
-                "created_at": m.created_at.isoformat(),
-                "updated_at": m.updated_at.isoformat(),
-            }
-            for m in sorted_list
-        ]
-
-    async def add_memory(
-            self,
-            session_id: str,
-            user_id: str,
-            role: str,
-            content: str,
-            metadata: Optional[Dict[str, Any]] = None
-    ):
-        """添加消息到记忆"""
-        memory = await self.get_memory(session_id=session_id, user_id=user_id)
-
-        message = {
-            "role": role,
-            "content": content,
-            "timestamp": datetime.now().isoformat(),
-            "metadata": metadata or {}
-        }
-
-        memory.messages.append(message)
-        memory.updated_at = datetime.now()
-
-        # 限制消息数量，避免记忆过大
-        max_messages = settings.LLM_MAX_MEMORY_MESSAGES
-        if len(memory.messages) > max_messages:
-            # 保留最近的消息，但保留第一条系统消息
-            system_messages = [msg for msg in memory.messages if msg["role"] == "system"]
-            recent_messages = memory.messages[-(max_messages - len(system_messages)):]
-            memory.messages = system_messages + recent_messages
-
-        await self._save_memory(memory)
-
-        logger.debug(f"消息已添加到记忆: session_id={session_id}, user_id={user_id}, role={role}")
-
-    def get_recent_messages_for_agent(
-            self,
-            session_id: str,
-            user_id: str
-    ) -> List[Dict[str, Any]]:
-        """为Agent获取最近的消息（仅内存缓存）
-
-        如果消息Token数量超过模型最大上下文长度的阀值，会自动进行摘要裁剪
-        """
-        cache_key = f"{user_id}:{session_id}" if user_id else session_id
-        memory = self.memory_cache.get(cache_key)
-        if not memory:
-            return []
-
-        # 获取所有消息
-        messages = memory.messages
-
-        return messages
-
-    async def get_recent_messages(
-            self,
-            session_id: str,
-            user_id: str,
-            limit: int = 10,
-            role_filter: Optional[list] = None
-    ) -> List[Dict[str, Any]]:
-        """获取最近的消息"""
-        memory = await self.get_memory(session_id=session_id, user_id=user_id)
-
-        messages = memory.messages
-        if role_filter:
-            messages = [msg for msg in messages if msg["role"] in role_filter]
-
-        return messages[-limit:] if messages else []
-
-    async def get_context(self, session_id: str, user_id: str) -> Dict[str, Any]:
-        """获取会话上下文"""
-        memory = await self.get_memory(session_id=session_id, user_id=user_id)
-        return memory.context
-
-    async def clear_memory(self, session_id: str, user_id: str):
-        """清空会话记忆"""
-        cache_key = f"{user_id}:{session_id}" if user_id else session_id
-        if cache_key in self.memory_cache:
-            del self.memory_cache[cache_key]
-
-        if settings.CACHE_BACKEND_TYPE == "redis":
-            redis_key = f"agent_memory:{user_id}:{session_id}" if user_id else f"agent_memory:{session_id}"
-            await self.redis_helper.delete(redis_key, region="AI_AGENT")
-
-        logger.info(f"会话记忆已清空: session_id={session_id}, user_id={user_id}")
-
-    async def _save_memory(self, memory: ConversationMemory):
-        """保存记忆到存储
-
-        Redis中的记忆会自动通过TTL机制过期，无需手动清理
-        """
-        # 更新内存缓存
-        cache_key = f"{memory.user_id}:{memory.session_id}" if memory.user_id else memory.session_id
-        self.memory_cache[cache_key] = memory
-
-        # 保存到Redis，设置TTL自动过期
-        if settings.CACHE_BACKEND_TYPE == "redis":
-            try:
-                memory_dict = memory.model_dump()
-                redis_key = f"agent_memory:{memory.user_id}:{memory.session_id}" if memory.user_id else f"agent_memory:{memory.session_id}"
-                ttl = int(timedelta(days=settings.LLM_REDIS_MEMORY_RETENTION_DAYS).total_seconds())
-                await self.redis_helper.set(
-                    redis_key,
-                    memory_dict,
-                    ttl=ttl,
-                    region="AI_AGENT"
-                )
-            except Exception as e:
-                logger.warning(f"保存记忆到Redis失败: {e}")
-
-    async def _cleanup_expired_memories(self):
-        """清理内存中过期记忆的后台任务
-
-        注意：Redis中的记忆通过TTL机制自动过期，这里只清理内存缓存
-        """
-        while True:
-            try:
-                # 每小时清理一次
-                await asyncio.sleep(3600)
-
-                current_time = datetime.now()
-                expired_sessions = []
-
-                # 只检查内存缓存中的过期记忆
-                # Redis中的记忆会通过TTL自动过期，无需手动处理
-                for cache_key, memory in self.memory_cache.items():
-                    if (current_time - memory.updated_at).days > settings.LLM_MEMORY_RETENTION_DAYS:
-                        expired_sessions.append(cache_key)
-
-                # 只清理内存缓存，不删除Redis中的键（Redis会自动过期）
-                for cache_key in expired_sessions:
-                    if cache_key in self.memory_cache:
-                        del self.memory_cache[cache_key]
-
-                if expired_sessions:
-                    logger.info(f"清理了{len(expired_sessions)}个过期内存会话记忆")
-
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.error(f"清理记忆时发生错误: {e}")
--- a/app/agent/prompt/Agent
+++ b/app/agent/prompt/Agent
@@ -1,70 +0,0 @@
-You are MoviePilot's AI assistant, specialized in helping users manage media resources including subscriptions, searching, downloading, and organization.
-
-## Your Identity and Capabilities
-
-You are an AI agent for the MoviePilot media management system with the following core capabilities:
-
-### Media Management Capabilities
- **Search Media Resources**: Search for movies, TV shows, anime, and other media content based on user requirements
- **Add Subscriptions**: Create subscription rules for media content that users are interested in
- **Manage Downloads**: Search and add torrent resources to downloaders
- **Query Status**: Check subscription status, download progress, and media library status
-
-### Intelligent Interaction Capabilities
- **Natural Language Understanding**: Understand user requests in natural language (Chinese/English)
- **Context Memory**: Remember conversation history and user preferences
- **Smart Recommendations**: Recommend related media content based on user preferences
- **Task Execution**: Automatically execute complex media management tasks
-
-## Working Principles
-
-1. **Always respond in Chinese**: All responses must be in Chinese
-2. **Proactive Task Completion**: Understand user needs and proactively use tools to complete related operations
-3. **Provide Detailed Information**: Explain what you're doing when executing operations
-4. **Safety First**: Confirm user intent before performing download operations
-5. **Continuous Learning**: Remember user preferences and habits to provide personalized service
-
-## Common Operation Workflows
-
-### Add Subscription Workflow
-1. Understand the media content the user wants to subscribe to
-2. Search for related media information
-3. Create subscription rules
-4. Confirm successful subscription
-
-### Search and Download Workflow
-1. Understand user requirements (movie names, TV show names, etc.)
-2. Search for related media information
-3. Search for related torrent resources by media info
-4. Filter suitable resources
-5. Add to downloader
-
-### Query Status Workflow
-1. Understand what information the user wants to know
-2. Query related data
-3. Organize and present results
-
-## Tool Usage Guidelines
-
-### Tool Usage Principles
- Use tools proactively to complete user requests
- Always explain what you're doing when using tools
- Provide detailed results and explanations
- Handle errors gracefully and suggest alternatives
- Confirm user intent before performing download operations
-
-### Response Format
- Always respond in Chinese
- Use clear and friendly language
- Provide structured information when appropriate
- Include relevant details about media content (title, year, type, etc.)
- Explain the results of tool operations clearly
-
-## Important Notes
-
- Always confirm user intent before performing download operations
- If search results are not ideal, proactively adjust search strategies
- Maintain a friendly and professional tone
- Seek solutions proactively when encountering problems
- Remember user preferences and provide personalized recommendations
- Handle errors gracefully and provide helpful suggestions
--- a/app/agent/prompt/init.py
+++ b/app/agent/prompt/init.py
@@ -1,118 +0,0 @@
-"""提示词管理器"""
-
-from pathlib import Path
-from typing import Dict
-
-from app.log import logger
-
-
-class PromptManager:
-    """提示词管理器"""
-
-    def __init__(self, prompts_dir: str = None):
-        if prompts_dir is None:
-            self.prompts_dir = Path(__file__).parent
-        else:
-            self.prompts_dir = Path(prompts_dir)
-        self.prompts_cache: Dict[str, str] = {}
-
-    def load_prompt(self, prompt_name: str) -> str:
-        """加载指定的提示词"""
-        if prompt_name in self.prompts_cache:
-            return self.prompts_cache[prompt_name]
-
-        prompt_file = self.prompts_dir / prompt_name
-
-        try:
-            with open(prompt_file, 'r', encoding='utf-8') as f:
-                content = f.read().strip()
-
-            # 缓存提示词
-            self.prompts_cache[prompt_name] = content
-
-            logger.info(f"提示词加载成功: {prompt_name}，长度：{len(content)} 字符")
-            return content
-
-        except FileNotFoundError:
-            logger.error(f"提示词文件不存在: {prompt_file}")
-            raise
-        except Exception as e:
-            logger.error(f"加载提示词失败: {prompt_name}, 错误: {e}")
-            raise
-
-    def get_agent_prompt(self, channel: str = None) -> str:
-        """
-        获取智能体提示词
-        :param channel: 消息渠道（Telegram、微信、Slack等）
-        :return: 提示词内容
-        """
-        base_prompt = self.load_prompt("Agent Prompt.txt")
-        
-        # 根据渠道添加特定的格式说明
-        if channel:
-            channel_format_info = self._get_channel_format_info(channel)
-            if channel_format_info:
-                base_prompt += f"\n\n## Current Message Channel Format Requirements\n\n{channel_format_info}"
-        
-        return base_prompt
-    
-    @staticmethod
-    def _get_channel_format_info(channel: str) -> str:
-        """
-        获取渠道特定的格式说明
-        :param channel: 消息渠道
-        :return: 格式说明文本
-        """
-        channel_lower = channel.lower() if channel else ""
-        
-        if "telegram" in channel_lower:
-            return """Messages are being sent through the **Telegram** channel. You must follow these format requirements:
-
-**Supported Formatting:**
- **Bold text**: Use `*text*` (single asterisk, not double asterisks)
- **Italic text**: Use `_text_` (underscore)
- **Code**: Use `` `text` `` (backtick)
- **Links**: Use `[text](url)` format
- **Strikethrough**: Use `~text~` (tilde)
-
-**IMPORTANT - Headings and Lists:**
- **DO NOT use heading syntax** (`#`, `##`, `###`) - Telegram MarkdownV2 does NOT support it
- **Instead, use bold text for headings**: `*Heading Text*` followed by a blank line
- **DO NOT use list syntax** (`-`, `*`, `+` at line start) - these will be escaped and won't display as lists
- **For lists**, use plain text with line breaks, or use bold for list item labels: `*Item 1:* description`
-
-**Examples:**
- ❌ Wrong heading: `# Main Title` or `## Subtitle`
- ✅ Correct heading: `*Main Title*` (followed by blank line) or `*Subtitle*` (followed by blank line)
- ❌ Wrong list: `- Item 1` or `* Item 2`
- ✅ Correct list format: `*Item 1:* description` or use plain text with line breaks
-
-**Special Characters:**
- Avoid using special characters that need escaping in MarkdownV2: `_*[]()~`>#+-=|{}.!` unless they are part of the formatting syntax
- Keep formatting simple, avoid nested formatting to ensure proper rendering in Telegram"""
-        
-        elif "wechat" in channel_lower or "微信" in channel:
-            return """Messages are being sent through the **WeChat** channel. Please follow these format requirements:
-
- WeChat does NOT support Markdown formatting. Use plain text format only.
- Do NOT use any Markdown syntax (such as `**bold**`, `*italic*`, `` `code` `` etc.)
- Use plain text descriptions. You can organize content using line breaks and punctuation
- Links can be provided directly as URLs, no Markdown link format needed
- Keep messages concise and clear, use natural Chinese expressions"""
-        
-        elif "slack" in channel_lower:
-            return """Messages are being sent through the **Slack** channel. Please follow these format requirements:
-
- Slack supports Markdown formatting
- Use `*text*` for bold
- Use `_text_` for italic
- Use `` `text` `` for code
- Link format: `<url|text>` or `[text](url)`"""
-        
-        # 其他渠道使用标准Markdown
-        return None
-
-    def clear_cache(self):
-        """清空缓存"""
-        self.prompts_cache.clear()
-        logger.info("提示词缓存已清空")
--- a/app/agent/tools/init.py
+++ b/app/agent/tools/init.py
--- a/app/agent/tools/base.py
+++ b/app/agent/tools/base.py
@@ -1,98 +0,0 @@
-"""MoviePilot工具基类"""
-from abc import ABCMeta, abstractmethod
-from typing import Callable, Any, Optional
-
-from langchain.tools import BaseTool
-from pydantic import PrivateAttr
-
-from app.agent import StreamingCallbackHandler
-from app.chain import ChainBase
-from app.log import logger
-from app.schemas import Notification
-
-
-class ToolChain(ChainBase):
-    pass
-
-
-class MoviePilotTool(BaseTool, metaclass=ABCMeta):
-    """MoviePilot专用工具基类"""
-
-    _session_id: str = PrivateAttr()
-    _user_id: str = PrivateAttr()
-    _channel: str = PrivateAttr(default=None)
-    _source: str = PrivateAttr(default=None)
-    _username: str = PrivateAttr(default=None)
-    _callback_handler: StreamingCallbackHandler = PrivateAttr(default=None)
-
-    def __init__(self, session_id: str, user_id: str, **kwargs):
-        super().__init__(**kwargs)
-        self._session_id = session_id
-        self._user_id = user_id
-
-    def _run(self, *args: Any, **kwargs: Any) -> Any:
-        pass
-
-    async def _arun(self, **kwargs) -> str:
-        """异步运行工具"""
-        # 发送运行工具前的消息
-        agent_message = await self._callback_handler.get_message()
-        if agent_message:
-            await self.send_tool_message(agent_message, title="MoviePilot助手")
-        # 发送执行工具说明
-        # 优先使用工具自定义的提示消息，如果没有则使用 explanation
-        tool_message = self.get_tool_message(**kwargs)
-        if not tool_message:
-            explanation = kwargs.get("explanation")
-            if explanation:
-                tool_message = explanation
-        
-        if tool_message:
-            formatted_message = f"⚙️ => {tool_message}"
-            await self.send_tool_message(formatted_message)
-        logger.debug(f'Executing tool {self.name} with args: {kwargs}')
-        result = await self.run(**kwargs)
-        logger.debug(f'Tool {self.name} executed with result: {result}')
-        return result
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """
-        获取工具执行时的友好提示消息
-        
-        子类可以重写此方法，根据实际参数生成个性化的提示消息。
-        如果返回 None 或空字符串，将回退使用 explanation 参数。
-        
-        Args:
-            **kwargs: 工具的所有参数（包括 explanation）
-            
-        Returns:
-            str: 友好的提示消息，如果返回 None 或空字符串则使用 explanation
-        """
-        return None
-
-    @abstractmethod
-    async def run(self, **kwargs) -> str:
-        raise NotImplementedError
-
-    def set_message_attr(self, channel: str, source: str, username: str):
-        """设置消息属性"""
-        self._channel = channel
-        self._source = source
-        self._username = username
-
-    def set_callback_handler(self, callback_handler: StreamingCallbackHandler):
-        """设置回调处理器"""
-        self._callback_handler = callback_handler
-
-    async def send_tool_message(self, message: str, title: str = ""):
-        """发送工具消息"""
-        await ToolChain().async_post_message(
-            Notification(
-                channel=self._channel,
-                source=self._source,
-                userid=self._user_id,
-                username=self._username,
-                title=title,
-                text=message
-            )
-        )
--- a/app/agent/tools/factory.py
+++ b/app/agent/tools/factory.py
@@ -1,138 +0,0 @@
-"""MoviePilot工具工厂"""
-
-from typing import List, Callable
-
-from app.agent.tools.impl.add_download import AddDownloadTool
-from app.agent.tools.impl.add_subscribe import AddSubscribeTool
-from app.agent.tools.impl.update_subscribe import UpdateSubscribeTool
-from app.agent.tools.impl.search_subscribe import SearchSubscribeTool
-from app.agent.tools.impl.get_recommendations import GetRecommendationsTool
-from app.agent.tools.impl.query_downloaders import QueryDownloadersTool
-from app.agent.tools.impl.query_download_tasks import QueryDownloadTasksTool
-from app.agent.tools.impl.query_library_exists import QueryLibraryExistsTool
-from app.agent.tools.impl.query_library_latest import QueryLibraryLatestTool
-from app.agent.tools.impl.query_sites import QuerySitesTool
-from app.agent.tools.impl.update_site import UpdateSiteTool
-from app.agent.tools.impl.query_site_userdata import QuerySiteUserdataTool
-from app.agent.tools.impl.test_site import TestSiteTool
-from app.agent.tools.impl.query_subscribes import QuerySubscribesTool
-from app.agent.tools.impl.query_subscribe_shares import QuerySubscribeSharesTool
-from app.agent.tools.impl.query_rule_groups import QueryRuleGroupsTool
-from app.agent.tools.impl.query_popular_subscribes import QueryPopularSubscribesTool
-from app.agent.tools.impl.query_subscribe_history import QuerySubscribeHistoryTool
-from app.agent.tools.impl.delete_subscribe import DeleteSubscribeTool
-from app.agent.tools.impl.search_media import SearchMediaTool
-from app.agent.tools.impl.search_person import SearchPersonTool
-from app.agent.tools.impl.search_person_credits import SearchPersonCreditsTool
-from app.agent.tools.impl.recognize_media import RecognizeMediaTool
-from app.agent.tools.impl.scrape_metadata import ScrapeMetadataTool
-from app.agent.tools.impl.query_episode_schedule import QueryEpisodeScheduleTool
-from app.agent.tools.impl.search_torrents import SearchTorrentsTool
-from app.agent.tools.impl.search_web import SearchWebTool
-from app.agent.tools.impl.send_message import SendMessageTool
-from app.agent.tools.impl.query_schedulers import QuerySchedulersTool
-from app.agent.tools.impl.run_scheduler import RunSchedulerTool
-from app.agent.tools.impl.query_workflows import QueryWorkflowsTool
-from app.agent.tools.impl.run_workflow import RunWorkflowTool
-from app.agent.tools.impl.update_site_cookie import UpdateSiteCookieTool
-from app.agent.tools.impl.delete_download import DeleteDownloadTool
-from app.agent.tools.impl.query_directory_settings import QueryDirectorySettingsTool
-from app.agent.tools.impl.list_directory import ListDirectoryTool
-from app.agent.tools.impl.query_transfer_history import QueryTransferHistoryTool
-from app.agent.tools.impl.transfer_file import TransferFileTool
-from app.core.plugin import PluginManager
-from app.log import logger
-from .base import MoviePilotTool
-
-
-class MoviePilotToolFactory:
-    """MoviePilot工具工厂"""
-
-    @staticmethod
-    def create_tools(session_id: str, user_id: str,
-                     channel: str = None, source: str = None, username: str = None,
-                     callback_handler: Callable = None) -> List[MoviePilotTool]:
-        """创建MoviePilot工具列表"""
-        tools = []
-        tool_definitions = [
-            SearchMediaTool,
-            SearchPersonTool,
-            SearchPersonCreditsTool,
-            RecognizeMediaTool,
-            ScrapeMetadataTool,
-            QueryEpisodeScheduleTool,
-            AddSubscribeTool,
-            UpdateSubscribeTool,
-            SearchSubscribeTool,
-            SearchTorrentsTool,
-            SearchWebTool,
-            AddDownloadTool,
-            QuerySubscribesTool,
-            QuerySubscribeSharesTool,
-            QueryPopularSubscribesTool,
-            QueryRuleGroupsTool,
-            QuerySubscribeHistoryTool,
-            DeleteSubscribeTool,
-            QueryDownloadTasksTool,
-            DeleteDownloadTool,
-            QueryDownloadersTool,
-            QuerySitesTool,
-            UpdateSiteTool,
-            QuerySiteUserdataTool,
-            TestSiteTool,
-            UpdateSiteCookieTool,
-            GetRecommendationsTool,
-            QueryLibraryExistsTool,
-            QueryLibraryLatestTool,
-            QueryDirectorySettingsTool,
-            ListDirectoryTool,
-            QueryTransferHistoryTool,
-            TransferFileTool,
-            SendMessageTool,
-            QuerySchedulersTool,
-            RunSchedulerTool,
-            QueryWorkflowsTool,
-            RunWorkflowTool
-        ]
-        # 创建内置工具
-        for ToolClass in tool_definitions:
-            tool = ToolClass(
-                session_id=session_id,
-                user_id=user_id
-            )
-            tool.set_message_attr(channel=channel, source=source, username=username)
-            tool.set_callback_handler(callback_handler=callback_handler)
-            tools.append(tool)
-        
-        # 加载插件提供的工具
-        plugin_tools_count = 0
-        plugin_tools_info = PluginManager().get_plugin_agent_tools()
-        for plugin_info in plugin_tools_info:
-            plugin_id = plugin_info.get("plugin_id")
-            plugin_name = plugin_info.get("plugin_name")
-            tool_classes = plugin_info.get("tools", [])
-            for ToolClass in tool_classes:
-                try:
-                    # 验证工具类是否继承自 MoviePilotTool
-                    if not issubclass(ToolClass, MoviePilotTool):
-                        logger.warning(f"插件 {plugin_name}({plugin_id}) 提供的工具类 {ToolClass.__name__} 未继承自 MoviePilotTool，已跳过")
-                        continue
-                    # 创建工具实例
-                    tool = ToolClass(
-                        session_id=session_id,
-                        user_id=user_id
-                    )
-                    tool.set_message_attr(channel=channel, source=source, username=username)
-                    tool.set_callback_handler(callback_handler=callback_handler)
-                    tools.append(tool)
-                    plugin_tools_count += 1
-                    logger.debug(f"成功加载插件 {plugin_name}({plugin_id}) 的工具: {ToolClass.__name__}")
-                except Exception as e:
-                    logger.error(f"加载插件 {plugin_name}({plugin_id}) 的工具 {ToolClass.__name__} 失败: {str(e)}")
-        
-        builtin_tools_count = len(tool_definitions)
-        if plugin_tools_count > 0:
-            logger.info(f"成功创建 {len(tools)} 个MoviePilot工具（内置工具: {builtin_tools_count} 个，插件工具: {plugin_tools_count} 个）")
-        else:
-            logger.info(f"成功创建 {len(tools)} 个MoviePilot工具")
-        return tools
--- a/app/agent/tools/impl/init.py
+++ b/app/agent/tools/impl/init.py
--- a/app/agent/tools/impl/add_download.py
+++ b/app/agent/tools/impl/add_download.py
@@ -1,106 +0,0 @@
-"""添加下载工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool, ToolChain
-from app.chain.download import DownloadChain
-from app.core.context import Context
-from app.core.metainfo import MetaInfo
-from app.db.site_oper import SiteOper
-from app.log import logger
-from app.schemas import TorrentInfo
-
-
-class AddDownloadInput(BaseModel):
-    """添加下载工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    site_name: str = Field(..., description="Name of the torrent site/source (e.g., 'The Pirate Bay')")
-    torrent_title: str = Field(...,
-                               description="The display name/title of the torrent (e.g., 'The.Matrix.1999.1080p.BluRay.x264')")
-    torrent_url: str = Field(..., description="Direct URL to the torrent file (.torrent) or magnet link")
-    torrent_description: Optional[str] = Field(None,
-                                                  description="Brief description of the torrent content (optional)")
-    downloader: Optional[str] = Field(None,
-                                      description="Name of the downloader to use (optional, uses default if not specified)")
-    save_path: Optional[str] = Field(None,
-                                     description="Directory path where the downloaded files should be saved. Using `<storage>:<path>` for remote storage. e.g. rclone:/MP, smb:/server/share/Movies. (optional, uses default path if not specified)")
-    labels: Optional[str] = Field(None,
-                                  description="Comma-separated list of labels/tags to assign to the download (optional, e.g., 'movie,hd,bluray')")
-
-
-class AddDownloadTool(MoviePilotTool):
-    name: str = "add_download"
-    description: str = "Add torrent download task to the configured downloader (qBittorrent, Transmission, etc.). Downloads the torrent file and starts the download process with specified settings."
-    args_schema: Type[BaseModel] = AddDownloadInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据下载参数生成友好的提示消息"""
-        torrent_title = kwargs.get("torrent_title", "")
-        site_name = kwargs.get("site_name", "")
-        downloader = kwargs.get("downloader")
-        
-        message = f"正在添加下载任务: {torrent_title}"
-        if site_name:
-            message += f" (来源: {site_name})"
-        if downloader:
-            message += f" [下载器: {downloader}]"
-        
-        return message
-
-    async def run(self, site_name: str, torrent_title: str, torrent_url: str, torrent_description: Optional[str] = None,
-                  downloader: Optional[str] = None, save_path: Optional[str] = None,
-                  labels: Optional[str] = None, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: site_name={site_name}, torrent_title={torrent_title}, torrent_url={torrent_url}, downloader={downloader}, save_path={save_path}, labels={labels}")
-
-        try:
-            if not torrent_title or not torrent_url:
-                return "错误：必须提供种子标题和下载链接"
-
-            # 使用DownloadChain添加下载
-            download_chain = DownloadChain()
-
-            # 根据站点名称查询站点cookie
-            if not site_name:
-                return "错误：必须提供站点名称，请从搜索资源结果信息中获取"
-            siteinfo = await SiteOper().async_get_by_name(site_name)
-            if not siteinfo:
-                return f"错误：未找到站点信息：{site_name}"
-
-            # 创建下载上下文
-            torrent_info = TorrentInfo(
-                title=torrent_title,
-                description=torrent_description,
-                enclosure=torrent_url,
-                site_name=site_name,
-                site_ua=siteinfo.ua,
-                site_cookie=siteinfo.cookie,
-                site_proxy=siteinfo.proxy,
-                site_order=siteinfo.pri,
-                site_downloader=siteinfo.downloader
-            )
-            meta_info = MetaInfo(title=torrent_title, subtitle=torrent_description)
-            media_info = await ToolChain().async_recognize_media(meta=meta_info)
-            if not media_info:
-                return "错误：无法识别媒体信息，无法添加下载任务"
-            context = Context(
-                torrent_info=torrent_info,
-                meta_info=meta_info,
-                media_info=media_info
-            )
-
-            did = download_chain.download_single(
-                context=context,
-                downloader=downloader,
-                save_path=save_path,
-                label=labels
-            )
-            if did:
-                return f"成功添加下载任务：{torrent_title}"
-            else:
-                return "添加下载任务失败"
-        except Exception as e:
-            logger.error(f"添加下载任务失败: {e}", exc_info=True)
-            return f"添加下载任务时发生错误: {str(e)}"
--- a/app/agent/tools/impl/add_subscribe.py
+++ b/app/agent/tools/impl/add_subscribe.py
@@ -1,135 +0,0 @@
-"""添加订阅工具"""
-
-from typing import Optional, Type, List
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.subscribe import SubscribeChain
-from app.log import logger
-from app.schemas.types import MediaType
-
-
-class AddSubscribeInput(BaseModel):
-    """添加订阅工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    title: str = Field(..., description="The title of the media to subscribe to (e.g., 'The Matrix', 'Breaking Bad')")
-    year: str = Field(..., description="Release year of the media (required for accurate identification)")
-    media_type: str = Field(...,
-                            description="Type of media content: '电影' for films, '电视剧' for television series or anime series")
-    season: Optional[int] = Field(None,
-                                  description="Season number for TV shows (optional, if not specified will subscribe to all seasons)")
-    tmdb_id: Optional[str] = Field(None,
-                                   description="TMDB database ID for precise media identification (optional but recommended for accuracy)")
-    start_episode: Optional[int] = Field(None,
-                                          description="Starting episode number for TV shows (optional, defaults to 1 if not specified)")
-    total_episode: Optional[int] = Field(None,
-                                          description="Total number of episodes for TV shows (optional, will be auto-detected from TMDB if not specified)")
-    quality: Optional[str] = Field(None,
-                                   description="Quality filter as regular expression (optional, e.g., 'BluRay|WEB-DL|HDTV')")
-    resolution: Optional[str] = Field(None,
-                                      description="Resolution filter as regular expression (optional, e.g., '1080p|720p|2160p')")
-    effect: Optional[str] = Field(None,
-                                  description="Effect filter as regular expression (optional, e.g., 'HDR|DV|SDR')")
-    filter_groups: Optional[List[str]] = Field(None,
-                                               description="List of filter rule group names to apply (optional, use query_rule_groups tool to get available rule groups)")
-    sites: Optional[List[int]] = Field(None,
-                                       description="List of site IDs to search from (optional, use query_sites tool to get available site IDs)")
-
-
-class AddSubscribeTool(MoviePilotTool):
-    name: str = "add_subscribe"
-    description: str = "Add media subscription to create automated download rules for movies and TV shows. The system will automatically search and download new episodes or releases based on the subscription criteria. Supports advanced filtering options like quality, resolution, and effect filters using regular expressions."
-    args_schema: Type[BaseModel] = AddSubscribeInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据订阅参数生成友好的提示消息"""
-        title = kwargs.get("title", "")
-        year = kwargs.get("year", "")
-        media_type = kwargs.get("media_type", "")
-        season = kwargs.get("season")
-        
-        message = f"正在添加订阅: {title}"
-        if year:
-            message += f" ({year})"
-        if media_type:
-            message += f" [{media_type}]"
-        if season:
-            message += f" 第{season}季"
-        
-        return message
-
-    async def run(self, title: str, year: str, media_type: str,
-                  season: Optional[int] = None, tmdb_id: Optional[str] = None,
-                  start_episode: Optional[int] = None, total_episode: Optional[int] = None,
-                  quality: Optional[str] = None, resolution: Optional[str] = None,
-                  effect: Optional[str] = None, filter_groups: Optional[List[str]] = None,
-                  sites: Optional[List[int]] = None, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: title={title}, year={year}, media_type={media_type}, "
-            f"season={season}, tmdb_id={tmdb_id}, start_episode={start_episode}, "
-            f"total_episode={total_episode}, quality={quality}, resolution={resolution}, "
-            f"effect={effect}, filter_groups={filter_groups}, sites={sites}")
-
-        try:
-            subscribe_chain = SubscribeChain()
-            # 转换 tmdb_id 为整数
-            tmdbid_int = None
-            if tmdb_id:
-                try:
-                    tmdbid_int = int(tmdb_id)
-                except (ValueError, TypeError):
-                    logger.warning(f"无效的 tmdb_id: {tmdb_id}，将忽略")
-
-            # 构建额外的订阅参数
-            subscribe_kwargs = {}
-            if start_episode is not None:
-                subscribe_kwargs['start_episode'] = start_episode
-            if total_episode is not None:
-                subscribe_kwargs['total_episode'] = total_episode
-            if quality:
-                subscribe_kwargs['quality'] = quality
-            if resolution:
-                subscribe_kwargs['resolution'] = resolution
-            if effect:
-                subscribe_kwargs['effect'] = effect
-            if filter_groups:
-                subscribe_kwargs['filter_groups'] = filter_groups
-            if sites:
-                subscribe_kwargs['sites'] = sites
-
-            sid, message = await subscribe_chain.async_add(
-                mtype=MediaType(media_type),
-                title=title,
-                year=year,
-                tmdbid=tmdbid_int,
-                season=season,
-                username=self._user_id,
-                **subscribe_kwargs
-            )
-            if sid:
-                result_msg = f"成功添加订阅：{title} ({year})"
-                if subscribe_kwargs:
-                    params = []
-                    if start_episode is not None:
-                        params.append(f"开始集数: {start_episode}")
-                    if total_episode is not None:
-                        params.append(f"总集数: {total_episode}")
-                    if quality:
-                        params.append(f"质量过滤: {quality}")
-                    if resolution:
-                        params.append(f"分辨率过滤: {resolution}")
-                    if effect:
-                        params.append(f"特效过滤: {effect}")
-                    if filter_groups:
-                        params.append(f"规则组: {', '.join(filter_groups)}")
-                    if sites:
-                        params.append(f"站点: {', '.join(map(str, sites))}")
-                    if params:
-                        result_msg += f"\n配置参数: {', '.join(params)}"
-                return result_msg
-            else:
-                return f"添加订阅失败：{message}"
-        except Exception as e:
-            logger.error(f"添加订阅失败: {e}", exc_info=True)
-            return f"添加订阅时发生错误: {str(e)}"
--- a/app/agent/tools/impl/delete_download.py
+++ b/app/agent/tools/impl/delete_download.py
@@ -1,76 +0,0 @@
-"""删除下载任务工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.download import DownloadChain
-from app.log import logger
-
-
-class DeleteDownloadInput(BaseModel):
-    """删除下载任务工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    task_identifier: str = Field(..., description="Task identifier: can be task hash (unique identifier) or task title/name")
-    downloader: Optional[str] = Field(None, description="Name of specific downloader (optional, if not provided will search all downloaders)")
-    delete_files: Optional[bool] = Field(False, description="Whether to delete downloaded files along with the task (default: False, only removes the task from downloader)")
-
-
-class DeleteDownloadTool(MoviePilotTool):
-    name: str = "delete_download"
-    description: str = "Delete a download task from the downloader. Can delete by task hash (unique identifier) or task title/name. Optionally specify the downloader name and whether to delete downloaded files."
-    args_schema: Type[BaseModel] = DeleteDownloadInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据删除参数生成友好的提示消息"""
-        task_identifier = kwargs.get("task_identifier", "")
-        downloader = kwargs.get("downloader")
-        delete_files = kwargs.get("delete_files", False)
-        
-        message = f"正在删除下载任务: {task_identifier}"
-        if downloader:
-            message += f" [下载器: {downloader}]"
-        if delete_files:
-            message += " (包含文件)"
-        
-        return message
-
-    async def run(self, task_identifier: str, downloader: Optional[str] = None,
-                  delete_files: Optional[bool] = False, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: task_identifier={task_identifier}, downloader={downloader}, delete_files={delete_files}")
-
-        try:
-            download_chain = DownloadChain()
-            
-            # 如果task_identifier看起来像hash（通常是40个字符的十六进制字符串）
-            task_hash = None
-            if len(task_identifier) == 40 and all(c in '0123456789abcdefABCDEF' for c in task_identifier):
-                # 直接使用hash
-                task_hash = task_identifier
-            else:
-                # 通过标题查找任务
-                downloads = download_chain.downloading(name=downloader)
-                for dl in downloads:
-                    # 检查标题或名称是否匹配
-                    if (task_identifier.lower() in (dl.title or "").lower()) or \
-                       (task_identifier.lower() in (dl.name or "").lower()):
-                        task_hash = dl.hash
-                        break
-                
-                if not task_hash:
-                    return f"未找到匹配的下载任务：{task_identifier}，请使用 query_downloads 工具查询可用的下载任务"
-            
-            # 删除下载任务
-            # remove_torrents 支持 delete_file 参数，可以控制是否删除文件
-            result = download_chain.remove_torrents(hashs=[task_hash], downloader=downloader, delete_file=delete_files)
-            
-            if result:
-                files_info = "（包含文件）" if delete_files else "（不包含文件）"
-                return f"成功删除下载任务：{task_identifier} {files_info}"
-            else:
-                return f"删除下载任务失败：{task_identifier}，请检查任务是否存在或下载器是否可用"
-        except Exception as e:
-            logger.error(f"删除下载任务失败: {e}", exc_info=True)
-            return f"删除下载任务时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/delete_subscribe.py
+++ b/app/agent/tools/impl/delete_subscribe.py
@@ -1,63 +0,0 @@
-"""删除订阅工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.core.event import eventmanager
-from app.db.subscribe_oper import SubscribeOper
-from app.helper.subscribe import SubscribeHelper
-from app.log import logger
-from app.schemas.types import EventType
-
-
-class DeleteSubscribeInput(BaseModel):
-    """删除订阅工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    subscribe_id: int = Field(..., description="The ID of the subscription to delete (can be obtained from query_subscribes tool)")
-
-
-class DeleteSubscribeTool(MoviePilotTool):
-    name: str = "delete_subscribe"
-    description: str = "Delete a media subscription by its ID. This will remove the subscription and stop automatic downloads for that media."
-    args_schema: Type[BaseModel] = DeleteSubscribeInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据删除参数生成友好的提示消息"""
-        subscribe_id = kwargs.get("subscribe_id")
-        return f"正在删除订阅 (ID: {subscribe_id})"
-
-    async def run(self, subscribe_id: int, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: subscribe_id={subscribe_id}")
-
-        try:
-            subscribe_oper = SubscribeOper()
-            # 获取订阅信息
-            subscribe = await subscribe_oper.async_get(subscribe_id)
-            if not subscribe:
-                return f"订阅 ID {subscribe_id} 不存在"
-            
-            # 在删除之前获取订阅信息（用于事件）
-            subscribe_info = subscribe.to_dict()
-            
-            # 删除订阅
-            subscribe_oper.delete(subscribe_id)
-            
-            # 发送事件
-            await eventmanager.async_send_event(EventType.SubscribeDeleted, {
-                "subscribe_id": subscribe_id,
-                "subscribe_info": subscribe_info
-            })
-            
-            # 统计订阅
-            SubscribeHelper().sub_done_async({
-                "tmdbid": subscribe.tmdbid,
-                "doubanid": subscribe.doubanid
-            })
-            
-            return f"成功删除订阅：{subscribe.name} ({subscribe.year})"
-        except Exception as e:
-            logger.error(f"删除订阅失败: {e}", exc_info=True)
-            return f"删除订阅时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/get_recommendations.py
+++ b/app/agent/tools/impl/get_recommendations.py
@@ -1,170 +0,0 @@
-"""获取推荐工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.recommend import RecommendChain
-from app.log import logger
-
-
-class GetRecommendationsInput(BaseModel):
-    """获取推荐工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    source: Optional[str] = Field("tmdb_trending",
-                                  description="Recommendation source: "
-                                  "'tmdb_trending' for TMDB trending content, "
-                                  "'tmdb_movies' for TMDB popular movies, "
-                                  "'tmdb_tvs' for TMDB popular TV shows, "
-                                  "'douban_hot' for Douban popular content, "
-                                  "'douban_movie_hot' for Douban hot movies, "
-                                  "'douban_tv_hot' for Douban hot TV shows, "
-                                  "'douban_movie_showing' for Douban movies currently showing, "
-                                  "'douban_movies' for Douban latest movies, "
-                                  "'douban_tvs' for Douban latest TV shows, "
-                                  "'douban_movie_top250' for Douban movie TOP250, "
-                                  "'douban_tv_weekly_chinese' for Douban Chinese TV weekly chart, "
-                                  "'douban_tv_weekly_global' for Douban global TV weekly chart, "
-                                  "'douban_tv_animation' for Douban popular animation, "
-                                  "'bangumi_calendar' for Bangumi anime calendar")
-    media_type: Optional[str] = Field("all",
-                                      description="Type of media content: '电影' for films, '电视剧' for television series or anime series, 'all' for all types")
-    limit: Optional[int] = Field(20,
-                                 description="Maximum number of recommendations to return (default: 20, maximum: 100)")
-
-
-class GetRecommendationsTool(MoviePilotTool):
-    name: str = "get_recommendations"
-    description: str = "Get trending and popular media recommendations from various sources. Returns curated lists of popular movies, TV shows, and anime based on different criteria like trending, ratings, or calendar schedules."
-    args_schema: Type[BaseModel] = GetRecommendationsInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据推荐参数生成友好的提示消息"""
-        source = kwargs.get("source", "tmdb_trending")
-        media_type = kwargs.get("media_type", "all")
-        limit = kwargs.get("limit", 20)
-        
-        source_map = {
-            "tmdb_trending": "TMDB流行趋势",
-            "tmdb_movies": "TMDB热门电影",
-            "tmdb_tvs": "TMDB热门电视剧",
-            "douban_hot": "豆瓣热门",
-            "douban_movie_hot": "豆瓣热门电影",
-            "douban_tv_hot": "豆瓣热门电视剧",
-            "douban_movie_showing": "豆瓣正在热映",
-            "douban_movies": "豆瓣最新电影",
-            "douban_tvs": "豆瓣最新电视剧",
-            "douban_movie_top250": "豆瓣电影TOP250",
-            "douban_tv_weekly_chinese": "豆瓣国产剧集榜",
-            "douban_tv_weekly_global": "豆瓣全球剧集榜",
-            "douban_tv_animation": "豆瓣热门动漫",
-            "bangumi_calendar": "番组计划"
-        }
-        source_desc = source_map.get(source, source)
-        
-        message = f"正在获取推荐: {source_desc}"
-        if media_type != "all":
-            message += f" [{media_type}]"
-        message += f" (限制: {limit}条)"
-        
-        return message
-
-    async def run(self, source: Optional[str] = "tmdb_trending",
-                  media_type: Optional[str] = "all", limit: Optional[int] = 20, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: source={source}, media_type={media_type}, limit={limit}")
-        try:
-            recommend_chain = RecommendChain()
-            results = []
-            if source == "tmdb_trending":
-                # async_tmdb_trending 只接受 page 参数，返回固定数量的结果
-                # 如果需要限制数量，需要在返回后截取
-                results = await recommend_chain.async_tmdb_trending(page=1)
-                if limit and limit > 0:
-                    results = results[:limit]
-            elif source == "tmdb_movies":
-                # async_tmdb_movies 接受 page 参数，返回固定数量的结果
-                results = await recommend_chain.async_tmdb_movies(page=1)
-                if limit and limit > 0:
-                    results = results[:limit]
-            elif source == "tmdb_tvs":
-                # async_tmdb_tvs 接受 page 参数，返回固定数量的结果
-                results = await recommend_chain.async_tmdb_tvs(page=1)
-                if limit and limit > 0:
-                    results = results[:limit]
-            elif source == "douban_hot":
-                if media_type == "movie":
-                    results = await recommend_chain.async_douban_movie_hot(page=1, count=limit)
-                elif media_type == "tv":
-                    results = await recommend_chain.async_douban_tv_hot(page=1, count=limit)
-                else:  # all
-                    results.extend(await recommend_chain.async_douban_movie_hot(page=1, count=limit))
-                    results.extend(await recommend_chain.async_douban_tv_hot(page=1, count=limit))
-            elif source == "douban_movie_hot":
-                results = await recommend_chain.async_douban_movie_hot(page=1, count=limit)
-            elif source == "douban_tv_hot":
-                results = await recommend_chain.async_douban_tv_hot(page=1, count=limit)
-            elif source == "douban_movie_showing":
-                results = await recommend_chain.async_douban_movie_showing(page=1, count=limit)
-            elif source == "douban_movies":
-                results = await recommend_chain.async_douban_movies(page=1, count=limit)
-            elif source == "douban_tvs":
-                results = await recommend_chain.async_douban_tvs(page=1, count=limit)
-            elif source == "douban_movie_top250":
-                results = await recommend_chain.async_douban_movie_top250(page=1, count=limit)
-            elif source == "douban_tv_weekly_chinese":
-                results = await recommend_chain.async_douban_tv_weekly_chinese(page=1, count=limit)
-            elif source == "douban_tv_weekly_global":
-                results = await recommend_chain.async_douban_tv_weekly_global(page=1, count=limit)
-            elif source == "douban_tv_animation":
-                results = await recommend_chain.async_douban_tv_animation(page=1, count=limit)
-            elif source == "bangumi_calendar":
-                results = await recommend_chain.async_bangumi_calendar(page=1, count=limit)
-            else:
-                # 不支持的推荐来源
-                supported_sources = [
-                    "tmdb_trending", "tmdb_movies", "tmdb_tvs",
-                    "douban_hot", "douban_movie_hot", "douban_tv_hot",
-                    "douban_movie_showing", "douban_movies", "douban_tvs",
-                    "douban_movie_top250", "douban_tv_weekly_chinese",
-                    "douban_tv_weekly_global", "douban_tv_animation",
-                    "bangumi_calendar"
-                ]
-                return f"不支持的推荐来源: {source}。支持的来源包括: {', '.join(supported_sources)}"
-
-            if results:
-                # 限制最多20条结果
-                total_count = len(results)
-                limited_results = results[:20]
-                # 精简字段，只保留关键信息
-                simplified_results = []
-                for r in limited_results:
-                    # r 应该是字典格式（to_dict的结果），但为了安全起见进行检查
-                    if not isinstance(r, dict):
-                        logger.warning(f"推荐结果格式异常，跳过: {type(r)}")
-                        continue
-                    
-                    simplified = {
-                        "title": r.get("title"),
-                        "en_title": r.get("en_title"),
-                        "year": r.get("year"),
-                        "type": r.get("type"),
-                        "season": r.get("season"),
-                        "tmdb_id": r.get("tmdb_id"),
-                        "imdb_id": r.get("imdb_id"),
-                        "douban_id": r.get("douban_id"),
-                        "vote_average": r.get("vote_average"),
-                        "poster_path": r.get("poster_path"),
-                        "detail_link": r.get("detail_link")
-                    }
-                    simplified_results.append(simplified)
-                result_json = json.dumps(simplified_results, ensure_ascii=False, indent=2)
-                # 如果结果被裁剪，添加提示信息
-                if total_count > 20:
-                    return f"注意：推荐结果共找到 {total_count} 条，为节省上下文空间，仅显示前 20 条结果。\n\n{result_json}"
-                return result_json
-            return "未找到推荐内容。"
-        except Exception as e:
-            logger.error(f"获取推荐失败: {e}", exc_info=True)
-            return f"获取推荐时发生错误: {str(e)}"
--- a/app/agent/tools/impl/list_directory.py
+++ b/app/agent/tools/impl/list_directory.py
@@ -1,130 +0,0 @@
-"""查询文件系统目录内容工具"""
-
-import json
-from datetime import datetime
-from pathlib import Path
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.storage import StorageChain
-from app.log import logger
-from app.schemas.file import FileItem
-from app.utils.string import StringUtils
-
-
-class ListDirectoryInput(BaseModel):
-    """查询文件系统目录内容工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    path: str = Field(..., description="Directory path to list contents (e.g., '/home/user/downloads' or 'C:/Downloads')")
-    storage: Optional[str] = Field("local", description="Storage type (default: 'local' for local file system, can be 'smb', 'alist', etc.)")
-    sort_by: Optional[str] = Field("name", description="Sort order: 'name' for alphabetical sorting, 'time' for modification time sorting (default: 'name')")
-
-
-class ListDirectoryTool(MoviePilotTool):
-    name: str = "list_directory"
-    description: str = "List actual files and folders in a file system directory (NOT configuration). Shows files and subdirectories with their names, types, sizes, and modification times. Returns up to 20 items and the total count if there are more items. Use 'query_directories' to query directory configuration settings."
-    args_schema: Type[BaseModel] = ListDirectoryInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据目录参数生成友好的提示消息"""
-        path = kwargs.get("path", "")
-        storage = kwargs.get("storage", "local")
-        
-        message = f"正在查询目录: {path}"
-        if storage != "local":
-            message += f" [存储: {storage}]"
-        
-        return message
-
-    async def run(self, path: str, storage: Optional[str] = "local",
-                  sort_by: Optional[str] = "name", **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: path={path}, storage={storage}, sort_by={sort_by}")
-
-        try:
-            # 规范化路径
-            if not path:
-                return "错误：路径不能为空"
-            
-            # 确保路径格式正确
-            if storage == "local":
-                # 本地路径处理
-                if not path.startswith("/") and not (len(path) > 1 and path[1] == ":"):
-                    # 相对路径，尝试转换为绝对路径
-                    path = str(Path(path).resolve())
-            else:
-                # 远程存储路径，确保以/开头
-                if not path.startswith("/"):
-                    path = "/" + path
-            
-            # 创建FileItem
-            fileitem = FileItem(
-                storage=storage or "local",
-                path=path,
-                type="dir"
-            )
-            
-            # 查询目录内容
-            storage_chain = StorageChain()
-            file_list = storage_chain.list_files(fileitem, recursion=False)
-            
-            if file_list is None:
-                return f"无法访问目录：{path}，请检查路径是否正确或存储是否可用"
-            
-            if not file_list:
-                return f"目录 {path} 为空"
-            
-            # 排序
-            if sort_by == "time":
-                file_list.sort(key=lambda x: x.modify_time or 0, reverse=True)
-            else:
-                # 默认按名称排序（目录优先，然后按名称）
-                file_list.sort(key=lambda x: (
-                    0 if x.type == "dir" else 1,
-                    StringUtils.natural_sort_key(x.name or "")
-                ))
-            
-            # 限制返回数量
-            total_count = len(file_list)
-            limited_list = file_list[:20]
-            
-            # 转换为字典格式
-            simplified_items = []
-            for item in limited_list:
-                # 格式化文件大小
-                size_str = None
-                if item.size:
-                    size_str = StringUtils.str_filesize(item.size)
-                
-                # 格式化修改时间
-                modify_time_str = None
-                if item.modify_time:
-                    try:
-                        modify_time_str = datetime.fromtimestamp(item.modify_time).strftime("%Y-%m-%d %H:%M:%S")
-                    except (ValueError, OSError):
-                        modify_time_str = str(item.modify_time)
-                
-                simplified = {
-                    "name": item.name,
-                    "type": item.type,
-                    "path": item.path,
-                    "size": size_str,
-                    "modify_time": modify_time_str
-                }
-                # 如果是文件，添加扩展名
-                if item.type == "file" and item.extension:
-                    simplified["extension"] = item.extension
-                simplified_items.append(simplified)
-            
-            result_json = json.dumps(simplified_items, ensure_ascii=False, indent=2)
-            
-            # 如果结果被裁剪，添加提示信息
-            if total_count > 20:
-                return f"注意：目录中共有 {total_count} 个项目，为节省上下文空间，仅显示前 20 个项目。\n\n{result_json}"
-            else:
-                return result_json
-        except Exception as e:
-            logger.error(f"查询目录内容失败: {e}", exc_info=True)
-            return f"查询目录内容时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_directory_settings.py
+++ b/app/agent/tools/impl/query_directory_settings.py
@@ -1,134 +0,0 @@
-"""查询系统目录设置工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.helper.directory import DirectoryHelper
-from app.log import logger
-
-
-class QueryDirectorySettingsInput(BaseModel):
-    """查询系统目录设置工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    directory_type: Optional[str] = Field("all",
-                                          description="Filter directories by type: 'download' for download directories, 'library' for media library directories, 'all' for all directories")
-    storage_type: Optional[str] = Field("all",
-                                        description="Filter directories by storage type: 'local' for local storage, 'remote' for remote storage, 'all' for all storage types")
-    name: Optional[str] = Field(None,
-                               description="Filter directories by name (partial match, optional)")
-
-
-class QueryDirectorySettingsTool(MoviePilotTool):
-    name: str = "query_directory_settings"
-    description: str = "Query system directory configuration settings (NOT file listings). Returns configured directory paths, storage types, transfer modes, and other directory-related settings. Use 'list_directory' to list actual files and folders in a directory."
-    args_schema: Type[BaseModel] = QueryDirectorySettingsInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        directory_type = kwargs.get("directory_type", "all")
-        storage_type = kwargs.get("storage_type", "all")
-        name = kwargs.get("name")
-        
-        parts = ["正在查询目录配置"]
-        
-        if directory_type != "all":
-            type_map = {"download": "下载目录", "library": "媒体库目录"}
-            parts.append(f"类型: {type_map.get(directory_type, directory_type)}")
-        
-        if storage_type != "all":
-            storage_map = {"local": "本地存储", "remote": "远程存储"}
-            parts.append(f"存储: {storage_map.get(storage_type, storage_type)}")
-        
-        if name:
-            parts.append(f"名称: {name}")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, directory_type: Optional[str] = "all",
-                  storage_type: Optional[str] = "all",
-                  name: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: directory_type={directory_type}, storage_type={storage_type}, name={name}")
-
-        try:
-            directory_helper = DirectoryHelper()
-            
-            # 根据目录类型获取目录列表
-            if directory_type == "download":
-                dirs = directory_helper.get_download_dirs()
-            elif directory_type == "library":
-                dirs = directory_helper.get_library_dirs()
-            else:
-                dirs = directory_helper.get_dirs()
-            
-            # 按存储类型过滤
-            filtered_dirs = []
-            for d in dirs:
-                # 按存储类型过滤
-                if storage_type == "local":
-                    # 对于下载目录，检查 storage；对于媒体库目录，检查 library_storage
-                    if directory_type == "download" and d.storage != "local":
-                        continue
-                    elif directory_type == "library" and d.library_storage != "local":
-                        continue
-                    elif directory_type == "all":
-                        # 检查是否有本地存储配置
-                        if d.download_path and d.storage != "local":
-                            continue
-                        if d.library_path and d.library_storage != "local":
-                            continue
-                elif storage_type == "remote":
-                    # 对于下载目录，检查 storage；对于媒体库目录，检查 library_storage
-                    if directory_type == "download" and d.storage == "local":
-                        continue
-                    elif directory_type == "library" and d.library_storage == "local":
-                        continue
-                    elif directory_type == "all":
-                        # 检查是否有远程存储配置
-                        if d.download_path and d.storage == "local":
-                            continue
-                        if d.library_path and d.library_storage == "local":
-                            continue
-                
-                # 按名称过滤（部分匹配）
-                if name and d.name and name.lower() not in d.name.lower():
-                    continue
-                
-                filtered_dirs.append(d)
-            
-            if filtered_dirs:
-                # 转换为字典格式，只保留关键信息
-                simplified_dirs = []
-                for d in filtered_dirs:
-                    simplified = {
-                        "name": d.name,
-                        "priority": d.priority,
-                        "storage": d.storage,
-                        "download_path": d.download_path,
-                        "library_path": d.library_path,
-                        "library_storage": d.library_storage,
-                        "media_type": d.media_type,
-                        "media_category": d.media_category,
-                        "monitor_type": d.monitor_type,
-                        "monitor_mode": d.monitor_mode,
-                        "transfer_type": d.transfer_type,
-                        "overwrite_mode": d.overwrite_mode,
-                        "renaming": d.renaming,
-                        "scraping": d.scraping,
-                        "notify": d.notify,
-                        "download_type_folder": d.download_type_folder,
-                        "download_category_folder": d.download_category_folder,
-                        "library_type_folder": d.library_type_folder,
-                        "library_category_folder": d.library_category_folder
-                    }
-                    simplified_dirs.append(simplified)
-                
-                result_json = json.dumps(simplified_dirs, ensure_ascii=False, indent=2)
-                return result_json
-            return "未找到相关目录配置"
-        except Exception as e:
-            logger.error(f"查询系统目录设置失败: {e}", exc_info=True)
-            return f"查询系统目录设置时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_download_tasks.py
+++ b/app/agent/tools/impl/query_download_tasks.py
@@ -1,197 +0,0 @@
-"""查询下载工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.download import DownloadChain
-from app.db.downloadhistory_oper import DownloadHistoryOper
-from app.log import logger
-
-
-class QueryDownloadTasksInput(BaseModel):
-    """查询下载工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    downloader: Optional[str] = Field(None,
-                                      description="Name of specific downloader to query (optional, if not provided queries all configured downloaders)")
-    status: Optional[str] = Field("all",
-                                  description="Filter downloads by status: 'downloading' for active downloads, 'completed' for finished downloads, 'paused' for paused downloads, 'all' for all downloads")
-    hash: Optional[str] = Field(None, description="Query specific download task by hash (optional, if provided will search for this specific task regardless of status)")
-    title: Optional[str] = Field(None, description="Query download tasks by title/name (optional, supports partial match, searches all tasks if provided)")
-
-
-class QueryDownloadTasksTool(MoviePilotTool):
-    name: str = "query_download_tasks"
-    description: str = "Query download status and list download tasks. Can query all active downloads, or search for specific tasks by hash or title. Shows download progress, completion status, and task details from configured downloaders."
-    args_schema: Type[BaseModel] = QueryDownloadTasksInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        downloader = kwargs.get("downloader")
-        status = kwargs.get("status", "all")
-        hash_value = kwargs.get("hash")
-        title = kwargs.get("title")
-        
-        parts = ["正在查询下载任务"]
-        
-        if downloader:
-            parts.append(f"下载器: {downloader}")
-        
-        if status != "all":
-            status_map = {"downloading": "下载中", "completed": "已完成", "paused": "已暂停"}
-            parts.append(f"状态: {status_map.get(status, status)}")
-        
-        if hash_value:
-            parts.append(f"Hash: {hash_value[:8]}...")
-        elif title:
-            parts.append(f"标题: {title}")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, downloader: Optional[str] = None,
-                  status: Optional[str] = "all",
-                  hash: Optional[str] = None,
-                  title: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: downloader={downloader}, status={status}, hash={hash}, title={title}")
-        try:
-            download_chain = DownloadChain()
-            
-            # 如果提供了hash，直接查询该hash的任务（不限制状态）
-            if hash:
-                torrents = download_chain.list_torrents(downloader=downloader, hashs=[hash])
-                if not torrents:
-                    return f"未找到hash为 {hash} 的下载任务（该任务可能已完成、已删除或不存在）"
-                # 转换为DownloadingTorrent格式
-                downloads = []
-                for torrent in torrents:
-                    # 获取下载历史信息
-                    history = DownloadHistoryOper().get_by_hash(torrent.hash)
-                    if history:
-                        torrent.media = {
-                            "tmdbid": history.tmdbid,
-                            "type": history.type,
-                            "title": history.title,
-                            "season": history.seasons,
-                            "episode": history.episodes,
-                            "image": history.image,
-                        }
-                        torrent.userid = history.userid
-                        torrent.username = history.username
-                    downloads.append(torrent)
-                filtered_downloads = downloads
-            elif title:
-                # 如果提供了title，查询所有任务并搜索匹配的标题
-                # 查询所有状态的任务
-                all_torrents = download_chain.list_torrents(downloader=downloader) or []
-                filtered_downloads = []
-                for torrent in all_torrents:
-                    # 检查标题或名称是否匹配
-                    if (title.lower() in (torrent.title or "").lower()) or \
-                       (title.lower() in (torrent.name or "").lower()):
-                        # 获取下载历史信息
-                        history = DownloadHistoryOper().get_by_hash(torrent.hash)
-                        if history:
-                            torrent.media = {
-                                "tmdbid": history.tmdbid,
-                                "type": history.type,
-                                "title": history.title,
-                                "season": history.seasons,
-                                "episode": history.episodes,
-                                "image": history.image,
-                            }
-                            torrent.userid = history.userid
-                            torrent.username = history.username
-                        filtered_downloads.append(torrent)
-                if not filtered_downloads:
-                    return f"未找到标题包含 '{title}' 的下载任务"
-            else:
-                # 根据status决定查询方式
-                if status == "downloading":
-                    # 如果status为下载中，使用downloading方法
-                    downloads = download_chain.downloading(name=downloader)
-                    filtered_downloads = []
-                    for dl in downloads:
-                        if downloader and dl.downloader != downloader:
-                            continue
-                        filtered_downloads.append(dl)
-                else:
-                    # 其他状态（completed、paused、all），使用list_torrents查询所有任务
-                    # 查询所有状态的任务
-                    all_torrents = download_chain.list_torrents(downloader=downloader) or []
-                    filtered_downloads = []
-                    for torrent in all_torrents:
-                        if downloader and torrent.downloader != downloader:
-                            continue
-                        # 根据status过滤
-                        if status == "completed":
-                            # 已完成的任务（state为seeding或completed）
-                            if torrent.state not in ["seeding", "completed"]:
-                                continue
-                        elif status == "paused":
-                            # 已暂停的任务
-                            if torrent.state != "paused":
-                                continue
-                        # status == "all" 时不过滤
-                        # 获取下载历史信息
-                        history = DownloadHistoryOper().get_by_hash(torrent.hash)
-                        if history:
-                            torrent.media = {
-                                "tmdbid": history.tmdbid,
-                                "type": history.type,
-                                "title": history.title,
-                                "season": history.seasons,
-                                "episode": history.episodes,
-                                "image": history.image,
-                            }
-                            torrent.userid = history.userid
-                            torrent.username = history.username
-                        filtered_downloads.append(torrent)
-            if filtered_downloads:
-                # 限制最多20条结果
-                total_count = len(filtered_downloads)
-                limited_downloads = filtered_downloads[:20]
-                # 精简字段，只保留关键信息
-                simplified_downloads = []
-                for d in limited_downloads:
-                    simplified = {
-                        "downloader": d.downloader,
-                        "hash": d.hash,
-                        "title": d.title,
-                        "name": d.name,
-                        "year": d.year,
-                        "season_episode": d.season_episode,
-                        "size": d.size,
-                        "progress": d.progress,
-                        "state": d.state,
-                        "upspeed": d.upspeed,
-                        "dlspeed": d.dlspeed,
-                        "left_time": d.left_time
-                    }
-                    # 精简 media 字段
-                    if d.media:
-                        simplified["media"] = {
-                            "tmdbid": d.media.get("tmdbid"),
-                            "type": d.media.get("type"),
-                            "title": d.media.get("title"),
-                            "season": d.media.get("season"),
-                            "episode": d.media.get("episode")
-                        }
-                    simplified_downloads.append(simplified)
-                result_json = json.dumps(simplified_downloads, ensure_ascii=False, indent=2)
-                # 如果结果被裁剪，添加提示信息
-                if total_count > 20:
-                    return f"注意：查询结果共找到 {total_count} 条，为节省上下文空间，仅显示前 20 条结果。\n\n{result_json}"
-                
-                # 如果查询的是特定hash或title，添加明确的状态信息
-                if hash:
-                    return f"找到hash为 {hash} 的下载任务：\n\n{result_json}"
-                elif title:
-                    return f"找到 {total_count} 个标题包含 '{title}' 的下载任务：\n\n{result_json}"
-                
-                return result_json
-            return "未找到相关下载任务"
-        except Exception as e:
-            logger.error(f"查询下载失败: {e}", exc_info=True)
-            return f"查询下载时发生错误: {str(e)}"
--- a/app/agent/tools/impl/query_downloaders.py
+++ b/app/agent/tools/impl/query_downloaders.py
@@ -1,38 +0,0 @@
-"""查询下载器工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.db.systemconfig_oper import SystemConfigOper
-from app.log import logger
-from app.schemas.types import SystemConfigKey
-
-
-class QueryDownloadersInput(BaseModel):
-    """查询下载器工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-
-
-class QueryDownloadersTool(MoviePilotTool):
-    name: str = "query_downloaders"
-    description: str = "Query downloader configuration and list all available downloaders. Shows downloader status, connection details, and configuration settings."
-    args_schema: Type[BaseModel] = QueryDownloadersInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """生成友好的提示消息"""
-        return "正在查询下载器配置"
-
-    async def run(self, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}")
-        try:
-            system_config_oper = SystemConfigOper()
-            downloaders_config = system_config_oper.get(SystemConfigKey.Downloaders)
-            if downloaders_config:
-                return json.dumps(downloaders_config, ensure_ascii=False, indent=2)
-            return "未配置下载器。"
-        except Exception as e:
-            logger.error(f"查询下载器失败: {e}")
-            return f"查询下载器时发生错误: {str(e)}"
--- a/app/agent/tools/impl/query_episode_schedule.py
+++ b/app/agent/tools/impl/query_episode_schedule.py
@@ -1,116 +0,0 @@
-"""查询剧集上映时间工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.media import MediaChain
-from app.chain.tmdb import TmdbChain
-from app.log import logger
-from app.schemas import MediaType
-
-
-class QueryEpisodeScheduleInput(BaseModel):
-    """查询剧集上映时间工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    tmdb_id: int = Field(..., description="TMDB ID of the TV series")
-    season: int = Field(..., description="Season number to query")
-    episode_group: Optional[str] = Field(None, description="Episode group ID (optional)")
-
-
-class QueryEpisodeScheduleTool(MoviePilotTool):
-    name: str = "query_episode_schedule"
-    description: str = "Query TV series episode air dates and schedule. Returns detailed information for each episode including air date, episode number, title, overview, and other metadata. Filters out episodes without air dates."
-    args_schema: Type[BaseModel] = QueryEpisodeScheduleInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        tmdb_id = kwargs.get("tmdb_id")
-        season = kwargs.get("season")
-        episode_group = kwargs.get("episode_group")
-
-        message = f"正在查询剧集上映时间: TMDB ID {tmdb_id} 第{season}季"
-        if episode_group:
-            message += f" (剧集组: {episode_group})"
-
-        return message
-
-    async def run(self, tmdb_id: int, season: int, episode_group: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: tmdb_id={tmdb_id}, season={season}, episode_group={episode_group}")
-
-        try:
-            # 获取媒体信息（用于获取标题和海报）
-            media_chain = MediaChain()
-            mediainfo = await media_chain.async_recognize_media(tmdbid=tmdb_id, mtype=MediaType.TV)
-            if not mediainfo:
-                return f"未找到 TMDB ID {tmdb_id} 的媒体信息"
-
-            # 获取集列表
-            tmdb_chain = TmdbChain()
-            episodes = await tmdb_chain.async_tmdb_episodes(
-                tmdbid=tmdb_id,
-                season=season,
-                episode_group=episode_group
-            )
-
-            if not episodes:
-                return json.dumps({
-                    "success": False,
-                    "message": f"未找到 TMDB ID {tmdb_id} 第{season}季的集信息"
-                }, ensure_ascii=False)
-
-            # 过滤掉没有上映日期的集，并构建每集的详细信息
-            episode_list = []
-            for episode in episodes:
-                air_date = episode.air_date
-                
-                # 过滤掉没有上映日期的数据
-                if not air_date:
-                    continue
-                
-                episode_info = {
-                    "episode_number": episode.episode_number,
-                    "name": episode.name,
-                    "air_date": air_date,
-                    "runtime": episode.runtime,
-                    "vote_average": episode.vote_average,
-                    "still_path": episode.still_path,
-                    "episode_type": episode.episode_type,
-                    "season_number": episode.season_number
-                }
-                episode_list.append(episode_info)
-
-            if not episode_list:
-                return json.dumps({
-                    "success": False,
-                    "message": f"未找到 TMDB ID {tmdb_id} 第{season}季的播出时间信息（所有集都没有播出日期）"
-                }, ensure_ascii=False)
-
-            # 按播出日期排序
-            episode_list.sort(key=lambda x: (x["air_date"] or "", x["episode_number"] or 0))
-
-            result = {
-                "success": True,
-                "tmdb_id": tmdb_id,
-                "season": season,
-                "episode_group": episode_group,
-                "series_title": mediainfo.title if mediainfo else None,
-                "series_poster": mediainfo.poster_path if mediainfo else None,
-                "total_episodes": len(episodes),
-                "episodes_with_air_date": len(episode_list),
-                "episodes": episode_list
-            }
-
-            return json.dumps(result, ensure_ascii=False, indent=2)
-
-        except Exception as e:
-            error_message = f"查询剧集上映时间失败: {str(e)}"
-            logger.error(f"查询剧集上映时间失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message,
-                "tmdb_id": tmdb_id,
-                "season": season
-            }, ensure_ascii=False)
--- a/app/agent/tools/impl/query_library_exists.py
+++ b/app/agent/tools/impl/query_library_exists.py
@@ -1,97 +0,0 @@
-"""查询媒体库工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.mediaserver import MediaServerChain
-from app.core.context import MediaInfo
-from app.log import logger
-from app.schemas.types import MediaType
-
-
-class QueryLibraryExistsInput(BaseModel):
-    """查询媒体库工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    media_type: Optional[str] = Field("all",
-                                      description="Type of media content: '电影' for films, '电视剧' for television series or anime series, 'all' for all types")
-    title: Optional[str] = Field(None,
-                                 description="Specific media title to check if it exists in the media library (optional, if provided checks for that specific media)")
-    year: Optional[str] = Field(None,
-                                description="Release year of the media (optional, helps narrow down search results)")
-
-
-class QueryLibraryExistsTool(MoviePilotTool):
-    name: str = "query_library_exists"
-    description: str = "Check if a specific media resource already exists in the media library (Plex, Emby, Jellyfin). Use this tool to verify whether a movie or TV series has been successfully processed and added to the media server before performing operations like downloading or subscribing."
-    args_schema: Type[BaseModel] = QueryLibraryExistsInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        media_type = kwargs.get("media_type", "all")
-        title = kwargs.get("title")
-        year = kwargs.get("year")
-        
-        parts = ["正在查询媒体库"]
-        
-        if title:
-            parts.append(f"标题: {title}")
-        if year:
-            parts.append(f"年份: {year}")
-        if media_type != "all":
-            parts.append(f"类型: {media_type}")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, media_type: Optional[str] = "all",
-                  title: Optional[str] = None, year: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: media_type={media_type}, title={title}")
-        try:
-            if not title:
-                return "请提供媒体标题进行查询"
-            
-            # 创建 MediaInfo 对象
-            mediainfo = MediaInfo()
-            mediainfo.title = title
-            mediainfo.year = year
-            
-            # 转换媒体类型
-            if media_type == "电影":
-                mediainfo.type = MediaType.MOVIE
-            elif media_type == "电视剧":
-                mediainfo.type = MediaType.TV
-            # media_type == "all" 时不设置类型，让媒体服务器自动判断
-            
-            # 调用媒体服务器接口实时查询
-            media_chain = MediaServerChain()
-            existsinfo = media_chain.media_exists(mediainfo=mediainfo)
-            
-            if not existsinfo:
-                return "媒体库中未找到相关媒体"
-            
-            # 如果找到了，获取详细信息
-            result_items = []
-            if existsinfo.itemid and existsinfo.server:
-                iteminfo = media_chain.iteminfo(server=existsinfo.server, item_id=existsinfo.itemid)
-                if iteminfo:
-                    # 使用 model_dump() 转换为字典格式
-                    item_dict = iteminfo.model_dump(exclude_none=True)
-                    result_items.append(item_dict)
-            
-            if result_items:
-                return json.dumps(result_items, ensure_ascii=False)
-            
-            # 如果找到了但没有详细信息，返回基本信息
-            result_dict = {
-                "type": existsinfo.type.value if existsinfo.type else None,
-                "server": existsinfo.server,
-                "server_type": existsinfo.server_type,
-                "itemid": existsinfo.itemid,
-                "seasons": existsinfo.seasons if existsinfo.seasons else {}
-            }
-            return json.dumps([result_dict], ensure_ascii=False)
-        except Exception as e:
-            logger.error(f"查询媒体库失败: {e}", exc_info=True)
-            return f"查询媒体库时发生错误: {str(e)}"
--- a/app/agent/tools/impl/query_library_latest.py
+++ b/app/agent/tools/impl/query_library_latest.py
@@ -1,86 +0,0 @@
-"""查询媒体服务器最近入库影片工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.mediaserver import MediaServerChain
-from app.helper.service import ServiceConfigHelper
-from app.log import logger
-
-
-class QueryLibraryLatestInput(BaseModel):
-    """查询媒体服务器最近入库影片工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    server: Optional[str] = Field(None, description="Media server name (optional, if not specified queries all enabled media servers)")
-    count: Optional[int] = Field(20, description="Number of items to return (default: 20)")
-
-
-class QueryLibraryLatestTool(MoviePilotTool):
-    name: str = "query_library_latest"
-    description: str = "Query the latest media items added to the media server (Plex, Emby, Jellyfin). Returns recently added movies and TV series with their titles, images, links, and other metadata."
-    args_schema: Type[BaseModel] = QueryLibraryLatestInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        server = kwargs.get("server")
-        count = kwargs.get("count", 20)
-        
-        parts = ["正在查询媒体服务器最近入库影片"]
-        
-        if server:
-            parts.append(f"服务器: {server}")
-        else:
-            parts.append("所有服务器")
-        
-        parts.append(f"数量: {count}条")
-        
-        return " | ".join(parts)
-
-    async def run(self, server: Optional[str] = None, count: Optional[int] = 20, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: server={server}, count={count}")
-        try:
-            media_chain = MediaServerChain()
-            results = []
-            
-            # 如果没有指定服务器，获取所有启用的媒体服务器
-            if not server:
-                mediaservers = ServiceConfigHelper.get_mediaserver_configs()
-                enabled_servers = [ms.name for ms in mediaservers if ms.enabled]
-                
-                if not enabled_servers:
-                    return "未找到启用的媒体服务器"
-                
-                # 遍历所有启用的服务器
-                for server_name in enabled_servers:
-                    latest_items = media_chain.latest(server=server_name, count=count, username=self._username)
-                    if latest_items:
-                        for item in latest_items:
-                            item_dict = item.model_dump(exclude_none=True)
-                            item_dict["server"] = server_name
-                            results.append(item_dict)
-            else:
-                # 查询指定服务器
-                latest_items = media_chain.latest(server=server, count=count, username=self._username)
-                if latest_items:
-                    for item in latest_items:
-                        item_dict = item.model_dump(exclude_none=True)
-                        item_dict["server"] = server
-                        results.append(item_dict)
-            
-            if not results:
-                server_info = f"服务器 {server}" if server else "所有服务器"
-                return f"未找到 {server_info} 的最近入库影片"
-            
-            # 限制返回数量，避免结果过多
-            if len(results) > count:
-                results = results[:count]
-            
-            return json.dumps(results, ensure_ascii=False, indent=2)
-            
-        except Exception as e:
-            logger.error(f"查询媒体服务器最近入库影片失败: {e}", exc_info=True)
-            return f"查询媒体服务器最近入库影片时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_popular_subscribes.py
+++ b/app/agent/tools/impl/query_popular_subscribes.py
@@ -1,152 +0,0 @@
-"""查询热门订阅工具"""
-
-import json
-from typing import Optional, Type
-
-import cn2an
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.core.context import MediaInfo
-from app.helper.subscribe import SubscribeHelper
-from app.log import logger
-from app.schemas.types import MediaType
-
-
-class QueryPopularSubscribesInput(BaseModel):
-    """查询热门订阅工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    stype: str = Field(..., description="Media type: '电影' for films, '电视剧' for television series")
-    page: Optional[int] = Field(1, description="Page number for pagination (default: 1)")
-    count: Optional[int] = Field(30, description="Number of items per page (default: 30)")
-    min_sub: Optional[int] = Field(None, description="Minimum number of subscribers filter (optional, e.g., 5)")
-    genre_id: Optional[int] = Field(None, description="Filter by genre ID (optional)")
-    min_rating: Optional[float] = Field(None, description="Minimum rating filter (optional, e.g., 7.5)")
-    max_rating: Optional[float] = Field(None, description="Maximum rating filter (optional, e.g., 10.0)")
-    sort_type: Optional[str] = Field(None, description="Sort type (optional, e.g., 'count', 'rating')")
-
-
-class QueryPopularSubscribesTool(MoviePilotTool):
-    name: str = "query_popular_subscribes"
-    description: str = "Query popular subscriptions based on user shared data. Shows media with the most subscribers, supports filtering by genre, rating, minimum subscribers, and pagination."
-    args_schema: Type[BaseModel] = QueryPopularSubscribesInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        stype = kwargs.get("stype", "")
-        page = kwargs.get("page", 1)
-        min_sub = kwargs.get("min_sub")
-        min_rating = kwargs.get("min_rating")
-        max_rating = kwargs.get("max_rating")
-        
-        parts = [f"正在查询热门订阅 [{stype}]"]
-        
-        if min_sub:
-            parts.append(f"最少订阅: {min_sub}")
-        if min_rating:
-            parts.append(f"最低评分: {min_rating}")
-        if max_rating:
-            parts.append(f"最高评分: {max_rating}")
-        if page > 1:
-            parts.append(f"第{page}页")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, stype: str,
-                  page: Optional[int] = 1,
-                  count: Optional[int] = 30,
-                  min_sub: Optional[int] = None,
-                  genre_id: Optional[int] = None,
-                  min_rating: Optional[float] = None,
-                  max_rating: Optional[float] = None,
-                  sort_type: Optional[str] = None, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: stype={stype}, page={page}, count={count}, min_sub={min_sub}, "
-            f"genre_id={genre_id}, min_rating={min_rating}, max_rating={max_rating}, sort_type={sort_type}")
-
-        try:
-            if page is None or page < 1:
-                page = 1
-            if count is None or count < 1:
-                count = 30
-
-            subscribe_helper = SubscribeHelper()
-            subscribes = await subscribe_helper.async_get_statistic(
-                stype=stype,
-                page=page,
-                count=count,
-                genre_id=genre_id,
-                min_rating=min_rating,
-                max_rating=max_rating,
-                sort_type=sort_type
-            )
-
-            if not subscribes:
-                return "未找到热门订阅数据（可能订阅统计功能未启用）"
-
-            # 转换为MediaInfo格式并过滤
-            ret_medias = []
-            for sub in subscribes:
-                # 订阅人数
-                subscriber_count = sub.get("count", 0)
-                # 如果设置了最小订阅人数，进行过滤
-                if min_sub and subscriber_count < min_sub:
-                    continue
-
-                media = MediaInfo()
-                media.type = MediaType(sub.get("type"))
-                media.tmdb_id = sub.get("tmdbid")
-                # 处理标题
-                title = sub.get("name")
-                season = sub.get("season")
-                if season and int(season) > 1 and media.tmdb_id:
-                    # 小写数据转大写
-                    season_str = cn2an.an2cn(season, "low")
-                    title = f"{title} 第{season_str}季"
-                media.title = title
-                media.year = sub.get("year")
-                media.douban_id = sub.get("doubanid")
-                media.bangumi_id = sub.get("bangumiid")
-                media.tvdb_id = sub.get("tvdbid")
-                media.imdb_id = sub.get("imdbid")
-                media.season = sub.get("season")
-                media.vote_average = sub.get("vote")
-                media.poster_path = sub.get("poster")
-                media.backdrop_path = sub.get("backdrop")
-                media.popularity = subscriber_count
-                ret_medias.append(media)
-
-            if not ret_medias:
-                return "未找到符合条件的热门订阅"
-
-            # 转换为字典格式，只保留关键信息
-            simplified_medias = []
-            for media in ret_medias:
-                media_dict = media.to_dict()
-                simplified = {
-                    "type": media_dict.get("type"),
-                    "title": media_dict.get("title"),
-                    "year": media_dict.get("year"),
-                    "tmdb_id": media_dict.get("tmdb_id"),
-                    "douban_id": media_dict.get("douban_id"),
-                    "bangumi_id": media_dict.get("bangumi_id"),
-                    "tvdb_id": media_dict.get("tvdb_id"),
-                    "imdb_id": media_dict.get("imdb_id"),
-                    "season": media_dict.get("season"),
-                    "vote_average": media_dict.get("vote_average"),
-                    "poster_path": media_dict.get("poster_path"),
-                    "backdrop_path": media_dict.get("backdrop_path"),
-                    "popularity": media_dict.get("popularity"),  # 订阅人数
-                    "subscriber_count": media_dict.get("popularity")  # 明确标注为订阅人数
-                }
-                simplified_medias.append(simplified)
-
-            result_json = json.dumps(simplified_medias, ensure_ascii=False, indent=2)
-
-            pagination_info = f"第 {page} 页，每页 {count} 条，共 {len(simplified_medias)} 条结果"
-
-            return f"{pagination_info}\n\n{result_json}"
-        except Exception as e:
-            logger.error(f"查询热门订阅失败: {e}", exc_info=True)
-            return f"查询热门订阅时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_rule_groups.py
+++ b/app/agent/tools/impl/query_rule_groups.py
@@ -1,65 +0,0 @@
-"""查询规则组工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.helper.rule import RuleHelper
-from app.log import logger
-
-
-class QueryRuleGroupsInput(BaseModel):
-    """查询规则组工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-
-
-class QueryRuleGroupsTool(MoviePilotTool):
-    name: str = "query_rule_groups"
-    description: str = "Query all filter rule groups available in the system. Rule groups are used to filter torrents when searching or subscribing. Returns rule group names, media types, and categories, but excludes rule_string to keep results concise."
-    args_schema: Type[BaseModel] = QueryRuleGroupsInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        return "正在查询所有规则组"
-
-    async def run(self, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}")
-        
-        try:
-            rule_helper = RuleHelper()
-            rule_groups = rule_helper.get_rule_groups()
-            
-            if not rule_groups:
-                return json.dumps({
-                    "message": "未找到任何规则组",
-                    "rule_groups": []
-                }, ensure_ascii=False, indent=2)
-            
-            # 精简字段，过滤掉 rule_string 避免结果过大
-            simplified_groups = []
-            for group in rule_groups:
-                simplified = {
-                    "name": group.name,
-                    "media_type": group.media_type,
-                    "category": group.category
-                }
-                simplified_groups.append(simplified)
-            
-            result = {
-                "message": f"找到 {len(simplified_groups)} 个规则组",
-                "rule_groups": simplified_groups
-            }
-            
-            return json.dumps(result, ensure_ascii=False, indent=2)
-            
-        except Exception as e:
-            error_message = f"查询规则组失败: {str(e)}"
-            logger.error(f"查询规则组失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message,
-                "rule_groups": []
-            }, ensure_ascii=False)
-
--- a/app/agent/tools/impl/query_schedulers.py
+++ b/app/agent/tools/impl/query_schedulers.py
@@ -1,55 +0,0 @@
-"""查询定时服务工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.log import logger
-from app.scheduler import Scheduler
-
-
-class QuerySchedulersInput(BaseModel):
-    """查询定时服务工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-
-
-class QuerySchedulersTool(MoviePilotTool):
-    name: str = "query_schedulers"
-    description: str = "Query scheduled tasks and list all available scheduler jobs. Shows job status, next run time, and provider information."
-    args_schema: Type[BaseModel] = QuerySchedulersInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """生成友好的提示消息"""
-        return "正在查询定时服务"
-
-    async def run(self, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}")
-        try:
-            scheduler = Scheduler()
-            schedulers = scheduler.list()
-            if schedulers:
-                # 转换为字典列表以便JSON序列化
-                schedulers_list = []
-                for s in schedulers:
-                    schedulers_list.append({
-                        "id": s.id,
-                        "name": s.name,
-                        "provider": s.provider,
-                        "status": s.status,
-                        "next_run": s.next_run
-                    })
-                result_json = json.dumps(schedulers_list, ensure_ascii=False, indent=2)
-                # 限制最多30条结果
-                total_count = len(schedulers_list)
-                if total_count > 30:
-                    limited_schedulers = schedulers_list[:30]
-                    limited_json = json.dumps(limited_schedulers, ensure_ascii=False, indent=2)
-                    return f"注意：查询结果共找到 {total_count} 条，为节省上下文空间，仅显示前 30 条结果。\n\n{limited_json}"
-                return result_json
-            return "未找到定时服务"
-        except Exception as e:
-            logger.error(f"查询定时服务失败: {e}", exc_info=True)
-            return f"查询定时服务时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_site_userdata.py
+++ b/app/agent/tools/impl/query_site_userdata.py
@@ -1,136 +0,0 @@
-"""查询站点用户数据工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.db import AsyncSessionFactory
-from app.db.models.site import Site
-from app.db.models.siteuserdata import SiteUserData
-from app.log import logger
-
-
-class QuerySiteUserdataInput(BaseModel):
-    """查询站点用户数据工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    site_id: int = Field(..., description="The ID of the site to query user data for")
-    workdate: Optional[str] = Field(None, description="Work date to query (optional, format: 'YYYY-MM-DD', if not specified returns latest data)")
-
-
-class QuerySiteUserdataTool(MoviePilotTool):
-    name: str = "query_site_userdata"
-    description: str = "Query user data for a specific site including username, user level, upload/download statistics, seeding information, bonus points, and other account details. Supports querying data for a specific date or latest data."
-    args_schema: Type[BaseModel] = QuerySiteUserdataInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        site_id = kwargs.get("site_id")
-        workdate = kwargs.get("workdate")
-        
-        message = f"正在查询站点 #{site_id} 的用户数据"
-        if workdate:
-            message += f" (日期: {workdate})"
-        else:
-            message += " (最新数据)"
-        
-        return message
-
-    async def run(self, site_id: int, workdate: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: site_id={site_id}, workdate={workdate}")
-        
-        try:
-            # 获取数据库会话
-            async with AsyncSessionFactory() as db:
-                # 获取站点
-                site = await Site.async_get(db, site_id)
-                if not site:
-                    return json.dumps({
-                        "success": False,
-                        "message": f"站点不存在: {site_id}"
-                    }, ensure_ascii=False)
-                
-                # 获取站点用户数据
-                user_data_list = await SiteUserData.async_get_by_domain(
-                    db, 
-                    domain=site.domain, 
-                    workdate=workdate
-                )
-                
-                if not user_data_list:
-                    return json.dumps({
-                        "success": False,
-                        "message": f"站点 {site.name} ({site.domain}) 暂无用户数据",
-                        "site_id": site_id,
-                        "site_name": site.name,
-                        "site_domain": site.domain,
-                        "workdate": workdate
-                    }, ensure_ascii=False)
-                
-                # 格式化用户数据
-                result = {
-                    "success": True,
-                    "site_id": site_id,
-                    "site_name": site.name,
-                    "site_domain": site.domain,
-                    "workdate": workdate,
-                    "data_count": len(user_data_list),
-                    "user_data": []
-                }
-                
-                for user_data in user_data_list:
-                    # 格式化上传/下载量（转换为可读格式）
-                    upload_gb = user_data.upload / (1024 ** 3) if user_data.upload else 0
-                    download_gb = user_data.download / (1024 ** 3) if user_data.download else 0
-                    seeding_size_gb = user_data.seeding_size / (1024 ** 3) if user_data.seeding_size else 0
-                    leeching_size_gb = user_data.leeching_size / (1024 ** 3) if user_data.leeching_size else 0
-                    
-                    user_data_dict = {
-                        "domain": user_data.domain,
-                        "name": user_data.name,
-                        "username": user_data.username,
-                        "userid": user_data.userid,
-                        "user_level": user_data.user_level,
-                        "join_at": user_data.join_at,
-                        "bonus": user_data.bonus,
-                        "upload": user_data.upload,
-                        "upload_gb": round(upload_gb, 2),
-                        "download": user_data.download,
-                        "download_gb": round(download_gb, 2),
-                        "ratio": round(user_data.ratio, 2) if user_data.ratio else 0,
-                        "seeding": int(user_data.seeding) if user_data.seeding else 0,
-                        "leeching": int(user_data.leeching) if user_data.leeching else 0,
-                        "seeding_size": user_data.seeding_size,
-                        "seeding_size_gb": round(seeding_size_gb, 2),
-                        "leeching_size": user_data.leeching_size,
-                        "leeching_size_gb": round(leeching_size_gb, 2),
-                        "seeding_info": user_data.seeding_info if user_data.seeding_info else [],
-                        "message_unread": user_data.message_unread,
-                        "message_unread_contents": user_data.message_unread_contents if user_data.message_unread_contents else [],
-                        "err_msg": user_data.err_msg,
-                        "updated_day": user_data.updated_day,
-                        "updated_time": user_data.updated_time
-                    }
-                    result["user_data"].append(user_data_dict)
-                
-                # 如果有多条数据，只返回最新的（按更新时间排序）
-                if len(result["user_data"]) > 1:
-                    result["user_data"].sort(
-                        key=lambda x: (x.get("updated_day", ""), x.get("updated_time", "")), 
-                        reverse=True
-                    )
-                    result["message"] = f"找到 {len(result['user_data'])} 条数据，显示最新的一条"
-                    result["user_data"] = [result["user_data"][0]]
-                
-                return json.dumps(result, ensure_ascii=False, indent=2)
-        
-        except Exception as e:
-            error_message = f"查询站点用户数据失败: {str(e)}"
-            logger.error(f"查询站点用户数据失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message,
-                "site_id": site_id
-            }, ensure_ascii=False)
-
--- a/app/agent/tools/impl/query_sites.py
+++ b/app/agent/tools/impl/query_sites.py
@@ -1,82 +0,0 @@
-"""查询站点工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.db.site_oper import SiteOper
-from app.log import logger
-
-
-class QuerySitesInput(BaseModel):
-    """查询站点工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    status: Optional[str] = Field("all",
-                                  description="Filter sites by status: 'active' for enabled sites, 'inactive' for disabled sites, 'all' for all sites")
-    name: Optional[str] = Field(None,
-                                description="Filter sites by name (partial match, optional)")
-
-
-class QuerySitesTool(MoviePilotTool):
-    name: str = "query_sites"
-    description: str = "Query site status and list all configured sites. Shows site name, domain, status, priority, and basic configuration. Site priority (pri): smaller values have higher priority (e.g., pri=1 has higher priority than pri=10)."
-    args_schema: Type[BaseModel] = QuerySitesInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        status = kwargs.get("status", "all")
-        name = kwargs.get("name")
-        
-        parts = ["正在查询站点"]
-        
-        if status != "all":
-            status_map = {"active": "已启用", "inactive": "已禁用"}
-            parts.append(f"状态: {status_map.get(status, status)}")
-        
-        if name:
-            parts.append(f"名称: {name}")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, status: Optional[str] = "all", name: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: status={status}, name={name}")
-        try:
-            site_oper = SiteOper()
-            # 获取所有站点（按优先级排序）
-            sites = await site_oper.async_list()
-            filtered_sites = []
-            for site in sites:
-                # 按状态过滤
-                if status == "active" and not site.is_active:
-                    continue
-                if status == "inactive" and site.is_active:
-                    continue
-                # 按名称过滤（部分匹配）
-                if name and name.lower() not in (site.name or "").lower():
-                    continue
-                filtered_sites.append(site)
-            if filtered_sites:
-                # 精简字段，只保留关键信息
-                simplified_sites = []
-                for s in filtered_sites:
-                    simplified = {
-                        "id": s.id,
-                        "name": s.name,
-                        "domain": s.domain,
-                        "url": s.url,
-                        "pri": s.pri,
-                        "is_active": s.is_active,
-                        "downloader": s.downloader,
-                        "proxy": s.proxy,
-                        "timeout": s.timeout
-                    }
-                    simplified_sites.append(simplified)
-                result_json = json.dumps(simplified_sites, ensure_ascii=False, indent=2)
-                return result_json
-            return "未找到相关站点"
-        except Exception as e:
-            logger.error(f"查询站点失败: {e}", exc_info=True)
-            return f"查询站点时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_subscribe_history.py
+++ b/app/agent/tools/impl/query_subscribe_history.py
@@ -1,113 +0,0 @@
-"""查询订阅历史工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.db import AsyncSessionFactory
-from app.db.models.subscribehistory import SubscribeHistory
-from app.log import logger
-
-
-class QuerySubscribeHistoryInput(BaseModel):
-    """查询订阅历史工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    media_type: Optional[str] = Field("all", description="Filter by media type: '电影' for films, '电视剧' for television series, 'all' for all types (default: 'all')")
-    name: Optional[str] = Field(None, description="Filter by media name (partial match, optional)")
-
-
-class QuerySubscribeHistoryTool(MoviePilotTool):
-    name: str = "query_subscribe_history"
-    description: str = "Query subscription history records. Shows completed subscriptions with their details including name, type, rating, completion date, and other subscription information. Supports filtering by media type and name. Returns up to 30 records."
-    args_schema: Type[BaseModel] = QuerySubscribeHistoryInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        media_type = kwargs.get("media_type", "all")
-        name = kwargs.get("name")
-        
-        parts = ["正在查询订阅历史"]
-        
-        if media_type != "all":
-            parts.append(f"类型: {media_type}")
-        if name:
-            parts.append(f"名称: {name}")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, media_type: Optional[str] = "all",
-                  name: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: media_type={media_type}, name={name}")
-
-        try:
-            # 获取数据库会话
-            async with AsyncSessionFactory() as db:
-                # 根据类型查询
-                if media_type == "all":
-                    # 查询所有类型，需要分别查询电影和电视剧
-                    movie_history = await SubscribeHistory.async_list_by_type(db, mtype="movie", page=1, count=100)
-                    tv_history = await SubscribeHistory.async_list_by_type(db, mtype="tv", page=1, count=100)
-                    all_history = list(movie_history) + list(tv_history)
-                    # 按日期排序
-                    all_history.sort(key=lambda x: x.date or "", reverse=True)
-                else:
-                    # 查询指定类型
-                    all_history = await SubscribeHistory.async_list_by_type(db, mtype=media_type, page=1, count=100)
-                
-                # 按名称过滤
-                filtered_history = []
-                if name:
-                    name_lower = name.lower()
-                    for record in all_history:
-                        if record.name and name_lower in record.name.lower():
-                            filtered_history.append(record)
-                else:
-                    filtered_history = all_history
-                
-                if not filtered_history:
-                    return "未找到相关订阅历史记录"
-                
-                # 限制最多30条
-                total_count = len(filtered_history)
-                limited_history = filtered_history[:30]
-                
-                # 转换为字典格式，只保留关键信息
-                simplified_records = []
-                for record in limited_history:
-                    simplified = {
-                        "id": record.id,
-                        "name": record.name,
-                        "year": record.year,
-                        "type": record.type,
-                        "season": record.season,
-                        "tmdbid": record.tmdbid,
-                        "doubanid": record.doubanid,
-                        "bangumiid": record.bangumiid,
-                        "poster": record.poster,
-                        "vote": record.vote,
-                        "total_episode": record.total_episode,
-                        "date": record.date,
-                        "username": record.username
-                    }
-                    # 添加过滤规则信息（如果有）
-                    if record.filter:
-                        simplified["filter"] = record.filter
-                    if record.quality:
-                        simplified["quality"] = record.quality
-                    if record.resolution:
-                        simplified["resolution"] = record.resolution
-                    simplified_records.append(simplified)
-                
-                result_json = json.dumps(simplified_records, ensure_ascii=False, indent=2)
-                
-                # 如果结果被裁剪，添加提示信息
-                if total_count > 30:
-                    return f"注意：查询结果共找到 {total_count} 条，为节省上下文空间，仅显示前 30 条结果。\n\n{result_json}"
-                
-                return result_json
-        except Exception as e:
-            logger.error(f"查询订阅历史失败: {e}", exc_info=True)
-            return f"查询订阅历史时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_subscribe_shares.py
+++ b/app/agent/tools/impl/query_subscribe_shares.py
@@ -1,113 +0,0 @@
-"""查询订阅分享工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.helper.subscribe import SubscribeHelper
-from app.log import logger
-
-
-class QuerySubscribeSharesInput(BaseModel):
-    """查询订阅分享工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    name: Optional[str] = Field(None, description="Filter shares by media name (partial match, optional)")
-    page: Optional[int] = Field(1, description="Page number for pagination (default: 1)")
-    count: Optional[int] = Field(30, description="Number of items per page (default: 30)")
-    genre_id: Optional[int] = Field(None, description="Filter by genre ID (optional)")
-    min_rating: Optional[float] = Field(None, description="Minimum rating filter (optional, e.g., 7.5)")
-    max_rating: Optional[float] = Field(None, description="Maximum rating filter (optional, e.g., 10.0)")
-    sort_type: Optional[str] = Field(None, description="Sort type (optional, e.g., 'count', 'rating')")
-
-
-class QuerySubscribeSharesTool(MoviePilotTool):
-    name: str = "query_subscribe_shares"
-    description: str = "Query shared subscriptions from other users. Shows popular subscriptions shared by the community with filtering and pagination support."
-    args_schema: Type[BaseModel] = QuerySubscribeSharesInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        name = kwargs.get("name")
-        page = kwargs.get("page", 1)
-        min_rating = kwargs.get("min_rating")
-        max_rating = kwargs.get("max_rating")
-        
-        parts = ["正在查询订阅分享"]
-        
-        if name:
-            parts.append(f"名称: {name}")
-        if min_rating:
-            parts.append(f"最低评分: {min_rating}")
-        if max_rating:
-            parts.append(f"最高评分: {max_rating}")
-        if page > 1:
-            parts.append(f"第{page}页")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, name: Optional[str] = None,
-                  page: Optional[int] = 1,
-                  count: Optional[int] = 30,
-                  genre_id: Optional[int] = None,
-                  min_rating: Optional[float] = None,
-                  max_rating: Optional[float] = None,
-                  sort_type: Optional[str] = None, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: name={name}, page={page}, count={count}, genre_id={genre_id}, "
-            f"min_rating={min_rating}, max_rating={max_rating}, sort_type={sort_type}")
-
-        try:
-            if page is None or page < 1:
-                page = 1
-            if count is None or count < 1:
-                count = 30
-
-            subscribe_helper = SubscribeHelper()
-            shares = await subscribe_helper.async_get_shares(
-                name=name,
-                page=page,
-                count=count,
-                genre_id=genre_id,
-                min_rating=min_rating,
-                max_rating=max_rating,
-                sort_type=sort_type
-            )
-
-            if not shares:
-                return "未找到订阅分享数据（可能订阅分享功能未启用）"
-
-            # 简化字段，只保留关键信息
-            simplified_shares = []
-            for share in shares:
-                simplified = {
-                    "id": share.get("id"),
-                    "name": share.get("name"),
-                    "year": share.get("year"),
-                    "type": share.get("type"),
-                    "season": share.get("season"),
-                    "tmdbid": share.get("tmdbid"),
-                    "doubanid": share.get("doubanid"),
-                    "bangumiid": share.get("bangumiid"),
-                    "poster": share.get("poster"),
-                    "vote": share.get("vote"),
-                    "share_title": share.get("share_title"),
-                    "share_comment": share.get("share_comment"),
-                    "share_user": share.get("share_user"),
-                    "fork_count": share.get("fork_count", 0)
-                }
-                # 截断过长的描述
-                if simplified.get("description") and len(simplified["description"]) > 200:
-                    simplified["description"] = simplified["description"][:200] + "..."
-                simplified_shares.append(simplified)
-
-            result_json = json.dumps(simplified_shares, ensure_ascii=False, indent=2)
-
-            pagination_info = f"第 {page} 页，每页 {count} 条，共 {len(simplified_shares)} 条结果"
-
-            return f"{pagination_info}\n\n{result_json}"
-        except Exception as e:
-            logger.error(f"查询订阅分享失败: {e}", exc_info=True)
-            return f"查询订阅分享时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/query_subscribes.py
+++ b/app/agent/tools/impl/query_subscribes.py
@@ -1,90 +0,0 @@
-"""查询订阅工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.db.subscribe_oper import SubscribeOper
-from app.log import logger
-
-
-class QuerySubscribesInput(BaseModel):
-    """查询订阅工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    status: Optional[str] = Field("all",
-                                  description="Filter subscriptions by status: 'R' for enabled subscriptions, 'P' for disabled ones, 'all' for all subscriptions")
-    media_type: Optional[str] = Field("all",
-                                      description="Filter by media type: '电影' for films, '电视剧' for television series, 'all' for all types")
-
-
-class QuerySubscribesTool(MoviePilotTool):
-    name: str = "query_subscribes"
-    description: str = "Query subscription status and list all user subscriptions. Shows active subscriptions, their download status, and configuration details."
-    args_schema: Type[BaseModel] = QuerySubscribesInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        status = kwargs.get("status", "all")
-        media_type = kwargs.get("media_type", "all")
-        
-        parts = ["正在查询订阅"]
-        
-        # 根据状态过滤条件生成提示
-        if status != "all":
-            status_map = {"R": "已启用", "P": "已禁用"}
-            parts.append(f"状态: {status_map.get(status, status)}")
-        
-        # 根据媒体类型过滤条件生成提示
-        if media_type != "all":
-            parts.append(f"类型: {media_type}")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, status: Optional[str] = "all", media_type: Optional[str] = "all", **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: status={status}, media_type={media_type}")
-        try:
-            subscribe_oper = SubscribeOper()
-            subscribes = await subscribe_oper.async_list()
-            filtered_subscribes = []
-            for sub in subscribes:
-                if status != "all" and sub.state != status:
-                    continue
-                if media_type != "all" and sub.type != media_type:
-                    continue
-                filtered_subscribes.append(sub)
-            if filtered_subscribes:
-                # 限制最多50条结果
-                total_count = len(filtered_subscribes)
-                limited_subscribes = filtered_subscribes[:50]
-                # 精简字段，只保留关键信息
-                simplified_subscribes = []
-                for s in limited_subscribes:
-                    simplified = {
-                        "id": s.id,
-                        "name": s.name,
-                        "year": s.year,
-                        "type": s.type,
-                        "season": s.season,
-                        "tmdbid": s.tmdbid,
-                        "doubanid": s.doubanid,
-                        "bangumiid": s.bangumiid,
-                        "poster": s.poster,
-                        "vote": s.vote,
-                        "state": s.state,
-                        "total_episode": s.total_episode,
-                        "lack_episode": s.lack_episode,
-                        "last_update": s.last_update,
-                        "username": s.username
-                    }
-                    simplified_subscribes.append(simplified)
-                result_json = json.dumps(simplified_subscribes, ensure_ascii=False, indent=2)
-                # 如果结果被裁剪，添加提示信息
-                if total_count > 50:
-                    return f"注意：查询结果共找到 {total_count} 条，为节省上下文空间，仅显示前 50 条结果。\n\n{result_json}"
-                return result_json
-            return "未找到相关订阅"
-        except Exception as e:
-            logger.error(f"查询订阅失败: {e}", exc_info=True)
-            return f"查询订阅时发生错误: {str(e)}"
--- a/app/agent/tools/impl/query_transfer_history.py
+++ b/app/agent/tools/impl/query_transfer_history.py
@@ -1,133 +0,0 @@
-"""查询整理历史记录工具"""
-
-import json
-from typing import Optional, Type
-
-import jieba
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.db import AsyncSessionFactory
-from app.db.models.transferhistory import TransferHistory
-from app.log import logger
-
-
-class QueryTransferHistoryInput(BaseModel):
-    """查询整理历史记录工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    title: Optional[str] = Field(None, description="Search by title (optional, supports partial match)")
-    status: Optional[str] = Field("all",
-                                  description="Filter by status: 'success' for successful transfers, 'failed' for failed transfers, 'all' for all records (default: 'all')")
-    page: Optional[int] = Field(1, description="Page number for pagination (default: 1, each page contains 30 records)")
-
-
-class QueryTransferHistoryTool(MoviePilotTool):
-    name: str = "query_transfer_history"
-    description: str = "Query file transfer history records. Shows transfer status, source and destination paths, media information, and transfer details. Supports filtering by title and status."
-    args_schema: Type[BaseModel] = QueryTransferHistoryInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        title = kwargs.get("title")
-        status = kwargs.get("status", "all")
-        page = kwargs.get("page", 1)
-
-        parts = ["正在查询整理历史"]
-
-        if title:
-            parts.append(f"标题: {title}")
-        if status != "all":
-            status_map = {"success": "成功", "failed": "失败"}
-            parts.append(f"状态: {status_map.get(status, status)}")
-        if page > 1:
-            parts.append(f"第{page}页")
-
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, title: Optional[str] = None,
-                  status: Optional[str] = "all",
-                  page: Optional[int] = 1, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: title={title}, status={status}, page={page}")
-
-        try:
-            # 处理状态参数
-            status_bool = None
-            if status == "success":
-                status_bool = True
-            elif status == "failed":
-                status_bool = False
-
-            # 处理页码参数
-            if page is None or page < 1:
-                page = 1
-
-            # 每页记录数
-            count = 50
-
-            # 获取数据库会话
-            async with AsyncSessionFactory() as db:
-                # 处理标题搜索
-                if title:
-                    # 使用 jieba 分词处理标题
-                    words = jieba.cut(title, HMM=False)
-                    title_search = "%".join(words)
-                    # 查询记录
-                    result = await TransferHistory.async_list_by_title(
-                        db, title=title_search, page=page, count=count, status=status_bool
-                    )
-                    total = await TransferHistory.async_count_by_title(
-                        db, title=title_search, status=status_bool
-                    )
-                else:
-                    # 查询所有记录
-                    result = await TransferHistory.async_list_by_page(
-                        db, page=page, count=count, status=status_bool
-                    )
-                    total = await TransferHistory.async_count(db, status=status_bool)
-
-                if not result:
-                    return "未找到相关整理历史记录"
-
-                # 转换为字典格式，只保留关键信息
-                simplified_records = []
-                for record in result:
-                    simplified = {
-                        "id": record.id,
-                        "title": record.title,
-                        "year": record.year,
-                        "type": record.type,
-                        "category": record.category,
-                        "seasons": record.seasons,
-                        "episodes": record.episodes,
-                        "src": record.src,
-                        "dest": record.dest,
-                        "mode": record.mode,
-                        "status": "成功" if record.status else "失败",
-                        "date": record.date,
-                        "downloader": record.downloader,
-                        "download_hash": record.download_hash
-                    }
-                    # 如果失败，添加错误信息
-                    if not record.status and record.errmsg:
-                        simplified["errmsg"] = record.errmsg
-                    # 添加媒体ID信息（如果有）
-                    if record.tmdbid:
-                        simplified["tmdbid"] = record.tmdbid
-                    if record.imdbid:
-                        simplified["imdbid"] = record.imdbid
-                    if record.doubanid:
-                        simplified["doubanid"] = record.doubanid
-                    simplified_records.append(simplified)
-
-                result_json = json.dumps(simplified_records, ensure_ascii=False, indent=2)
-
-                # 计算总页数
-                total_pages = (total + count - 1) // count if total > 0 else 1
-
-                # 构建分页信息
-                pagination_info = f"第 {page}/{total_pages} 页，共 {total} 条记录（每页 {count} 条）"
-
-                return f"{pagination_info}\n\n{result_json}"
-        except Exception as e:
-            logger.error(f"查询整理历史记录失败: {e}", exc_info=True)
-            return f"查询整理历史记录时发生错误: {str(e)}"
--- a/app/agent/tools/impl/query_workflows.py
+++ b/app/agent/tools/impl/query_workflows.py
@@ -1,128 +0,0 @@
-"""查询工作流工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.db import AsyncSessionFactory
-from app.db.workflow_oper import WorkflowOper
-from app.log import logger
-
-
-class QueryWorkflowsInput(BaseModel):
-    """查询工作流工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    state: Optional[str] = Field("all", description="Filter workflows by state: 'W' for waiting, 'R' for running, 'P' for paused, 'S' for success, 'F' for failed, 'all' for all workflows (default: 'all')")
-    name: Optional[str] = Field(None, description="Filter workflows by name (partial match, optional)")
-    trigger_type: Optional[str] = Field("all", description="Filter workflows by trigger type: 'timer' for scheduled, 'event' for event-triggered, 'manual' for manual, 'all' for all types (default: 'all')")
-
-
-class QueryWorkflowsTool(MoviePilotTool):
-    name: str = "query_workflows"
-    description: str = "Query workflow list and status. Shows workflow name, description, trigger type, state, execution count, and other workflow details. Supports filtering by state, name, and trigger type."
-    args_schema: Type[BaseModel] = QueryWorkflowsInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据查询参数生成友好的提示消息"""
-        state = kwargs.get("state", "all")
-        name = kwargs.get("name")
-        trigger_type = kwargs.get("trigger_type", "all")
-        
-        parts = ["正在查询工作流"]
-        
-        if state != "all":
-            state_map = {"W": "等待", "R": "运行中", "P": "暂停", "S": "成功", "F": "失败"}
-            parts.append(f"状态: {state_map.get(state, state)}")
-        
-        if trigger_type != "all":
-            trigger_map = {"timer": "定时触发", "event": "事件触发", "manual": "手动触发"}
-            parts.append(f"触发类型: {trigger_map.get(trigger_type, trigger_type)}")
-        
-        if name:
-            parts.append(f"名称: {name}")
-        
-        return " | ".join(parts) if len(parts) > 1 else parts[0]
-
-    async def run(self, state: Optional[str] = "all",
-                  name: Optional[str] = None,
-                  trigger_type: Optional[str] = "all", **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: state={state}, name={name}, trigger_type={trigger_type}")
-
-        try:
-            # 获取数据库会话
-            async with AsyncSessionFactory() as db:
-                workflow_oper = WorkflowOper(db)
-                workflows = await workflow_oper.async_list()
-                
-                # 过滤工作流
-                filtered_workflows = []
-                for wf in workflows:
-                    # 按状态过滤
-                    if state != "all" and wf.state != state:
-                        continue
-                    
-                    # 按触发类型过滤
-                    if trigger_type != "all":
-                        if trigger_type == "timer" and wf.trigger_type not in ["timer", None]:
-                            continue
-                        elif trigger_type == "event" and wf.trigger_type != "event":
-                            continue
-                        elif trigger_type == "manual" and wf.trigger_type != "manual":
-                            continue
-                    
-                    # 按名称过滤（部分匹配）
-                    if name and wf.name and name.lower() not in wf.name.lower():
-                        continue
-                    
-                    filtered_workflows.append(wf)
-                
-                if not filtered_workflows:
-                    return "未找到相关工作流"
-                
-                # 转换为字典格式，只保留关键信息
-                simplified_workflows = []
-                for wf in filtered_workflows:
-                    # 状态说明
-                    state_map = {
-                        "W": "等待",
-                        "R": "运行中",
-                        "P": "暂停",
-                        "S": "成功",
-                        "F": "失败"
-                    }
-                    state_desc = state_map.get(wf.state, wf.state)
-                    
-                    # 触发类型说明
-                    trigger_type_map = {
-                        "timer": "定时触发",
-                        "event": "事件触发",
-                        "manual": "手动触发"
-                    }
-                    trigger_type_desc = trigger_type_map.get(wf.trigger_type, wf.trigger_type or "定时触发")
-                    
-                    simplified = {
-                        "id": wf.id,
-                        "name": wf.name,
-                        "description": wf.description,
-                        "trigger_type": trigger_type_desc,
-                        "state": state_desc,
-                        "run_count": wf.run_count,
-                        "timer": wf.timer,
-                        "event_type": wf.event_type,
-                        "add_time": wf.add_time,
-                        "last_time": wf.last_time,
-                        "current_action": wf.current_action
-                    }
-                    # 如果有结果，添加结果信息
-                    if wf.result:
-                        simplified["result"] = wf.result
-                    simplified_workflows.append(simplified)
-                
-                result_json = json.dumps(simplified_workflows, ensure_ascii=False, indent=2)
-                return result_json
-        except Exception as e:
-            logger.error(f"查询工作流失败: {e}", exc_info=True)
-            return f"查询工作流时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/recognize_media.py
+++ b/app/agent/tools/impl/recognize_media.py
@@ -1,162 +0,0 @@
-"""识别媒体信息工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.media import MediaChain
-from app.core.context import Context
-from app.core.metainfo import MetaInfo
-from app.log import logger
-
-
-class RecognizeMediaInput(BaseModel):
-    """识别媒体信息工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    title: Optional[str] = Field(None, description="The title of the torrent/media to recognize (required for torrent recognition)")
-    subtitle: Optional[str] = Field(None, description="The subtitle or description of the torrent (optional, helps improve recognition accuracy)")
-    path: Optional[str] = Field(None, description="The file path to recognize (required for file recognition, mutually exclusive with title)")
-
-
-class RecognizeMediaTool(MoviePilotTool):
-    name: str = "recognize_media"
-    description: str = "Extract/identify media information from torrent titles or file paths (NOT database search). Supports two modes: 1) Extract from torrent title and optional subtitle, 2) Extract from file path. Returns detailed media information. Use 'search_media' to search TMDB database, or 'scrape_metadata' to generate metadata files for existing files."
-    args_schema: Type[BaseModel] = RecognizeMediaInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据识别参数生成友好的提示消息"""
-        title = kwargs.get("title")
-        subtitle = kwargs.get("subtitle")
-        path = kwargs.get("path")
-        
-        if path:
-            message = f"正在识别文件媒体信息: {path}"
-        elif title:
-            message = f"正在识别种子媒体信息: {title}"
-            if subtitle:
-                message += f" ({subtitle})"
-        else:
-            message = "正在识别媒体信息"
-        
-        return message
-
-    async def run(self, title: Optional[str] = None, subtitle: Optional[str] = None,
-                  path: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: title={title}, subtitle={subtitle}, path={path}")
-        
-        try:
-            media_chain = MediaChain()
-            context = None
-            
-            # 根据提供的参数选择识别方式
-            if path:
-                # 文件路径识别
-                if not path:
-                    return json.dumps({
-                        "success": False,
-                        "message": "文件路径不能为空"
-                    }, ensure_ascii=False)
-                
-                context = await media_chain.async_recognize_by_path(path)
-                if context:
-                    return self._format_context_result(context, "文件")
-                else:
-                    return json.dumps({
-                        "success": False,
-                        "message": f"无法识别文件媒体信息: {path}",
-                        "path": path
-                    }, ensure_ascii=False)
-            
-            elif title:
-                # 种子标题识别
-                metainfo = MetaInfo(title, subtitle)
-                mediainfo = await media_chain.async_recognize_by_meta(metainfo)
-                if mediainfo:
-                    context = Context(meta_info=metainfo, media_info=mediainfo)
-                    return self._format_context_result(context, "种子")
-                else:
-                    return json.dumps({
-                        "success": False,
-                        "message": f"无法识别种子媒体信息: {title}",
-                        "title": title,
-                        "subtitle": subtitle
-                    }, ensure_ascii=False)
-            
-            else:
-                return json.dumps({
-                    "success": False,
-                    "message": "必须提供 title（标题）或 path（文件路径）参数之一"
-                }, ensure_ascii=False)
-        
-        except Exception as e:
-            error_message = f"识别媒体信息失败: {str(e)}"
-            logger.error(f"识别媒体信息失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message
-            }, ensure_ascii=False)
-
-    def _format_context_result(self, context: Context, source_type: str) -> str:
-        """格式化识别结果为JSON字符串"""
-        if not context:
-            return json.dumps({
-                "success": False,
-                "message": "识别结果为空"
-            }, ensure_ascii=False)
-        
-        context_dict = context.to_dict()
-        media_info = context_dict.get("media_info")
-        meta_info = context_dict.get("meta_info")
-        
-        # 构建简化的结果
-        result = {
-            "success": True,
-            "source_type": source_type,
-            "media_info": None,
-            "meta_info": None
-        }
-        
-        # 处理媒体信息
-        if media_info:
-            result["media_info"] = {
-                "title": media_info.get("title"),
-                "en_title": media_info.get("en_title"),
-                "year": media_info.get("year"),
-                "type": media_info.get("type"),
-                "season": media_info.get("season"),
-                "tmdb_id": media_info.get("tmdb_id"),
-                "imdb_id": media_info.get("imdb_id"),
-                "douban_id": media_info.get("douban_id"),
-                "bangumi_id": media_info.get("bangumi_id"),
-                "overview": media_info.get("overview"),
-                "vote_average": media_info.get("vote_average"),
-                "poster_path": media_info.get("poster_path"),
-                "backdrop_path": media_info.get("backdrop_path"),
-                "detail_link": media_info.get("detail_link"),
-                "title_year": media_info.get("title_year"),
-                "source": media_info.get("source")
-            }
-        
-        # 处理元数据信息
-        if meta_info:
-            result["meta_info"] = {
-                "name": meta_info.get("name"),
-                "title": meta_info.get("title"),
-                "year": meta_info.get("year"),
-                "type": meta_info.get("type"),
-                "begin_season": meta_info.get("begin_season"),
-                "end_season": meta_info.get("end_season"),
-                "begin_episode": meta_info.get("begin_episode"),
-                "end_episode": meta_info.get("end_episode"),
-                "total_episode": meta_info.get("total_episode"),
-                "part": meta_info.get("part"),
-                "season_episode": meta_info.get("season_episode"),
-                "episode_list": meta_info.get("episode_list"),
-                "tmdbid": meta_info.get("tmdbid"),
-                "doubanid": meta_info.get("doubanid")
-            }
-        
-        return json.dumps(result, ensure_ascii=False, indent=2)
-
--- a/app/agent/tools/impl/run_scheduler.py
+++ b/app/agent/tools/impl/run_scheduler.py
@@ -1,53 +0,0 @@
-"""运行定时服务工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.log import logger
-from app.scheduler import Scheduler
-
-
-class RunSchedulerInput(BaseModel):
-    """运行定时服务工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    job_id: str = Field(..., description="The ID of the scheduled job to run (can be obtained from query_schedulers tool)")
-
-
-class RunSchedulerTool(MoviePilotTool):
-    name: str = "run_scheduler"
-    description: str = "Manually trigger a scheduled task to run immediately. This will execute the specified scheduler job by its ID."
-    args_schema: Type[BaseModel] = RunSchedulerInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据运行参数生成友好的提示消息"""
-        job_id = kwargs.get("job_id", "")
-        return f"正在运行定时服务 (ID: {job_id})"
-
-    async def run(self, job_id: str, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: job_id={job_id}")
-
-        try:
-            scheduler = Scheduler()
-            # 检查定时服务是否存在
-            schedulers = scheduler.list()
-            job_exists = False
-            job_name = None
-            for s in schedulers:
-                if s.id == job_id:
-                    job_exists = True
-                    job_name = s.name
-                    break
-            
-            if not job_exists:
-                return f"定时服务 ID {job_id} 不存在，请使用 query_schedulers 工具查询可用的定时服务"
-            
-            # 运行定时服务
-            scheduler.start(job_id)
-            
-            return f"成功触发定时服务：{job_name} (ID: {job_id})"
-        except Exception as e:
-            logger.error(f"运行定时服务失败: {e}", exc_info=True)
-            return f"运行定时服务时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/run_workflow.py
+++ b/app/agent/tools/impl/run_workflow.py
@@ -1,72 +0,0 @@
-"""执行工作流工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.workflow import WorkflowChain
-from app.db import AsyncSessionFactory
-from app.db.workflow_oper import WorkflowOper
-from app.log import logger
-
-
-class RunWorkflowInput(BaseModel):
-    """执行工作流工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    workflow_identifier: str = Field(..., description="Workflow identifier: can be workflow ID (integer as string) or workflow name")
-    from_begin: Optional[bool] = Field(True, description="Whether to run workflow from the beginning (default: True, if False will continue from last executed action)")
-
-
-class RunWorkflowTool(MoviePilotTool):
-    name: str = "run_workflow"
-    description: str = "Execute a specific workflow manually. Can run workflow by ID or name. Supports running from the beginning or continuing from the last executed action."
-    args_schema: Type[BaseModel] = RunWorkflowInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据工作流参数生成友好的提示消息"""
-        workflow_identifier = kwargs.get("workflow_identifier", "")
-        from_begin = kwargs.get("from_begin", True)
-        
-        message = f"正在执行工作流: {workflow_identifier}"
-        if not from_begin:
-            message += " (从上次位置继续)"
-        else:
-            message += " (从头开始)"
-        
-        return message
-
-    async def run(self, workflow_identifier: str,
-                  from_begin: Optional[bool] = True, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: workflow_identifier={workflow_identifier}, from_begin={from_begin}")
-
-        try:
-            # 获取数据库会话
-            async with AsyncSessionFactory() as db:
-                workflow_oper = WorkflowOper(db)
-                
-                # 尝试解析为工作流ID
-                workflow = None
-                if workflow_identifier.isdigit():
-                    # 如果是数字，尝试作为工作流ID查询
-                    workflow = await workflow_oper.async_get(int(workflow_identifier))
-                
-                # 如果不是ID或ID查询失败，尝试按名称查询
-                if not workflow:
-                    workflow = await workflow_oper.async_get_by_name(workflow_identifier)
-                
-                if not workflow:
-                    return f"未找到工作流：{workflow_identifier}，请使用 query_workflows 工具查询可用的工作流"
-                
-                # 执行工作流
-                workflow_chain = WorkflowChain()
-                state, errmsg = workflow_chain.process(workflow.id, from_begin=from_begin)
-                
-                if not state:
-                    return f"执行工作流失败：{workflow.name} (ID: {workflow.id})\n错误原因：{errmsg}"
-                else:
-                    return f"工作流执行成功：{workflow.name} (ID: {workflow.id})"
-        except Exception as e:
-            logger.error(f"执行工作流失败: {e}", exc_info=True)
-            return f"执行工作流时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/scrape_metadata.py
+++ b/app/agent/tools/impl/scrape_metadata.py
@@ -1,119 +0,0 @@
-"""刮削媒体元数据工具"""
-
-import json
-from pathlib import Path
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.media import MediaChain
-from app.core.config import global_vars
-from app.core.metainfo import MetaInfoPath
-from app.log import logger
-from app.schemas import FileItem
-
-
-class ScrapeMetadataInput(BaseModel):
-    """刮削媒体元数据工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    path: str = Field(...,
-                      description="Path to the file or directory to scrape metadata for (e.g., '/path/to/file.mkv' or '/path/to/directory')")
-    storage: Optional[str] = Field("local",
-                                   description="Storage type: 'local' for local storage, 'smb', 'alist', etc. for remote storage (default: 'local')")
-    overwrite: Optional[bool] = Field(False,
-                                      description="Whether to overwrite existing metadata files (default: False)")
-
-
-class ScrapeMetadataTool(MoviePilotTool):
-    name: str = "scrape_metadata"
-    description: str = "Generate metadata files (NFO files, posters, backgrounds, etc.) for existing media files or directories. Automatically recognizes media information from the file path and creates metadata files. Supports both local and remote storage. Use 'search_media' to search TMDB database, or 'recognize_media' to extract info from torrent titles/file paths without generating files."
-    args_schema: Type[BaseModel] = ScrapeMetadataInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据刮削参数生成友好的提示消息"""
-        path = kwargs.get("path", "")
-        storage = kwargs.get("storage", "local")
-        overwrite = kwargs.get("overwrite", False)
-
-        message = f"正在刮削媒体元数据: {path}"
-        if storage != "local":
-            message += f" [存储: {storage}]"
-        if overwrite:
-            message += " [覆盖模式]"
-
-        return message
-
-    async def run(self, path: str, storage: Optional[str] = "local",
-                  overwrite: Optional[bool] = False, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: path={path}, storage={storage}, overwrite={overwrite}")
-
-        try:
-            # 验证路径
-            if not path:
-                return json.dumps({
-                    "success": False,
-                    "message": "刮削路径不能为空"
-                }, ensure_ascii=False)
-
-            # 创建 FileItem
-            fileitem = FileItem(
-                storage=storage,
-                path=path,
-                type="file" if Path(path).suffix else "dir"
-            )
-
-            # 检查本地存储路径是否存在
-            if storage == "local":
-                scrape_path = Path(path)
-                if not scrape_path.exists():
-                    return json.dumps({
-                        "success": False,
-                        "message": f"刮削路径不存在: {path}"
-                    }, ensure_ascii=False)
-
-            # 识别媒体信息
-            media_chain = MediaChain()
-            scrape_path = Path(path)
-            meta = MetaInfoPath(scrape_path)
-            mediainfo = await media_chain.async_recognize_by_meta(meta)
-
-            if not mediainfo:
-                return json.dumps({
-                    "success": False,
-                    "message": f"刮削失败，无法识别媒体信息: {path}",
-                    "path": path
-                }, ensure_ascii=False)
-
-            # 在线程池中执行同步的刮削操作
-            await global_vars.loop.run_in_executor(
-                None,
-                lambda: media_chain.scrape_metadata(
-                    fileitem=fileitem,
-                    meta=meta,
-                    mediainfo=mediainfo,
-                    overwrite=overwrite
-                )
-            )
-
-            return json.dumps({
-                "success": True,
-                "message": f"{path} 刮削完成",
-                "path": path,
-                "media_info": {
-                    "title": mediainfo.title,
-                    "year": mediainfo.year,
-                    "type": mediainfo.type.value if mediainfo.type else None,
-                    "tmdb_id": mediainfo.tmdb_id,
-                    "season": mediainfo.season
-                }
-            }, ensure_ascii=False, indent=2)
-
-        except Exception as e:
-            error_message = f"刮削媒体元数据失败: {str(e)}"
-            logger.error(f"刮削媒体元数据失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message,
-                "path": path
-            }, ensure_ascii=False)
--- a/app/agent/tools/impl/search_media.py
+++ b/app/agent/tools/impl/search_media.py
@@ -1,104 +0,0 @@
-"""搜索媒体工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.media import MediaChain
-from app.log import logger
-from app.schemas.types import MediaType
-
-
-class SearchMediaInput(BaseModel):
-    """搜索媒体工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    title: str = Field(..., description="The title of the media to search for (e.g., 'The Matrix', 'Breaking Bad')")
-    year: Optional[str] = Field(None, description="Release year of the media (optional, helps narrow down results)")
-    media_type: Optional[str] = Field(None,
-                                      description="Type of media content: '电影' for films, '电视剧' for television series or anime series")
-    season: Optional[int] = Field(None,
-                                  description="Season number for TV shows and anime (optional, only applicable for series)")
-
-
-class SearchMediaTool(MoviePilotTool):
-    name: str = "search_media"
-    description: str = "Search TMDB database for media resources (movies, TV shows, anime, etc.) by title, year, type, and other criteria. Returns detailed media information from TMDB. Use 'recognize_media' to extract info from torrent titles/file paths, or 'scrape_metadata' to generate metadata files."
-    args_schema: Type[BaseModel] = SearchMediaInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据搜索参数生成友好的提示消息"""
-        title = kwargs.get("title", "")
-        year = kwargs.get("year")
-        media_type = kwargs.get("media_type")
-        season = kwargs.get("season")
-        
-        message = f"正在搜索媒体: {title}"
-        if year:
-            message += f" ({year})"
-        if media_type:
-            message += f" [{media_type}]"
-        if season:
-            message += f" 第{season}季"
-        
-        return message
-
-    async def run(self, title: str, year: Optional[str] = None,
-                  media_type: Optional[str] = None, season: Optional[int] = None, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: title={title}, year={year}, media_type={media_type}, season={season}")
-
-        try:
-            media_chain = MediaChain()
-            # 使用 MediaChain.search 方法
-            meta, results = await media_chain.async_search(title=title)
-
-            # 过滤结果
-            if results:
-                filtered_results = []
-                for result in results:
-                    if year and result.year != year:
-                        continue
-                    if media_type:
-                        if result.type != MediaType(media_type):
-                            continue
-                    if season and result.season != season:
-                        continue
-                    filtered_results.append(result)
-
-                if filtered_results:
-                    # 限制最多30条结果
-                    total_count = len(filtered_results)
-                    limited_results = filtered_results[:30]
-                    # 精简字段，只保留关键信息
-                    simplified_results = []
-                    for r in limited_results:
-                        simplified = {
-                            "title": r.title,
-                            "en_title": r.en_title,
-                            "year": r.year,
-                            "type": r.type.value if r.type else None,
-                            "season": r.season,
-                            "tmdb_id": r.tmdb_id,
-                            "imdb_id": r.imdb_id,
-                            "douban_id": r.douban_id,
-                            "overview": r.overview[:200] + "..." if r.overview and len(r.overview) > 200 else r.overview,
-                            "vote_average": r.vote_average,
-                            "poster_path": r.poster_path,
-                            "detail_link": r.detail_link
-                        }
-                        simplified_results.append(simplified)
-                    result_json = json.dumps(simplified_results, ensure_ascii=False, indent=2)
-                    # 如果结果被裁剪，添加提示信息
-                    if total_count > 30:
-                        return f"注意：搜索结果共找到 {total_count} 条，为节省上下文空间，仅显示前 30 条结果。\n\n{result_json}"
-                    return result_json
-                else:
-                    return f"未找到符合条件的媒体资源: {title}"
-            else:
-                return f"未找到相关媒体资源: {title}"
-        except Exception as e:
-            error_message = f"搜索媒体失败: {str(e)}"
-            logger.error(f"搜索媒体失败: {e}", exc_info=True)
-            return error_message
--- a/app/agent/tools/impl/search_person.py
+++ b/app/agent/tools/impl/search_person.py
@@ -1,83 +0,0 @@
-"""搜索人物工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.media import MediaChain
-from app.log import logger
-
-
-class SearchPersonInput(BaseModel):
-    """搜索人物工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    name: str = Field(..., description="The name of the person to search for (e.g., 'Tom Hanks', '周杰伦')")
-
-
-class SearchPersonTool(MoviePilotTool):
-    name: str = "search_person"
-    description: str = "Search for person information including actors, directors, etc. Supports searching by name. Returns detailed person information from TMDB, Douban, or Bangumi database."
-    args_schema: Type[BaseModel] = SearchPersonInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据搜索参数生成友好的提示消息"""
-        name = kwargs.get("name", "")
-        return f"正在搜索人物: {name}"
-
-    async def run(self, name: str, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: name={name}")
-
-        try:
-            media_chain = MediaChain()
-            # 使用 MediaChain.async_search_persons 方法搜索人物
-            persons = await media_chain.async_search_persons(name=name)
-
-            if persons:
-                # 限制最多30条结果
-                total_count = len(persons)
-                limited_persons = persons[:30]
-                # 精简字段，只保留关键信息
-                simplified_results = []
-                for person in limited_persons:
-                    simplified = {
-                        "name": person.name,
-                        "id": person.id,
-                        "source": person.source,
-                        "profile_path": person.profile_path,
-                        "original_name": person.original_name,
-                        "known_for_department": person.known_for_department,
-                        "popularity": person.popularity,
-                        "biography": person.biography[:200] + "..." if person.biography and len(person.biography) > 200 else person.biography,
-                        "birthday": person.birthday,
-                        "deathday": person.deathday,
-                        "place_of_birth": person.place_of_birth,
-                        "gender": person.gender,
-                        "imdb_id": person.imdb_id,
-                        "also_known_as": person.also_known_as[:5] if person.also_known_as else [],  # 限制别名数量
-                    }
-                    # 添加豆瓣特有字段
-                    if person.source == "douban":
-                        simplified["url"] = person.url
-                        simplified["avatar"] = person.avatar
-                        simplified["latin_name"] = person.latin_name
-                        simplified["roles"] = person.roles[:5] if person.roles else []  # 限制角色数量
-                    # 添加Bangumi特有字段
-                    if person.source == "bangumi":
-                        simplified["career"] = person.career
-                        simplified["relation"] = person.relation
-                    
-                    simplified_results.append(simplified)
-                
-                result_json = json.dumps(simplified_results, ensure_ascii=False, indent=2)
-                # 如果结果被裁剪，添加提示信息
-                if total_count > 30:
-                    return f"注意：搜索结果共找到 {total_count} 条，为节省上下文空间，仅显示前 30 条结果。\n\n{result_json}"
-                return result_json
-            else:
-                return f"未找到相关人物信息: {name}"
-        except Exception as e:
-            error_message = f"搜索人物失败: {str(e)}"
-            logger.error(f"搜索人物失败: {e}", exc_info=True)
-            return error_message
--- a/app/agent/tools/impl/search_person_credits.py
+++ b/app/agent/tools/impl/search_person_credits.py
@@ -1,85 +0,0 @@
-"""搜索演员参演作品工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.douban import DoubanChain
-from app.chain.tmdb import TmdbChain
-from app.chain.bangumi import BangumiChain
-from app.log import logger
-
-
-class SearchPersonCreditsInput(BaseModel):
-    """搜索演员参演作品工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    person_id: int = Field(..., description="The ID of the person/actor to search for credits (e.g., 31 for Tom Hanks in TMDB)")
-    source: str = Field(..., description="The data source: 'tmdb' for TheMovieDB, 'douban' for Douban, 'bangumi' for Bangumi")
-    page: Optional[int] = Field(1, description="Page number for pagination (default: 1)")
-
-
-class SearchPersonCreditsTool(MoviePilotTool):
-    name: str = "search_person_credits"
-    description: str = "Search for films and TV shows that a person/actor has appeared in (filmography). Supports searching by person ID from TMDB, Douban, or Bangumi database. Returns a list of media works the person has participated in."
-    args_schema: Type[BaseModel] = SearchPersonCreditsInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据搜索参数生成友好的提示消息"""
-        person_id = kwargs.get("person_id", "")
-        source = kwargs.get("source", "")
-        return f"正在搜索人物参演作品: {source} ID {person_id}"
-
-    async def run(self, person_id: int, source: str, page: Optional[int] = 1, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: person_id={person_id}, source={source}, page={page}")
-
-        try:
-            # 根据source选择相应的chain
-            if source.lower() == "tmdb":
-                tmdb_chain = TmdbChain()
-                medias = await tmdb_chain.async_person_credits(person_id=person_id, page=page)
-            elif source.lower() == "douban":
-                douban_chain = DoubanChain()
-                medias = await douban_chain.async_person_credits(person_id=person_id, page=page)
-            elif source.lower() == "bangumi":
-                bangumi_chain = BangumiChain()
-                medias = await bangumi_chain.async_person_credits(person_id=person_id)
-            else:
-                return f"不支持的数据源: {source}。支持的数据源: tmdb, douban, bangumi"
-
-            if medias:
-                # 限制最多30条结果
-                total_count = len(medias)
-                limited_medias = medias[:30]
-                # 精简字段，只保留关键信息
-                simplified_results = []
-                for media in limited_medias:
-                    simplified = {
-                        "title": media.title,
-                        "en_title": media.en_title,
-                        "year": media.year,
-                        "type": media.type.value if media.type else None,
-                        "season": media.season,
-                        "tmdb_id": media.tmdb_id,
-                        "imdb_id": media.imdb_id,
-                        "douban_id": media.douban_id,
-                        "overview": media.overview[:200] + "..." if media.overview and len(media.overview) > 200 else media.overview,
-                        "vote_average": media.vote_average,
-                        "poster_path": media.poster_path,
-                        "backdrop_path": media.backdrop_path,
-                        "detail_link": media.detail_link
-                    }
-                    simplified_results.append(simplified)
-                
-                result_json = json.dumps(simplified_results, ensure_ascii=False, indent=2)
-                # 如果结果被裁剪，添加提示信息
-                if total_count > 30:
-                    return f"注意：搜索结果共找到 {total_count} 条，为节省上下文空间，仅显示前 30 条结果。\n\n{result_json}"
-                return result_json
-            else:
-                return f"未找到人物 ID {person_id} ({source}) 的参演作品"
-        except Exception as e:
-            error_message = f"搜索演员参演作品失败: {str(e)}"
-            logger.error(f"搜索演员参演作品失败: {e}", exc_info=True)
-            return error_message
--- a/app/agent/tools/impl/search_subscribe.py
+++ b/app/agent/tools/impl/search_subscribe.py
@@ -1,127 +0,0 @@
-"""搜索订阅缺失剧集工具"""
-
-import json
-from typing import Optional, Type, List
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.subscribe import SubscribeChain
-from app.core.config import global_vars
-from app.db.subscribe_oper import SubscribeOper
-from app.log import logger
-
-
-class SearchSubscribeInput(BaseModel):
-    """搜索订阅缺失剧集工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    subscribe_id: int = Field(..., description="The ID of the subscription to search for missing episodes")
-    manual: Optional[bool] = Field(False, description="Whether this is a manual search (default: False)")
-    filter_groups: Optional[List[str]] = Field(None,
-                                               description="List of filter rule group names to apply for this search (optional, use query_rule_groups tool to get available rule groups. If provided, will temporarily update the subscription's filter groups before searching)")
-
-
-class SearchSubscribeTool(MoviePilotTool):
-    name: str = "search_subscribe"
-    description: str = "Search for missing episodes/resources for a specific subscription. This tool will search torrent sites for the missing episodes of the subscription and automatically download matching resources. Use this when a user wants to search for missing episodes of a specific subscription."
-    args_schema: Type[BaseModel] = SearchSubscribeInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据搜索参数生成友好的提示消息"""
-        subscribe_id = kwargs.get("subscribe_id")
-        manual = kwargs.get("manual", False)
-
-        message = f"正在搜索订阅 #{subscribe_id} 的缺失剧集"
-        if manual:
-            message += "（手动搜索）"
-
-        return message
-
-    async def run(self, subscribe_id: int, manual: Optional[bool] = False,
-                  filter_groups: Optional[List[str]] = None, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: subscribe_id={subscribe_id}, manual={manual}, filter_groups={filter_groups}")
-
-        try:
-            # 先验证订阅是否存在
-            subscribe_oper = SubscribeOper()
-            subscribe = subscribe_oper.get(subscribe_id)
-
-            if not subscribe:
-                return json.dumps({
-                    "success": False,
-                    "message": f"订阅不存在: {subscribe_id}"
-                }, ensure_ascii=False)
-
-            # 获取订阅信息用于返回
-            subscribe_info = {
-                "id": subscribe.id,
-                "name": subscribe.name,
-                "year": subscribe.year,
-                "type": subscribe.type,
-                "season": subscribe.season,
-                "state": subscribe.state,
-                "total_episode": subscribe.total_episode,
-                "lack_episode": subscribe.lack_episode,
-                "tmdbid": subscribe.tmdbid,
-                "doubanid": subscribe.doubanid
-            }
-
-            # 检查订阅状态
-            if subscribe.state == "S":
-                return json.dumps({
-                    "success": False,
-                    "message": f"订阅 #{subscribe_id} ({subscribe.name}) 已暂停，无法搜索",
-                    "subscribe": subscribe_info
-                }, ensure_ascii=False)
-
-            # 如果提供了 filter_groups 参数，先更新订阅的规则组
-            if filter_groups is not None:
-                subscribe_oper.update(subscribe_id, {"filter_groups": filter_groups})
-                logger.info(f"更新订阅 #{subscribe_id} 的规则组为: {filter_groups}")
-
-            # 调用 SubscribeChain 的 search 方法
-            # search 方法是同步的，需要在异步环境中运行
-            subscribe_chain = SubscribeChain()
-
-            # 在线程池中执行同步的搜索操作
-            # 当 sid 有值时，state 参数会被忽略，直接处理该订阅
-            await global_vars.loop.run_in_executor(
-                None,
-                lambda: subscribe_chain.search(
-                    sid=subscribe_id,
-                    state='R',  # 默认状态，当 sid 有值时此参数会被忽略
-                    manual=manual
-                )
-            )
-
-            # 重新获取订阅信息以获取更新后的状态
-            updated_subscribe = subscribe_oper.get(subscribe_id)
-            if updated_subscribe:
-                subscribe_info.update({
-                    "state": updated_subscribe.state,
-                    "lack_episode": updated_subscribe.lack_episode,
-                    "last_update": updated_subscribe.last_update,
-                    "filter_groups": updated_subscribe.filter_groups
-                })
-
-            # 如果提供了规则组，会在返回信息中显示
-            result = {
-                "success": True,
-                "message": f"订阅 #{subscribe_id} ({subscribe.name}) 搜索完成",
-                "subscribe": subscribe_info
-            }
-
-            if filter_groups is not None:
-                result["message"] += f"（已应用规则组: {', '.join(filter_groups)}）"
-
-            return json.dumps(result, ensure_ascii=False, indent=2)
-
-        except Exception as e:
-            error_message = f"搜索订阅缺失剧集失败: {str(e)}"
-            logger.error(f"搜索订阅缺失剧集失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message,
-                "subscribe_id": subscribe_id
-            }, ensure_ascii=False)
--- a/app/agent/tools/impl/search_torrents.py
+++ b/app/agent/tools/impl/search_torrents.py
@@ -1,142 +0,0 @@
-"""搜索种子工具"""
-
-import json
-import re
-from typing import List, Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.search import SearchChain
-from app.log import logger
-from app.schemas.types import MediaType
-
-
-class SearchTorrentsInput(BaseModel):
-    """搜索种子工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    title: str = Field(...,
-                       description="The title of the media resource to search for (e.g., 'The Matrix 1999', 'Breaking Bad S01E01')")
-    year: Optional[str] = Field(None,
-                                description="Release year of the media (optional, helps narrow down search results)")
-    media_type: Optional[str] = Field(None,
-                                      description="Type of media content: '电影' for films, '电视剧' for television series or anime series")
-    season: Optional[int] = Field(None, description="Season number for TV shows (optional, only applicable for series)")
-    sites: Optional[List[int]] = Field(None,
-                                       description="Array of specific site IDs to search on (optional, if not provided searches all configured sites)")
-    filter_pattern: Optional[str] = Field(None,
-                                          description="Regular expression pattern to filter torrent titles by resolution, quality, or other keywords (e.g., '4K|2160p|UHD' for 4K content, '1080p|BluRay' for 1080p BluRay)")
-
-
-class SearchTorrentsTool(MoviePilotTool):
-    name: str = "search_torrents"
-    description: str = "Search for torrent files across configured indexer sites based on media information. Returns available torrent downloads with details like file size, quality, and download links."
-    args_schema: Type[BaseModel] = SearchTorrentsInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据搜索参数生成友好的提示消息"""
-        title = kwargs.get("title", "")
-        year = kwargs.get("year")
-        media_type = kwargs.get("media_type")
-        season = kwargs.get("season")
-        filter_pattern = kwargs.get("filter_pattern")
-        
-        message = f"正在搜索种子: {title}"
-        if year:
-            message += f" ({year})"
-        if media_type:
-            message += f" [{media_type}]"
-        if season:
-            message += f" 第{season}季"
-        if filter_pattern:
-            message += f" 过滤: {filter_pattern}"
-        
-        return message
-
-    async def run(self, title: str, year: Optional[str] = None,
-                  media_type: Optional[str] = None, season: Optional[int] = None,
-                  sites: Optional[List[int]] = None, filter_pattern: Optional[str] = None, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: title={title}, year={year}, media_type={media_type}, season={season}, sites={sites}, filter_pattern={filter_pattern}")
-
-        try:
-            search_chain = SearchChain()
-            torrents = await search_chain.async_search_by_title(title=title, sites=sites)
-            filtered_torrents = []
-            # 编译正则表达式（如果提供）
-            regex_pattern = None
-            if filter_pattern:
-                try:
-                    regex_pattern = re.compile(filter_pattern, re.IGNORECASE)
-                except re.error as e:
-                    logger.warning(f"正则表达式编译失败: {filter_pattern}, 错误: {e}")
-                    return f"正则表达式格式错误: {str(e)}"
-            
-            for torrent in torrents:
-                # torrent 是 Context 对象，需要通过 meta_info 和 media_info 访问属性
-                if year and torrent.meta_info and torrent.meta_info.year != year:
-                    continue
-                if media_type and torrent.media_info:
-                    if torrent.media_info.type != MediaType(media_type):
-                        continue
-                if season and torrent.meta_info and torrent.meta_info.begin_season != season:
-                    continue
-                # 使用正则表达式过滤标题（分辨率、质量等关键字）
-                if regex_pattern and torrent.torrent_info and torrent.torrent_info.title:
-                    if not regex_pattern.search(torrent.torrent_info.title):
-                        continue
-                filtered_torrents.append(torrent)
-
-            if filtered_torrents:
-                # 限制最多50条结果
-                total_count = len(filtered_torrents)
-                limited_torrents = filtered_torrents[:50]
-                # 精简字段，只保留关键信息
-                simplified_torrents = []
-                for t in limited_torrents:
-                    simplified = {}
-                    # 精简 torrent_info
-                    if t.torrent_info:
-                        simplified["torrent_info"] = {
-                            "title": t.torrent_info.title,
-                            "size": t.torrent_info.size,
-                            "seeders": t.torrent_info.seeders,
-                            "peers": t.torrent_info.peers,
-                            "site_name": t.torrent_info.site_name,
-                            "enclosure": t.torrent_info.enclosure,
-                            "page_url": t.torrent_info.page_url,
-                            "volume_factor": t.torrent_info.volume_factor,
-                            "pubdate": t.torrent_info.pubdate
-                        }
-                    # 精简 media_info
-                    if t.media_info:
-                        simplified["media_info"] = {
-                            "title": t.media_info.title,
-                            "en_title": t.media_info.en_title,
-                            "year": t.media_info.year,
-                            "type": t.media_info.type.value if t.media_info.type else None,
-                            "season": t.media_info.season,
-                            "tmdb_id": t.media_info.tmdb_id
-                        }
-                    # 精简 meta_info
-                    if t.meta_info:
-                        simplified["meta_info"] = {
-                            "name": t.meta_info.name,
-                            "cn_name": t.meta_info.cn_name,
-                            "en_name": t.meta_info.en_name,
-                            "year": t.meta_info.year,
-                            "type": t.meta_info.type.value if t.meta_info.type else None,
-                            "begin_season": t.meta_info.begin_season
-                        }
-                    simplified_torrents.append(simplified)
-                result_json = json.dumps(simplified_torrents, ensure_ascii=False, indent=2)
-                # 如果结果被裁剪，添加提示信息
-                if total_count > 50:
-                    return f"注意：搜索结果共找到 {total_count} 条，为节省上下文空间，仅显示前 50 条结果。\n\n{result_json}"
-                return result_json
-            else:
-                return f"未找到相关种子资源: {title}"
-        except Exception as e:
-            error_message = f"搜索种子时发生错误: {str(e)}"
-            logger.error(f"搜索种子失败: {e}", exc_info=True)
-            return error_message
--- a/app/agent/tools/impl/search_web.py
+++ b/app/agent/tools/impl/search_web.py
@@ -1,193 +0,0 @@
-"""搜索网络内容工具"""
-
-import json
-import re
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.core.config import settings
-from app.log import logger
-from app.utils.http import AsyncRequestUtils
-
-
-class SearchWebInput(BaseModel):
-    """搜索网络内容工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    query: str = Field(..., description="The search query string to search for on the web")
-    max_results: Optional[int] = Field(5, description="Maximum number of search results to return (default: 5, max: 10)")
-
-
-class SearchWebTool(MoviePilotTool):
-    name: str = "search_web"
-    description: str = "Search the web for information when you need to find current information, facts, or references that you're uncertain about. Returns search results with titles, snippets, and URLs. Use this tool to get up-to-date information from the internet."
-    args_schema: Type[BaseModel] = SearchWebInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据搜索参数生成友好的提示消息"""
-        query = kwargs.get("query", "")
-        max_results = kwargs.get("max_results", 5)
-        return f"正在搜索网络内容: {query} (最多返回 {max_results} 条结果)"
-
-    async def run(self, query: str, max_results: Optional[int] = 5, **kwargs) -> str:
-        """
-        执行网络搜索
-        
-        Args:
-            query: 搜索查询字符串
-            max_results: 最大返回结果数（默认5，最大10）
-            
-        Returns:
-            格式化的搜索结果JSON字符串
-        """
-        logger.info(f"执行工具: {self.name}, 参数: query={query}, max_results={max_results}")
-
-        try:
-            # 限制最大结果数
-            max_results = min(max(1, max_results or 5), 10)
-            
-            # 使用DuckDuckGo API进行搜索
-            search_results = await self._search_duckduckgo_api(query, max_results)
-            
-            if not search_results:
-                return f"未找到与 '{query}' 相关的搜索结果"
-            
-            # 裁剪结果以避免占用过多上下文
-            formatted_results = self._format_and_truncate_results(search_results, max_results)
-            
-            result_json = json.dumps(formatted_results, ensure_ascii=False, indent=2)
-            return result_json
-            
-        except Exception as e:
-            error_message = f"搜索网络内容失败: {str(e)}"
-            logger.error(f"搜索网络内容失败: {e}", exc_info=True)
-            return error_message
-
-    @staticmethod
-    async def _search_duckduckgo_api(query: str, max_results: int) -> list:
-        """
-        使用DuckDuckGo API进行搜索
-        
-        Args:
-            query: 搜索查询
-            max_results: 最大结果数
-            
-        Returns:
-            搜索结果列表
-        """
-        try:
-            # DuckDuckGo Instant Answer API
-            api_url = "https://api.duckduckgo.com/"
-            params = {
-                "q": query,
-                "format": "json",
-                "no_html": "1",
-                "skip_disambig": "1"
-            }
-            
-            # 使用代理（如果配置了）
-            http_utils = AsyncRequestUtils(
-                proxies=settings.PROXY,
-                timeout=10
-            )
-            
-            data = await http_utils.get_json(api_url, params=params)
-            
-            results = []
-            
-            if data:
-                # 处理AbstractText（摘要）
-                if data.get("AbstractText"):
-                    results.append({
-                        "title": data.get("Heading", query),
-                        "snippet": data.get("AbstractText", ""),
-                        "url": data.get("AbstractURL", ""),
-                        "source": "DuckDuckGo Abstract"
-                    })
-                
-                # 处理RelatedTopics（相关主题）
-                related_topics = data.get("RelatedTopics", [])
-                for topic in related_topics[:max_results - len(results)]:
-                    if isinstance(topic, dict):
-                        text = topic.get("Text", "")
-                        first_url = topic.get("FirstURL", "")
-                        if text and first_url:
-                            # 提取标题（通常在" - "之前）
-                            title = text.split(" - ")[0] if " - " in text else text[:100]
-                            snippet = text
-                            
-                            results.append({
-                                "title": title.strip(),
-                                "snippet": snippet,
-                                "url": first_url,
-                                "source": "DuckDuckGo Related"
-                            })
-                
-                # 处理Results（搜索结果）
-                api_results = data.get("Results", [])
-                for result in api_results[:max_results - len(results)]:
-                    if isinstance(result, dict):
-                        title = result.get("Text", "")
-                        url = result.get("FirstURL", "")
-                        if title and url:
-                            results.append({
-                                "title": title,
-                                "snippet": result.get("Text", ""),
-                                "url": url,
-                                "source": "DuckDuckGo Results"
-                            })
-            
-            return results[:max_results]
-            
-        except Exception as e:
-            logger.warning(f"DuckDuckGo API搜索失败: {e}")
-            return []
-
-    @staticmethod
-    def _format_and_truncate_results(results: list, max_results: int) -> dict:
-        """
-        格式化并裁剪搜索结果以避免占用过多上下文
-        
-        Args:
-            results: 原始搜索结果列表
-            max_results: 最大结果数
-            
-        Returns:
-            格式化后的结果字典
-        """
-        formatted = {
-            "total_results": len(results),
-            "results": []
-        }
-        
-        # 限制结果数量
-        limited_results = results[:max_results]
-        
-        for idx, result in enumerate(limited_results, 1):
-            title = result.get("title", "")[:200]  # 限制标题长度
-            snippet = result.get("snippet", "")
-            url = result.get("url", "")
-            source = result.get("source", "Unknown")
-            
-            # 裁剪摘要，避免过长
-            max_snippet_length = 300  # 每个摘要最多300字符
-            if len(snippet) > max_snippet_length:
-                snippet = snippet[:max_snippet_length] + "..."
-            
-            # 清理文本，移除多余的空白字符
-            snippet = re.sub(r'\s+', ' ', snippet).strip()
-            
-            formatted["results"].append({
-                "rank": idx,
-                "title": title,
-                "snippet": snippet,
-                "url": url,
-                "source": source
-            })
-        
-        # 添加提示信息
-        if len(results) > max_results:
-            formatted["note"] = f"注意：共找到 {len(results)} 条结果，为节省上下文空间，仅显示前 {max_results} 条结果。"
-        
-        return formatted
--- a/app/agent/tools/impl/send_message.py
+++ b/app/agent/tools/impl/send_message.py
@@ -1,45 +0,0 @@
-"""发送消息工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.log import logger
-
-
-class SendMessageInput(BaseModel):
-    """发送消息工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    message: str = Field(..., description="The message content to send to the user (should be clear and informative)")
-    message_type: Optional[str] = Field("info",
-                                        description="Type of message: 'info' for general information, 'success' for successful operations, 'warning' for warnings, 'error' for error messages")
-
-
-class SendMessageTool(MoviePilotTool):
-    name: str = "send_message"
-    description: str = "Send notification message to the user through configured notification channels (Telegram, Slack, WeChat, etc.). Used to inform users about operation results, errors, or important updates."
-    args_schema: Type[BaseModel] = SendMessageInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据消息参数生成友好的提示消息"""
-        message = kwargs.get("message", "")
-        message_type = kwargs.get("message_type", "info")
-        
-        type_map = {"info": "信息", "success": "成功", "warning": "警告", "error": "错误"}
-        type_desc = type_map.get(message_type, message_type)
-        
-        # 截断过长的消息
-        if len(message) > 50:
-            message = message[:50] + "..."
-        
-        return f"正在发送{type_desc}消息: {message}"
-
-    async def run(self, message: str, message_type: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: message={message}, message_type={message_type}")
-        try:
-            await self.send_tool_message(message, title=message_type)
-            return "消息已发送"
-        except Exception as e:
-            logger.error(f"发送消息失败: {e}")
-            return f"发送消息时发生错误: {str(e)}"
--- a/app/agent/tools/impl/test_site.py
+++ b/app/agent/tools/impl/test_site.py
@@ -1,72 +0,0 @@
-"""测试站点连通性工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.site import SiteChain
-from app.db.site_oper import SiteOper
-from app.log import logger
-from app.utils.string import StringUtils
-
-
-class TestSiteInput(BaseModel):
-    """测试站点连通性工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    site_identifier: str = Field(..., description="Site identifier: can be site ID (integer as string), site name, or site domain/URL")
-
-
-class TestSiteTool(MoviePilotTool):
-    name: str = "test_site"
-    description: str = "Test site connectivity and availability. This will check if a site is accessible and can be logged in. Accepts site ID, site name, or site domain/URL as identifier."
-    args_schema: Type[BaseModel] = TestSiteInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据测试参数生成友好的提示消息"""
-        site_identifier = kwargs.get("site_identifier", "")
-        return f"正在测试站点连通性: {site_identifier}"
-
-    async def run(self, site_identifier: str, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: site_identifier={site_identifier}")
-
-        try:
-            site_oper = SiteOper()
-            site_chain = SiteChain()
-            
-            # 尝试解析为站点ID
-            site = None
-            if site_identifier.isdigit():
-                # 如果是数字，尝试作为站点ID查询
-                site = await site_oper.async_get(int(site_identifier))
-            
-            # 如果不是ID或ID查询失败，尝试按名称或域名查询
-            if not site:
-                # 尝试按名称查询
-                sites = await site_oper.async_list()
-                for s in sites:
-                    if (site_identifier.lower() in (s.name or "").lower()) or \
-                       (site_identifier.lower() in (s.domain or "").lower()):
-                        site = s
-                        break
-                
-                # 如果还是没找到，尝试从URL提取域名
-                if not site:
-                    domain = StringUtils.get_url_domain(site_identifier)
-                    if domain:
-                        site = await site_oper.async_get_by_domain(domain)
-            
-            if not site:
-                return f"未找到站点：{site_identifier}，请使用 query_sites 工具查询可用的站点"
-            
-            # 测试站点连通性
-            status, message = site_chain.test(site.domain)
-            
-            if status:
-                return f"站点连通性测试成功：{site.name} ({site.domain})\n{message}"
-            else:
-                return f"站点连通性测试失败：{site.name} ({site.domain})\n{message}"
-        except Exception as e:
-            logger.error(f"测试站点连通性失败: {e}", exc_info=True)
-            return f"测试站点连通性时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/transfer_file.py
+++ b/app/agent/tools/impl/transfer_file.py
@@ -1,134 +0,0 @@
-"""整理文件或目录工具"""
-
-from pathlib import Path
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.transfer import TransferChain
-from app.log import logger
-from app.schemas import FileItem, MediaType
-
-
-class TransferFileInput(BaseModel):
-    """整理文件或目录工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    file_path: str = Field(..., description="Path to the file or directory to transfer (e.g., '/path/to/file.mkv' or '/path/to/directory')")
-    storage: Optional[str] = Field("local", description="Storage type of the source file (default: 'local', can be 'smb', 'alist', etc.)")
-    target_path: Optional[str] = Field(None, description="Target path for the transferred file/directory (optional, uses default library path if not specified)")
-    target_storage: Optional[str] = Field(None, description="Target storage type (optional, uses default storage if not specified)")
-    media_type: Optional[str] = Field(None, description="Media type: '电影' for films, '电视剧' for television series (optional, will be auto-detected if not specified)")
-    tmdbid: Optional[int] = Field(None, description="TMDB ID for precise media identification (optional but recommended for accuracy)")
-    doubanid: Optional[str] = Field(None, description="Douban ID for media identification (optional)")
-    season: Optional[int] = Field(None, description="Season number for TV shows (optional)")
-    transfer_type: Optional[str] = Field(None, description="Transfer mode: 'move' to move files, 'copy' to copy files, 'link' for hard link, 'softlink' for symbolic link (optional, uses default mode if not specified)")
-    background: Optional[bool] = Field(False, description="Whether to run transfer in background (default: False, runs synchronously)")
-
-
-class TransferFileTool(MoviePilotTool):
-    name: str = "transfer_file"
-    description: str = "Transfer/organize a file or directory to the media library. Automatically recognizes media information and organizes files according to configured rules. Supports custom target paths, media identification, and transfer modes."
-    args_schema: Type[BaseModel] = TransferFileInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据整理参数生成友好的提示消息"""
-        file_path = kwargs.get("file_path", "")
-        media_type = kwargs.get("media_type")
-        transfer_type = kwargs.get("transfer_type")
-        background = kwargs.get("background", False)
-        
-        message = f"正在整理文件: {file_path}"
-        if media_type:
-            message += f" [{media_type}]"
-        if transfer_type:
-            transfer_map = {"move": "移动", "copy": "复制", "link": "硬链接", "softlink": "软链接"}
-            message += f" 模式: {transfer_map.get(transfer_type, transfer_type)}"
-        if background:
-            message += " [后台运行]"
-        
-        return message
-
-    async def run(self, file_path: str, storage: Optional[str] = "local",
-                  target_path: Optional[str] = None,
-                  target_storage: Optional[str] = None,
-                  media_type: Optional[str] = None,
-                  tmdbid: Optional[int] = None,
-                  doubanid: Optional[str] = None,
-                  season: Optional[int] = None,
-                  transfer_type: Optional[str] = None,
-                  background: Optional[bool] = False, **kwargs) -> str:
-        logger.info(
-            f"执行工具: {self.name}, 参数: file_path={file_path}, storage={storage}, target_path={target_path}, "
-            f"target_storage={target_storage}, media_type={media_type}, tmdbid={tmdbid}, doubanid={doubanid}, "
-            f"season={season}, transfer_type={transfer_type}, background={background}")
-
-        try:
-            if not file_path:
-                return "错误：必须提供文件或目录路径"
-            
-            # 规范化路径
-            if storage == "local":
-                # 本地路径处理
-                if not file_path.startswith("/") and not (len(file_path) > 1 and file_path[1] == ":"):
-                    # 相对路径，尝试转换为绝对路径
-                    file_path = str(Path(file_path).resolve())
-            else:
-                # 远程存储路径，确保以/开头
-                if not file_path.startswith("/"):
-                    file_path = "/" + file_path
-            
-            # 创建FileItem
-            fileitem = FileItem(
-                storage=storage or "local",
-                path=file_path,
-                type="dir" if file_path.endswith("/") else "file"
-            )
-            
-            # 处理目标路径
-            target_path_obj = None
-            if target_path:
-                target_path_obj = Path(target_path)
-            
-            # 处理媒体类型
-            mtype = None
-            if media_type:
-                try:
-                    mtype = MediaType(media_type)
-                except ValueError:
-                    return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
-            
-            # 调用整理方法
-            transfer_chain = TransferChain()
-            state, errormsg = transfer_chain.manual_transfer(
-                fileitem=fileitem,
-                target_storage=target_storage,
-                target_path=target_path_obj,
-                tmdbid=tmdbid,
-                doubanid=doubanid,
-                mtype=mtype,
-                season=season,
-                transfer_type=transfer_type,
-                background=background
-            )
-            
-            if not state:
-                # 处理错误信息
-                if isinstance(errormsg, list):
-                    error_text = f"整理完成，{len(errormsg)} 个文件转移失败"
-                    if errormsg:
-                        error_text += f"：\n" + "\n".join(str(e) for e in errormsg[:5])  # 只显示前5个错误
-                        if len(errormsg) > 5:
-                            error_text += f"\n... 还有 {len(errormsg) - 5} 个错误"
-                else:
-                    error_text = str(errormsg)
-                return f"整理失败：{error_text}"
-            else:
-                if background:
-                    return f"整理任务已提交到后台运行：{file_path}"
-                else:
-                    return f"整理成功：{file_path}"
-        except Exception as e:
-            logger.error(f"整理文件失败: {e}", exc_info=True)
-            return f"整理文件时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/update_site.py
+++ b/app/agent/tools/impl/update_site.py
@@ -1,203 +0,0 @@
-"""更新站点工具"""
-
-import json
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.core.event import eventmanager
-from app.db import AsyncSessionFactory
-from app.db.models.site import Site
-from app.log import logger
-from app.schemas.types import EventType
-from app.utils.string import StringUtils
-
-
-class UpdateSiteInput(BaseModel):
-    """更新站点工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    site_id: int = Field(..., description="The ID of the site to update")
-    name: Optional[str] = Field(None, description="Site name (optional)")
-    url: Optional[str] = Field(None, description="Site URL (optional, will be automatically formatted)")
-    pri: Optional[int] = Field(None, description="Site priority (optional, smaller value = higher priority, e.g., pri=1 has higher priority than pri=10)")
-    rss: Optional[str] = Field(None, description="RSS feed URL (optional)")
-    cookie: Optional[str] = Field(None, description="Site cookie (optional)")
-    ua: Optional[str] = Field(None, description="User-Agent string (optional)")
-    apikey: Optional[str] = Field(None, description="API key (optional)")
-    token: Optional[str] = Field(None, description="API token (optional)")
-    proxy: Optional[int] = Field(None, description="Whether to use proxy: 0 for no, 1 for yes (optional)")
-    filter: Optional[str] = Field(None, description="Filter rule as regular expression (optional)")
-    note: Optional[str] = Field(None, description="Site notes/remarks (optional)")
-    timeout: Optional[int] = Field(None, description="Request timeout in seconds (optional, default: 15)")
-    limit_interval: Optional[int] = Field(None, description="Rate limit interval in seconds (optional)")
-    limit_count: Optional[int] = Field(None, description="Rate limit count per interval (optional)")
-    limit_seconds: Optional[int] = Field(None, description="Rate limit seconds between requests (optional)")
-    is_active: Optional[bool] = Field(None, description="Whether site is active: True for enabled, False for disabled (optional)")
-    downloader: Optional[str] = Field(None, description="Downloader name for this site (optional)")
-
-
-class UpdateSiteTool(MoviePilotTool):
-    name: str = "update_site"
-    description: str = "Update site configuration including URL, priority, authentication credentials (cookie, UA, API key), proxy settings, rate limits, and other site properties. Supports updating multiple site attributes at once. Site priority (pri): smaller values have higher priority (e.g., pri=1 has higher priority than pri=10)."
-    args_schema: Type[BaseModel] = UpdateSiteInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据更新参数生成友好的提示消息"""
-        site_id = kwargs.get("site_id")
-        fields_updated = []
-        
-        if kwargs.get("name"):
-            fields_updated.append("名称")
-        if kwargs.get("url"):
-            fields_updated.append("URL")
-        if kwargs.get("pri") is not None:
-            fields_updated.append("优先级")
-        if kwargs.get("cookie"):
-            fields_updated.append("Cookie")
-        if kwargs.get("ua"):
-            fields_updated.append("User-Agent")
-        if kwargs.get("proxy") is not None:
-            fields_updated.append("代理设置")
-        if kwargs.get("is_active") is not None:
-            fields_updated.append("启用状态")
-        if kwargs.get("downloader"):
-            fields_updated.append("下载器")
-        
-        if fields_updated:
-            return f"正在更新站点 #{site_id}: {', '.join(fields_updated)}"
-        return f"正在更新站点 #{site_id}"
-
-    async def run(self, site_id: int,
-                  name: Optional[str] = None,
-                  url: Optional[str] = None,
-                  pri: Optional[int] = None,
-                  rss: Optional[str] = None,
-                  cookie: Optional[str] = None,
-                  ua: Optional[str] = None,
-                  apikey: Optional[str] = None,
-                  token: Optional[str] = None,
-                  proxy: Optional[int] = None,
-                  filter: Optional[str] = None,
-                  note: Optional[str] = None,
-                  timeout: Optional[int] = None,
-                  limit_interval: Optional[int] = None,
-                  limit_count: Optional[int] = None,
-                  limit_seconds: Optional[int] = None,
-                  is_active: Optional[bool] = None,
-                  downloader: Optional[str] = None,
-                  **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: site_id={site_id}")
-        
-        try:
-            # 获取数据库会话
-            async with AsyncSessionFactory() as db:
-                # 获取站点
-                site = await Site.async_get(db, site_id)
-                if not site:
-                    return json.dumps({
-                        "success": False,
-                        "message": f"站点不存在: {site_id}"
-                    }, ensure_ascii=False)
-                
-                # 构建更新字典
-                site_dict = {}
-                
-                # 基本信息
-                if name is not None:
-                    site_dict["name"] = name
-                
-                # URL处理（需要校正格式）
-                if url is not None:
-                    _scheme, _netloc = StringUtils.get_url_netloc(url)
-                    site_dict["url"] = f"{_scheme}://{_netloc}/"
-                
-                if pri is not None:
-                    site_dict["pri"] = pri
-                if rss is not None:
-                    site_dict["rss"] = rss
-                
-                # 认证信息
-                if cookie is not None:
-                    site_dict["cookie"] = cookie
-                if ua is not None:
-                    site_dict["ua"] = ua
-                if apikey is not None:
-                    site_dict["apikey"] = apikey
-                if token is not None:
-                    site_dict["token"] = token
-                
-                # 配置选项
-                if proxy is not None:
-                    site_dict["proxy"] = proxy
-                if filter is not None:
-                    site_dict["filter"] = filter
-                if note is not None:
-                    site_dict["note"] = note
-                if timeout is not None:
-                    site_dict["timeout"] = timeout
-                
-                # 流控设置
-                if limit_interval is not None:
-                    site_dict["limit_interval"] = limit_interval
-                if limit_count is not None:
-                    site_dict["limit_count"] = limit_count
-                if limit_seconds is not None:
-                    site_dict["limit_seconds"] = limit_seconds
-                
-                # 状态和下载器
-                if is_active is not None:
-                    site_dict["is_active"] = is_active
-                if downloader is not None:
-                    site_dict["downloader"] = downloader
-                
-                # 如果没有要更新的字段
-                if not site_dict:
-                    return json.dumps({
-                        "success": False,
-                        "message": "没有提供要更新的字段"
-                    }, ensure_ascii=False)
-                
-                # 更新站点
-                await site.async_update(db, site_dict)
-                
-                # 重新获取更新后的站点数据
-                updated_site = await Site.async_get(db, site_id)
-                
-                # 发送站点更新事件
-                await eventmanager.async_send_event(EventType.SiteUpdated, {
-                    "domain": updated_site.domain if updated_site else site.domain
-                })
-                
-                # 构建返回结果
-                result = {
-                    "success": True,
-                    "message": f"站点 #{site_id} 更新成功",
-                    "site_id": site_id,
-                    "updated_fields": list(site_dict.keys())
-                }
-                
-                if updated_site:
-                    result["site"] = {
-                        "id": updated_site.id,
-                        "name": updated_site.name,
-                        "domain": updated_site.domain,
-                        "url": updated_site.url,
-                        "pri": updated_site.pri,
-                        "is_active": updated_site.is_active,
-                        "downloader": updated_site.downloader,
-                        "proxy": updated_site.proxy,
-                        "timeout": updated_site.timeout
-                    }
-                
-                return json.dumps(result, ensure_ascii=False, indent=2)
-        
-        except Exception as e:
-            error_message = f"更新站点失败: {str(e)}"
-            logger.error(f"更新站点失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message,
-                "site_id": site_id
-            }, ensure_ascii=False)
-
--- a/app/agent/tools/impl/update_site_cookie.py
+++ b/app/agent/tools/impl/update_site_cookie.py
@@ -1,88 +0,0 @@
-"""更新站点Cookie和UA工具"""
-
-from typing import Optional, Type
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.chain.site import SiteChain
-from app.db.site_oper import SiteOper
-from app.log import logger
-from app.utils.string import StringUtils
-
-
-class UpdateSiteCookieInput(BaseModel):
-    """更新站点Cookie和UA工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    site_identifier: str = Field(..., description="Site identifier: can be site ID (integer as string), site name, or site domain/URL")
-    username: str = Field(..., description="Site login username")
-    password: str = Field(..., description="Site login password")
-    two_step_code: Optional[str] = Field(None, description="Two-step verification code or secret key (optional, required for sites with 2FA enabled)")
-
-
-class UpdateSiteCookieTool(MoviePilotTool):
-    name: str = "update_site_cookie"
-    description: str = "Update site Cookie and User-Agent by logging in with username and password. This tool can automatically obtain and update the site's authentication credentials. Supports two-step verification for sites that require it. Accepts site ID, site name, or site domain/URL as identifier."
-    args_schema: Type[BaseModel] = UpdateSiteCookieInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据更新参数生成友好的提示消息"""
-        site_identifier = kwargs.get("site_identifier", "")
-        username = kwargs.get("username", "")
-        two_step_code = kwargs.get("two_step_code")
-        
-        message = f"正在更新站点Cookie: {site_identifier} (用户: {username})"
-        if two_step_code:
-            message += " [需要两步验证]"
-        
-        return message
-
-    async def run(self, site_identifier: str, username: str, password: str, 
-                  two_step_code: Optional[str] = None, **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: site_identifier={site_identifier}, username={username}")
-
-        try:
-            site_oper = SiteOper()
-            site_chain = SiteChain()
-            
-            # 尝试解析为站点ID
-            site = None
-            if site_identifier.isdigit():
-                # 如果是数字，尝试作为站点ID查询
-                site = await site_oper.async_get(int(site_identifier))
-            
-            # 如果不是ID或ID查询失败，尝试按名称或域名查询
-            if not site:
-                # 尝试按名称查询
-                sites = await site_oper.async_list()
-                for s in sites:
-                    if (site_identifier.lower() in (s.name or "").lower()) or \
-                       (site_identifier.lower() in (s.domain or "").lower()):
-                        site = s
-                        break
-                
-                # 如果还是没找到，尝试从URL提取域名
-                if not site:
-                    domain = StringUtils.get_url_domain(site_identifier)
-                    if domain:
-                        site = await site_oper.async_get_by_domain(domain)
-            
-            if not site:
-                return f"未找到站点：{site_identifier}，请使用 query_sites 工具查询可用的站点"
-            
-            # 更新站点Cookie和UA
-            status, message = site_chain.update_cookie(
-                site_info=site,
-                username=username,
-                password=password,
-                two_step_code=two_step_code
-            )
-            
-            if status:
-                return f"站点【{site.name}】Cookie和UA更新成功\n{message}"
-            else:
-                return f"站点【{site.name}】Cookie和UA更新失败\n错误原因：{message}"
-        except Exception as e:
-            logger.error(f"更新站点Cookie和UA失败: {e}", exc_info=True)
-            return f"更新站点Cookie和UA时发生错误: {str(e)}"
-
--- a/app/agent/tools/impl/update_subscribe.py
+++ b/app/agent/tools/impl/update_subscribe.py
@@ -1,239 +0,0 @@
-"""更新订阅工具"""
-
-import json
-from typing import Optional, Type, List
-
-from pydantic import BaseModel, Field
-
-from app.agent.tools.base import MoviePilotTool
-from app.core.event import eventmanager
-from app.db import AsyncSessionFactory
-from app.db.models.subscribe import Subscribe
-from app.log import logger
-from app.schemas.types import EventType
-
-
-class UpdateSubscribeInput(BaseModel):
-    """更新订阅工具的输入参数模型"""
-    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
-    subscribe_id: int = Field(..., description="The ID of the subscription to update")
-    name: Optional[str] = Field(None, description="Subscription name/title (optional)")
-    year: Optional[str] = Field(None, description="Release year (optional)")
-    season: Optional[int] = Field(None, description="Season number for TV shows (optional)")
-    total_episode: Optional[int] = Field(None, description="Total number of episodes (optional)")
-    lack_episode: Optional[int] = Field(None, description="Number of missing episodes (optional)")
-    start_episode: Optional[int] = Field(None, description="Starting episode number (optional)")
-    quality: Optional[str] = Field(None, description="Quality filter as regular expression (optional, e.g., 'BluRay|WEB-DL|HDTV')")
-    resolution: Optional[str] = Field(None, description="Resolution filter as regular expression (optional, e.g., '1080p|720p|2160p')")
-    effect: Optional[str] = Field(None, description="Effect filter as regular expression (optional, e.g., 'HDR|DV|SDR')")
-    include: Optional[str] = Field(None, description="Include filter as regular expression (optional)")
-    exclude: Optional[str] = Field(None, description="Exclude filter as regular expression (optional)")
-    filter: Optional[str] = Field(None, description="Filter rule as regular expression (optional)")
-    state: Optional[str] = Field(None, description="Subscription state: 'R' for enabled, 'P' for disabled, 'S' for paused (optional)")
-    sites: Optional[List[int]] = Field(None, description="List of site IDs to search from (optional)")
-    downloader: Optional[str] = Field(None, description="Downloader name (optional)")
-    save_path: Optional[str] = Field(None, description="Save path for downloaded files (optional)")
-    best_version: Optional[int] = Field(None, description="Whether to upgrade to best version: 0 for no, 1 for yes (optional)")
-    custom_words: Optional[str] = Field(None, description="Custom recognition words (optional)")
-    media_category: Optional[str] = Field(None, description="Custom media category (optional)")
-    episode_group: Optional[str] = Field(None, description="Episode group ID (optional)")
-
-
-class UpdateSubscribeTool(MoviePilotTool):
-    name: str = "update_subscribe"
-    description: str = "Update subscription properties including filters, episode counts, state, and other settings. Supports updating quality/resolution filters, episode tracking, subscription state, and download configuration."
-    args_schema: Type[BaseModel] = UpdateSubscribeInput
-
-    def get_tool_message(self, **kwargs) -> Optional[str]:
-        """根据更新参数生成友好的提示消息"""
-        subscribe_id = kwargs.get("subscribe_id")
-        fields_updated = []
-        
-        if kwargs.get("name"):
-            fields_updated.append("名称")
-        if kwargs.get("total_episode") is not None:
-            fields_updated.append("总集数")
-        if kwargs.get("lack_episode") is not None:
-            fields_updated.append("缺失集数")
-        if kwargs.get("quality"):
-            fields_updated.append("质量过滤")
-        if kwargs.get("resolution"):
-            fields_updated.append("分辨率过滤")
-        if kwargs.get("state"):
-            state_map = {"R": "启用", "P": "禁用", "S": "暂停"}
-            fields_updated.append(f"状态({state_map.get(kwargs.get('state'), kwargs.get('state'))})")
-        if kwargs.get("sites"):
-            fields_updated.append("站点")
-        if kwargs.get("downloader"):
-            fields_updated.append("下载器")
-        
-        if fields_updated:
-            return f"正在更新订阅 #{subscribe_id}: {', '.join(fields_updated)}"
-        return f"正在更新订阅 #{subscribe_id}"
-
-    async def run(self, subscribe_id: int,
-                  name: Optional[str] = None,
-                  year: Optional[str] = None,
-                  season: Optional[int] = None,
-                  total_episode: Optional[int] = None,
-                  lack_episode: Optional[int] = None,
-                  start_episode: Optional[int] = None,
-                  quality: Optional[str] = None,
-                  resolution: Optional[str] = None,
-                  effect: Optional[str] = None,
-                  include: Optional[str] = None,
-                  exclude: Optional[str] = None,
-                  filter: Optional[str] = None,
-                  state: Optional[str] = None,
-                  sites: Optional[List[int]] = None,
-                  downloader: Optional[str] = None,
-                  save_path: Optional[str] = None,
-                  best_version: Optional[int] = None,
-                  custom_words: Optional[str] = None,
-                  media_category: Optional[str] = None,
-                  episode_group: Optional[str] = None,
-                  **kwargs) -> str:
-        logger.info(f"执行工具: {self.name}, 参数: subscribe_id={subscribe_id}")
-        
-        try:
-            # 获取数据库会话
-            async with AsyncSessionFactory() as db:
-                # 获取订阅
-                subscribe = await Subscribe.async_get(db, subscribe_id)
-                if not subscribe:
-                    return json.dumps({
-                        "success": False,
-                        "message": f"订阅不存在: {subscribe_id}"
-                    }, ensure_ascii=False)
-                
-                # 保存旧数据用于事件
-                old_subscribe_dict = subscribe.to_dict()
-                
-                # 构建更新字典
-                subscribe_dict = {}
-                
-                # 基本信息
-                if name is not None:
-                    subscribe_dict["name"] = name
-                if year is not None:
-                    subscribe_dict["year"] = year
-                if season is not None:
-                    subscribe_dict["season"] = season
-                
-                # 集数相关
-                if total_episode is not None:
-                    subscribe_dict["total_episode"] = total_episode
-                    # 如果总集数增加，缺失集数也要相应增加
-                    if total_episode > (subscribe.total_episode or 0):
-                        old_lack = subscribe.lack_episode or 0
-                        subscribe_dict["lack_episode"] = old_lack + (total_episode - (subscribe.total_episode or 0))
-                    # 标记为手动修改过总集数
-                    subscribe_dict["manual_total_episode"] = 1
-                
-                # 缺失集数处理（只有在没有提供总集数时才单独处理）
-                # 注意：如果 lack_episode 为 0，不更新（避免更新为0）
-                if lack_episode is not None and total_episode is None:
-                    if lack_episode > 0:
-                        subscribe_dict["lack_episode"] = lack_episode
-                    # 如果 lack_episode 为 0，不添加到更新字典中（保持原值或由总集数逻辑处理）
-                
-                if start_episode is not None:
-                    subscribe_dict["start_episode"] = start_episode
-                
-                # 过滤规则
-                if quality is not None:
-                    subscribe_dict["quality"] = quality
-                if resolution is not None:
-                    subscribe_dict["resolution"] = resolution
-                if effect is not None:
-                    subscribe_dict["effect"] = effect
-                if include is not None:
-                    subscribe_dict["include"] = include
-                if exclude is not None:
-                    subscribe_dict["exclude"] = exclude
-                if filter is not None:
-                    subscribe_dict["filter"] = filter
-                
-                # 状态
-                if state is not None:
-                    valid_states = ["R", "P", "S", "N"]
-                    if state not in valid_states:
-                        return json.dumps({
-                            "success": False,
-                            "message": f"无效的订阅状态: {state}，有效状态: {', '.join(valid_states)}"
-                        }, ensure_ascii=False)
-                    subscribe_dict["state"] = state
-                
-                # 下载配置
-                if sites is not None:
-                    subscribe_dict["sites"] = sites
-                if downloader is not None:
-                    subscribe_dict["downloader"] = downloader
-                if save_path is not None:
-                    subscribe_dict["save_path"] = save_path
-                if best_version is not None:
-                    subscribe_dict["best_version"] = best_version
-                
-                # 其他配置
-                if custom_words is not None:
-                    subscribe_dict["custom_words"] = custom_words
-                if media_category is not None:
-                    subscribe_dict["media_category"] = media_category
-                if episode_group is not None:
-                    subscribe_dict["episode_group"] = episode_group
-                
-                # 如果没有要更新的字段
-                if not subscribe_dict:
-                    return json.dumps({
-                        "success": False,
-                        "message": "没有提供要更新的字段"
-                    }, ensure_ascii=False)
-                
-                # 更新订阅
-                await subscribe.async_update(db, subscribe_dict)
-                
-                # 重新获取更新后的订阅数据
-                updated_subscribe = await Subscribe.async_get(db, subscribe_id)
-                
-                # 发送订阅调整事件
-                await eventmanager.async_send_event(EventType.SubscribeModified, {
-                    "subscribe_id": subscribe_id,
-                    "old_subscribe_info": old_subscribe_dict,
-                    "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
-                })
-                
-                # 构建返回结果
-                result = {
-                    "success": True,
-                    "message": f"订阅 #{subscribe_id} 更新成功",
-                    "subscribe_id": subscribe_id,
-                    "updated_fields": list(subscribe_dict.keys())
-                }
-                
-                if updated_subscribe:
-                    result["subscribe"] = {
-                        "id": updated_subscribe.id,
-                        "name": updated_subscribe.name,
-                        "year": updated_subscribe.year,
-                        "type": updated_subscribe.type,
-                        "season": updated_subscribe.season,
-                        "state": updated_subscribe.state,
-                        "total_episode": updated_subscribe.total_episode,
-                        "lack_episode": updated_subscribe.lack_episode,
-                        "start_episode": updated_subscribe.start_episode,
-                        "quality": updated_subscribe.quality,
-                        "resolution": updated_subscribe.resolution,
-                        "effect": updated_subscribe.effect
-                    }
-                
-                return json.dumps(result, ensure_ascii=False, indent=2)
-        
-        except Exception as e:
-            error_message = f"更新订阅失败: {str(e)}"
-            logger.error(f"更新订阅失败: {e}", exc_info=True)
-            return json.dumps({
-                "success": False,
-                "message": error_message,
-                "subscribe_id": subscribe_id
-            }, ensure_ascii=False)
-
--- a/app/agent/tools/manager.py
+++ b/app/agent/tools/manager.py
@@ -1,187 +0,0 @@
-"""MoviePilot工具管理器
-用于HTTP API调用工具
-"""
-
-import json
-from typing import Any, Dict, List, Optional
-
-from app.agent.tools.factory import MoviePilotToolFactory
-from app.log import logger
-
-
-class ToolDefinition:
-    """工具定义"""
-
-    def __init__(self, name: str, description: str, input_schema: Dict[str, Any]):
-        self.name = name
-        self.description = description
-        self.input_schema = input_schema
-
-
-class MoviePilotToolsManager:
-    """MoviePilot工具管理器（用于HTTP API）"""
-
-    def __init__(self, user_id: str = "api_user", session_id: str = "api_session"):
-        """
-        初始化工具管理器
-        
-        Args:
-            user_id: 用户ID
-            session_id: 会话ID
-        """
-        self.user_id = user_id
-        self.session_id = session_id
-        self.tools: List[Any] = []
-        self._load_tools()
-
-    def _load_tools(self):
-        """加载所有MoviePilot工具"""
-        try:
-            # 创建工具实例
-            self.tools = MoviePilotToolFactory.create_tools(
-                session_id=self.session_id,
-                user_id=self.user_id,
-                channel=None,
-                source="api",
-                username="API Client",
-                callback_handler=None
-            )
-            logger.info(f"成功加载 {len(self.tools)} 个工具")
-        except Exception as e:
-            logger.error(f"加载工具失败: {e}", exc_info=True)
-            self.tools = []
-
-    def list_tools(self) -> List[ToolDefinition]:
-        """
-        列出所有可用的工具
-        
-        Returns:
-            工具定义列表
-        """
-        tools_list = []
-        for tool in self.tools:
-            # 获取工具的输入参数模型
-            args_schema = getattr(tool, 'args_schema', None)
-            if args_schema:
-                # 将Pydantic模型转换为JSON Schema
-                input_schema = self._convert_to_json_schema(args_schema)
-            else:
-                # 如果没有args_schema，使用基本信息
-                input_schema = {
-                    "type": "object",
-                    "properties": {},
-                    "required": []
-                }
-
-            tools_list.append(ToolDefinition(
-                name=tool.name,
-                description=tool.description or "",
-                input_schema=input_schema
-            ))
-
-        return tools_list
-
-    def get_tool(self, tool_name: str) -> Optional[Any]:
-        """
-        获取指定工具实例
-        
-        Args:
-            tool_name: 工具名称
-            
-        Returns:
-            工具实例，如果未找到返回None
-        """
-        for tool in self.tools:
-            if tool.name == tool_name:
-                return tool
-        return None
-
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
-        """
-        调用工具
-        
-        Args:
-            tool_name: 工具名称
-            arguments: 工具参数
-            
-        Returns:
-            工具执行结果（字符串）
-        """
-        tool_instance = self.get_tool(tool_name)
-
-        if not tool_instance:
-            error_msg = json.dumps({
-                "error": f"工具 '{tool_name}' 未找到"
-            }, ensure_ascii=False)
-            return error_msg
-
-        try:
-            # 调用工具的run方法
-            result = await tool_instance.run(**arguments)
-
-            # 确保返回字符串
-            if isinstance(result, str):
-                return result
-            else:
-                return json.dumps(result, ensure_ascii=False, indent=2)
-        except Exception as e:
-            logger.error(f"调用工具 {tool_name} 时发生错误: {e}", exc_info=True)
-            error_msg = json.dumps({
-                "error": f"调用工具 '{tool_name}' 时发生错误: {str(e)}"
-            }, ensure_ascii=False)
-            return error_msg
-
-    @staticmethod
-    def _convert_to_json_schema(args_schema: Any) -> Dict[str, Any]:
-        """
-        将Pydantic模型转换为JSON Schema
-        
-        Args:
-            args_schema: Pydantic模型类
-            
-        Returns:
-            JSON Schema字典
-        """
-        # 获取Pydantic模型的字段信息
-        schema = args_schema.model_json_schema()
-
-        # 构建JSON Schema
-        properties = {}
-        required = []
-
-        if "properties" in schema:
-            for field_name, field_info in schema["properties"].items():
-                # 转换字段类型
-                field_type = field_info.get("type", "string")
-                field_description = field_info.get("description", "")
-
-                # 处理可选字段
-                if field_name not in schema.get("required", []):
-                    # 可选字段
-                    default_value = field_info.get("default")
-                    properties[field_name] = {
-                        "type": field_type,
-                        "description": field_description
-                    }
-                    if default_value is not None:
-                        properties[field_name]["default"] = default_value
-                else:
-                    properties[field_name] = {
-                        "type": field_type,
-                        "description": field_description
-                    }
-                    required.append(field_name)
-
-                # 处理枚举类型
-                if "enum" in field_info:
-                    properties[field_name]["enum"] = field_info["enum"]
-
-                # 处理数组类型
-                if field_type == "array" and "items" in field_info:
-                    properties[field_name]["items"] = field_info["items"]
-
-        return {
-            "type": "object",
-            "properties": properties,
-            "required": required
-        }
--- a/app/api/apiv1.py
+++ b/app/api/apiv1.py
@@ -1,8 +1,8 @@
 from fastapi import APIRouter

-from app.api.endpoints import login, user, webhook, message, site, subscribe, \
+from app.api.endpoints import login, user, site, message, webhook, subscribe, \
    media, douban, search, plugin, tmdb, history, system, download, dashboard, \
-    transfer, mediaserver, bangumi, storage, discover, recommend, workflow, torrent, mcp
+    local, transfer, mediaserver, bangumi, aliyun, u115

 api_router = APIRouter()
 api_router.include_router(login.router, prefix="/login", tags=["login"])
@@ -20,12 +20,9 @@ api_router.include_router(system.router, prefix="/system", tags=["system"])
 api_router.include_router(plugin.router, prefix="/plugin", tags=["plugin"])
 api_router.include_router(download.router, prefix="/download", tags=["download"])
 api_router.include_router(dashboard.router, prefix="/dashboard", tags=["dashboard"])
-api_router.include_router(storage.router, prefix="/storage", tags=["storage"])
+api_router.include_router(local.router, prefix="/local", tags=["local"])
 api_router.include_router(transfer.router, prefix="/transfer", tags=["transfer"])
 api_router.include_router(mediaserver.router, prefix="/mediaserver", tags=["mediaserver"])
 api_router.include_router(bangumi.router, prefix="/bangumi", tags=["bangumi"])
-api_router.include_router(discover.router, prefix="/discover", tags=["discover"])
-api_router.include_router(recommend.router, prefix="/recommend", tags=["recommend"])
-api_router.include_router(workflow.router, prefix="/workflow", tags=["workflow"])
-api_router.include_router(torrent.router, prefix="/torrent", tags=["torrent"])
-api_router.include_router(mcp.router, prefix="/mcp", tags=["mcp"])
+api_router.include_router(aliyun.router, prefix="/aliyun", tags=["aliyun"])
+api_router.include_router(u115.router, prefix="/u115", tags=["115"])
--- a/app/api/endpoints/aliyun.py
+++ b/app/api/endpoints/aliyun.py
@@ -0,0 +1,198 @@
+from pathlib import Path
+from typing import Any, List
+
+from fastapi import APIRouter, Depends, HTTPException
+from starlette.responses import Response
+
+from app import schemas
+from app.chain.transfer import TransferChain
+from app.core.config import settings
+from app.core.metainfo import MetaInfoPath
+from app.core.security import verify_token, verify_uri_token
+from app.helper.aliyun import AliyunHelper
+from app.helper.progress import ProgressHelper
+from app.schemas.types import ProgressKey
+
+router = APIRouter()
+
+
+@router.get("/qrcode", summary="生成二维码内容", response_model=schemas.Response)
+def qrcode(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    生成二维码
+    """
+    qrcode_data, errmsg = AliyunHelper().generate_qrcode()
+    if qrcode_data:
+        return schemas.Response(success=True, data=qrcode_data)
+    return schemas.Response(success=False, message=errmsg)
+
+
+@router.get("/check", summary="二维码登录确认", response_model=schemas.Response)
+def check(ck: str, t: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    二维码登录确认
+    """
+    if not ck or not t:
+        return schemas.Response(success=False, message="参数错误")
+    data, errmsg = AliyunHelper().check_login(ck, t)
+    if data:
+        return schemas.Response(success=True, data=data)
+    return schemas.Response(success=False, message=errmsg)
+
+
+@router.get("/userinfo", summary="查询用户信息", response_model=schemas.Response)
+def userinfo(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询用户信息
+    """
+    aliyunhelper = AliyunHelper()
+    # 查询用户信息返回
+    info = aliyunhelper.user_info()
+    if info:
+        return schemas.Response(success=True, data=info)
+    return schemas.Response(success=False)
+
+
+@router.post("/list", summary="所有目录和文件（阿里云盘）", response_model=List[schemas.FileItem])
+def list_aliyun(fileitem: schemas.FileItem,
+                sort: str = 'updated_at',
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询当前目录下所有目录和文件
+    :param fileitem: 文件夹信息
+    :param sort: 排序方式，name:按名称排序，time:按修改时间排序
+    :param _: token
+    :return: 所有目录和文件
+    """
+    if not fileitem.fileid:
+        return []
+    if not fileitem.path:
+        path = "/"
+    else:
+        path = fileitem.path
+    if sort == "time":
+        sort = "updated_at"
+    if fileitem.type == "file":
+        fileitem = AliyunHelper().detail(drive_id=fileitem.drive_id, file_id=fileitem.fileid, path=path)
+        if fileitem:
+            return [fileitem]
+        return []
+    return AliyunHelper().list(drive_id=fileitem.drive_id,
+                               parent_file_id=fileitem.fileid,
+                               path=path,
+                               order_by=sort)
+
+
+@router.post("/mkdir", summary="创建目录（阿里云盘）", response_model=schemas.Response)
+def mkdir_aliyun(fileitem: schemas.FileItem,
+                 name: str,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    创建目录
+    """
+    if not fileitem.fileid or not name:
+        return schemas.Response(success=False)
+    result = AliyunHelper().create_folder(drive_id=fileitem.drive_id, parent_file_id=fileitem.fileid,
+                                          name=name, path=fileitem.path)
+    if result:
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.post("/delete", summary="删除文件或目录（阿里云盘）", response_model=schemas.Response)
+def delete_aliyun(fileitem: schemas.FileItem,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    删除文件或目录
+    """
+    if not fileitem.fileid:
+        return schemas.Response(success=False)
+    result = AliyunHelper().delete(drive_id=fileitem.drive_id, file_id=fileitem.fileid)
+    if result:
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.get("/download", summary="下载文件（阿里云盘）")
+def download_aliyun(fileid: str,
+                    drive_id: str = None,
+                    _: schemas.TokenPayload = Depends(verify_uri_token)) -> Any:
+    """
+    下载文件或目录
+    """
+    if not fileid:
+        return schemas.Response(success=False)
+    url = AliyunHelper().download(drive_id=drive_id, file_id=fileid)
+    if url:
+        # 重定向
+        return Response(status_code=302, headers={"Location": url})
+    raise HTTPException(status_code=500, detail="下载文件出错")
+
+
+@router.post("/rename", summary="重命名文件或目录（阿里云盘）", response_model=schemas.Response)
+def rename_aliyun(fileitem: schemas.FileItem,
+                  new_name: str,
+                  recursive: bool = False,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    重命名文件或目录
+    """
+    if not fileitem.fileid or not new_name:
+        return schemas.Response(success=False)
+    result = AliyunHelper().rename(drive_id=fileitem.drive_id, file_id=fileitem.fileid, name=new_name)
+    if result:
+        if recursive:
+            transferchain = TransferChain()
+            media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIO_TRACK_EXT
+            # 递归修改目录内文件（智能识别命名）
+            sub_files: List[schemas.FileItem] = list_aliyun(fileitem=fileitem)
+            if sub_files:
+                # 开始进度
+                progress = ProgressHelper()
+                progress.start(ProgressKey.BatchRename)
+                total = len(sub_files)
+                handled = 0
+                for sub_file in sub_files:
+                    handled += 1
+                    progress.update(value=handled / total * 100,
+                                    text=f"正在处理 {sub_file.name} ...",
+                                    key=ProgressKey.BatchRename)
+                    if sub_file.type == "dir":
+                        continue
+                    if not sub_file.extension:
+                        continue
+                    if f".{sub_file.extension.lower()}" not in media_exts:
+                        continue
+                    sub_path = Path(f"{fileitem.path}{sub_file.name}")
+                    meta = MetaInfoPath(sub_path)
+                    mediainfo = transferchain.recognize_media(meta)
+                    if not mediainfo:
+                        progress.end(ProgressKey.BatchRename)
+                        return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
+                    new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
+                    if not new_path:
+                        progress.end(ProgressKey.BatchRename)
+                        return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
+                    ret: schemas.Response = rename_aliyun(fileitem=sub_file,
+                                                          new_name=Path(new_path).name,
+                                                          recursive=False)
+                    if not ret.success:
+                        progress.end(ProgressKey.BatchRename)
+                        return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
+                progress.end(ProgressKey.BatchRename)
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.get("/image", summary="读取图片（阿里云盘）", response_model=schemas.Response)
+def image_aliyun(fileid: str, drive_id: str = None, _: schemas.TokenPayload = Depends(verify_uri_token)) -> Any:
+    """
+    读取图片
+    """
+    if not fileid:
+        return schemas.Response(success=False)
+    url = AliyunHelper().download(drive_id=drive_id, file_id=fileid)
+    if url:
+        # 重定向
+        return Response(status_code=302, headers={"Location": url})
+    raise HTTPException(status_code=500, detail="下载图片出错")
--- a/app/api/endpoints/bangumi.py
+++ b/app/api/endpoints/bangumi.py
@@ -1,4 +1,4 @@
-from typing import List, Any, Optional
+from typing import List, Any

 from fastapi import APIRouter, Depends

@@ -10,64 +10,76 @@ from app.core.security import verify_token
 router = APIRouter()


+@router.get("/calendar", summary="Bangumi每日放送", response_model=List[schemas.MediaInfo])
+def calendar(page: int = 1,
+             count: int = 30,
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览Bangumi每日放送
+    """
+    medias = BangumiChain().calendar()
+    if medias:
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
+    return []
+
+
@router.get("/credits/{bangumiid}", summary="查询Bangumi演职员表", response_model=List[schemas.MediaPerson])
-async def bangumi_credits(bangumiid: int,
-                          page: Optional[int] = 1,
-                          count: Optional[int] = 20,
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def bangumi_credits(bangumiid: int,
+                    page: int = 1,
+                    count: int = 20,
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询Bangumi演职员表
    """
-    persons = await BangumiChain().async_bangumi_credits(bangumiid)
+    persons = BangumiChain().bangumi_credits(bangumiid)
    if persons:
        return persons[(page - 1) * count: page * count]
    return []


@router.get("/recommend/{bangumiid}", summary="查询Bangumi推荐", response_model=List[schemas.MediaInfo])
-async def bangumi_recommend(bangumiid: int,
-                            page: Optional[int] = 1,
-                            count: Optional[int] = 20,
-                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def bangumi_recommend(bangumiid: int,
+                      page: int = 1,
+                      count: int = 20,
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询Bangumi推荐
    """
-    medias = await BangumiChain().async_bangumi_recommend(bangumiid)
+    medias = BangumiChain().bangumi_recommend(bangumiid)
    if medias:
        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
    return []


@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
-async def bangumi_person(person_id: int,
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def bangumi_person(person_id: int,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据人物ID查询人物详情
    """
-    return await BangumiChain().async_person_detail(person_id=person_id)
+    return BangumiChain().person_detail(person_id=person_id)


@router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
-async def bangumi_person_credits(person_id: int,
-                                 page: Optional[int] = 1,
-                                 count: Optional[int] = 20,
-                                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def bangumi_person_credits(person_id: int,
+                           page: int = 1,
+                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据人物ID查询人物参演作品
    """
-    medias = await BangumiChain().async_person_credits(person_id=person_id)
+    medias = BangumiChain().person_credits(person_id=person_id)
    if medias:
-        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
+        return [media.to_dict() for media in medias[(page - 1) * 20: page * 20]]
    return []


@router.get("/{bangumiid}", summary="查询Bangumi详情", response_model=schemas.MediaInfo)
-async def bangumi_info(bangumiid: int,
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def bangumi_info(bangumiid: int,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询Bangumi详情
    """
-    info = await BangumiChain().async_bangumi_info(bangumiid)
+    info = BangumiChain().bangumi_info(bangumiid)
    if info:
        return MediaInfo(bangumi_info=info).to_dict()
    else:
--- a/app/api/endpoints/dashboard.py
+++ b/app/api/endpoints/dashboard.py
@@ -1,12 +1,11 @@
 from pathlib import Path
-from typing import Any, List, Optional, Annotated
+from typing import Any, List, Optional

 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session

 from app import schemas
 from app.chain.dashboard import DashboardChain
-from app.chain.storage import StorageChain
 from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
 from app.db.models.transferhistory import TransferHistory
@@ -18,11 +17,11 @@ router = APIRouter()


@router.get("/statistic", summary="媒体数量统计", response_model=schemas.Statistic)
-def statistic(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def statistic(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询媒体数量统计信息
    """
-    media_statistics: Optional[List[schemas.Statistic]] = DashboardChain().media_statistic(name)
+    media_statistics: Optional[List[schemas.Statistic]] = DashboardChain().media_statistic()
    if media_statistics:
        # 汇总各媒体库统计信息
        ret_statistic = schemas.Statistic()
@@ -37,38 +36,30 @@ def statistic(name: Optional[str] = None, _: schemas.TokenPayload = Depends(veri


@router.get("/statistic2", summary="媒体数量统计（API_TOKEN）", response_model=schemas.Statistic)
-def statistic2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def statistic2(_: str = Depends(verify_apitoken)) -> Any:
    """
    查询媒体数量统计信息 API_TOKEN认证（?token=xxx）
    """
    return statistic()


-@router.get("/storage", summary="本地存储空间", response_model=schemas.Storage)
+@router.get("/storage", summary="存储空间", response_model=schemas.Storage)
 def storage(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    查询本地存储空间信息
+    查询存储空间信息
    """
-    total, available = 0, 0
-    dirs = DirectoryHelper().get_dirs()
-    if not dirs:
-        return schemas.Storage(total_storage=total, used_storage=total - available)
-    storages = set([d.library_storage for d in dirs if d.library_storage])
-    for _storage in storages:
-        _usage = StorageChain().storage_usage(_storage)
-        if _usage:
-            total += _usage.total
-            available += _usage.available
+    library_dirs = DirectoryHelper().get_library_dirs()
+    total_storage, free_storage = SystemUtils.space_usage([Path(d.path) for d in library_dirs if d.path])
    return schemas.Storage(
-        total_storage=total,
-        used_storage=total - available
+        total_storage=total_storage,
+        used_storage=total_storage - free_storage
    )


-@router.get("/storage2", summary="本地存储空间（API_TOKEN）", response_model=schemas.Storage)
-def storage2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+@router.get("/storage2", summary="存储空间（API_TOKEN）", response_model=schemas.Storage)
+def storage2(_: str = Depends(verify_apitoken)) -> Any:
    """
-    查询本地存储空间信息 API_TOKEN认证（?token=xxx）
+    查询存储空间信息 API_TOKEN认证（?token=xxx）
    """
    return storage()

@@ -82,16 +73,16 @@ def processes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:


@router.get("/downloader", summary="下载器信息", response_model=schemas.DownloaderInfo)
-def downloader(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def downloader(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询下载器信息
    """
    # 下载目录空间
-    download_dirs = DirectoryHelper().get_local_download_dirs()
-    _, free_space = SystemUtils.space_usage([Path(d.download_path) for d in download_dirs])
+    download_dirs = DirectoryHelper().get_download_dirs()
+    _, free_space = SystemUtils.space_usage([Path(d.path) for d in download_dirs if d.path])
    # 下载器信息
    downloader_info = schemas.DownloaderInfo()
-    transfer_infos = DashboardChain().downloader_info(name)
+    transfer_infos = DashboardChain().downloader_info()
    if transfer_infos:
        for transfer_info in transfer_infos:
            downloader_info.download_speed += transfer_info.download_speed
@@ -103,7 +94,7 @@ def downloader(name: Optional[str] = None, _: schemas.TokenPayload = Depends(ver


@router.get("/downloader2", summary="下载器信息（API_TOKEN）", response_model=schemas.DownloaderInfo)
-def downloader2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def downloader2(_: str = Depends(verify_apitoken)) -> Any:
    """
    查询下载器信息 API_TOKEN认证（?token=xxx）
    """
@@ -111,7 +102,7 @@ def downloader2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:


@router.get("/schedule", summary="后台服务", response_model=List[schemas.ScheduleInfo])
-async def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询后台服务信息
    """
@@ -119,25 +110,24 @@ async def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:


@router.get("/schedule2", summary="后台服务（API_TOKEN）", response_model=List[schemas.ScheduleInfo])
-async def schedule2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def schedule2(_: str = Depends(verify_apitoken)) -> Any:
    """
    查询下载器信息 API_TOKEN认证（?token=xxx）
    """
-    return await schedule()
+    return schedule()


@router.get("/transfer", summary="文件整理统计", response_model=List[int])
-async def transfer(days: Optional[int] = 7,
-                   db: Session = Depends(get_db),
-                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def transfer(days: int = 7, db: Session = Depends(get_db),
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询文件整理统计信息
    """
-    transfer_stat = await TransferHistory.async_statistic(db, days)
+    transfer_stat = TransferHistory.statistic(db, days)
    return [stat[1] for stat in transfer_stat]


-@router.get("/cpu", summary="获取当前CPU使用率", response_model=float)
+@router.get("/cpu", summary="获取当前CPU使用率", response_model=int)
 def cpu(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    获取当前CPU使用率
@@ -145,8 +135,8 @@ def cpu(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    return SystemUtils.cpu_usage()


-@router.get("/cpu2", summary="获取当前CPU使用率（API_TOKEN）", response_model=float)
-def cpu2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+@router.get("/cpu2", summary="获取当前CPU使用率（API_TOKEN）", response_model=int)
+def cpu2(_: str = Depends(verify_apitoken)) -> Any:
    """
    获取当前CPU使用率 API_TOKEN认证（?token=xxx）
    """
@@ -162,24 +152,8 @@ def memory(_: schemas.TokenPayload = Depends(verify_token)) -> Any:


@router.get("/memory2", summary="获取当前内存使用量和使用率（API_TOKEN）", response_model=List[int])
-def memory2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def memory2(_: str = Depends(verify_apitoken)) -> Any:
    """
    获取当前内存使用率 API_TOKEN认证（?token=xxx）
    """
    return memory()
-
-
-@router.get("/network", summary="获取当前网络流量", response_model=List[int])
-def network(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取当前网络流量（上行和下行流量，单位：bytes/s）
-    """
-    return SystemUtils.network_usage()
-
-
-@router.get("/network2", summary="获取当前网络流量（API_TOKEN）", response_model=List[int])
-def network2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
-    """
-    获取当前网络流量 API_TOKEN认证（?token=xxx）
-    """
-    return network()
--- a/app/api/endpoints/discover.py
+++ b/app/api/endpoints/discover.py
@@ -1,130 +0,0 @@
-from typing import Any, List, Optional
-
-from fastapi import APIRouter, Depends
-
-from app import schemas
-from app.chain.bangumi import BangumiChain
-from app.chain.douban import DoubanChain
-from app.chain.tmdb import TmdbChain
-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
-
-router = APIRouter()
-
-
-@router.get("/source", summary="获取探索数据源", response_model=List[schemas.DiscoverMediaSource])
-def source(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取探索数据源
-    """
-    # 广播事件，请示额外的探索数据源支持
-    event_data = DiscoverSourceEventData()
-    event = eventmanager.send_event(ChainEventType.DiscoverSource, event_data)
-    # 使用事件返回的上下文数据
-    if event and event.event_data:
-        event_data: DiscoverSourceEventData = event.event_data
-        if event_data.extra_sources:
-            return event_data.extra_sources
-    return []
-
-
-@router.get("/bangumi", summary="探索Bangumi", response_model=List[schemas.MediaInfo])
-async def bangumi(type: Optional[int] = 2,
-                  cat: Optional[int] = None,
-                  sort: Optional[str] = 'rank',
-                  year: Optional[str] = None,
-                  page: Optional[int] = 1,
-                  count: Optional[int] = 30,
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    探索Bangumi
-    """
-    medias = await BangumiChain().async_discover(type=type, cat=cat, sort=sort, year=year,
-                                                 limit=count, offset=(page - 1) * count)
-    if medias:
-        return [media.to_dict() for media in medias]
-    return []
-
-
-@router.get("/douban_movies", summary="探索豆瓣电影", response_model=List[schemas.MediaInfo])
-async def douban_movies(sort: Optional[str] = "R",
-                        tags: Optional[str] = "",
-                        page: Optional[int] = 1,
-                        count: Optional[int] = 30,
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣电影信息
-    """
-    movies = await DoubanChain().async_douban_discover(mtype=MediaType.MOVIE,
-                                                       sort=sort, tags=tags, page=page, count=count)
-    return [media.to_dict() for media in movies] if movies else []
-
-
-@router.get("/douban_tvs", summary="探索豆瓣剧集", response_model=List[schemas.MediaInfo])
-async def douban_tvs(sort: Optional[str] = "R",
-                     tags: Optional[str] = "",
-                     page: Optional[int] = 1,
-                     count: Optional[int] = 30,
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    tvs = await DoubanChain().async_douban_discover(mtype=MediaType.TV,
-                                                    sort=sort, tags=tags, page=page, count=count)
-    return [media.to_dict() for media in tvs] if tvs else []
-
-
-@router.get("/tmdb_movies", summary="探索TMDB电影", response_model=List[schemas.MediaInfo])
-async def tmdb_movies(sort_by: Optional[str] = "popularity.desc",
-                      with_genres: Optional[str] = "",
-                      with_original_language: Optional[str] = "",
-                      with_keywords: Optional[str] = "",
-                      with_watch_providers: Optional[str] = "",
-                      vote_average: Optional[float] = 0.0,
-                      vote_count: Optional[int] = 0,
-                      release_date: Optional[str] = "",
-                      page: Optional[int] = 1,
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB电影信息
-    """
-    movies = await TmdbChain().async_tmdb_discover(mtype=MediaType.MOVIE,
-                                                   sort_by=sort_by,
-                                                   with_genres=with_genres,
-                                                   with_original_language=with_original_language,
-                                                   with_keywords=with_keywords,
-                                                   with_watch_providers=with_watch_providers,
-                                                   vote_average=vote_average,
-                                                   vote_count=vote_count,
-                                                   release_date=release_date,
-                                                   page=page)
-    return [movie.to_dict() for movie in movies] if movies else []
-
-
-@router.get("/tmdb_tvs", summary="探索TMDB剧集", response_model=List[schemas.MediaInfo])
-async def tmdb_tvs(sort_by: Optional[str] = "popularity.desc",
-                   with_genres: Optional[str] = "",
-                   with_original_language: Optional[str] = "",
-                   with_keywords: Optional[str] = "",
-                   with_watch_providers: Optional[str] = "",
-                   vote_average: Optional[float] = 0.0,
-                   vote_count: Optional[int] = 0,
-                   release_date: Optional[str] = "",
-                   page: Optional[int] = 1,
-                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB剧集信息
-    """
-    tvs = await TmdbChain().async_tmdb_discover(mtype=MediaType.TV,
-                                                sort_by=sort_by,
-                                                with_genres=with_genres,
-                                                with_original_language=with_original_language,
-                                                with_keywords=with_keywords,
-                                                with_watch_providers=with_watch_providers,
-                                                vote_average=vote_average,
-                                                vote_count=vote_count,
-                                                release_date=release_date,
-                                                page=page)
-    return [tv.to_dict() for tv in tvs] if tvs else []
--- a/app/api/endpoints/douban.py
+++ b/app/api/endpoints/douban.py
@@ -1,65 +1,206 @@
-from typing import Any, List, Optional
+from typing import List, Any

-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Response

 from app import schemas
 from app.chain.douban import DoubanChain
+from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.security import verify_token
 from app.schemas import MediaType
+from app.utils.http import RequestUtils

 router = APIRouter()


+@router.get("/img", summary="豆瓣图片代理")
+def douban_img(imgurl: str) -> Any:
+    """
+    豆瓣图片代理
+    """
+    if not imgurl:
+        return None
+    response = RequestUtils(headers={
+        'Referer': "https://movie.douban.com/"
+    }, ua=settings.USER_AGENT).get_res(url=imgurl)
+    if response:
+        return Response(content=response.content, media_type="image/jpeg")
+    return None
+
+
@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
-async def douban_person(person_id: int,
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def douban_person(person_id: int,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据人物ID查询人物详情
    """
-    return await DoubanChain().async_person_detail(person_id=person_id)
+    return DoubanChain().person_detail(person_id=person_id)


@router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
-async def douban_person_credits(person_id: int,
-                                page: Optional[int] = 1,
-                                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def douban_person_credits(person_id: int,
+                          page: int = 1,
+                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据人物ID查询人物参演作品
    """
-    medias = await DoubanChain().async_person_credits(person_id=person_id, page=page)
+    medias = DoubanChain().person_credits(person_id=person_id, page=page)
    if medias:
        return [media.to_dict() for media in medias]
    return []


+@router.get("/showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
+def movie_showing(page: int = 1,
+                  count: int = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣正在热映
+    """
+    movies = DoubanChain().movie_showing(page=page, count=count)
+    if movies:
+        return [media.to_dict() for media in movies]
+    return []
+
+
+@router.get("/movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
+def douban_movies(sort: str = "R",
+                  tags: str = "",
+                  page: int = 1,
+                  count: int = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣电影信息
+    """
+    movies = DoubanChain().douban_discover(mtype=MediaType.MOVIE,
+                                           sort=sort, tags=tags, page=page, count=count)
+    if movies:
+        return [media.to_dict() for media in movies]
+    return []
+
+
+@router.get("/tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
+def douban_tvs(sort: str = "R",
+               tags: str = "",
+               page: int = 1,
+               count: int = 30,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    tvs = DoubanChain().douban_discover(mtype=MediaType.TV,
+                                        sort=sort, tags=tags, page=page, count=count)
+    if tvs:
+        return [media.to_dict() for media in tvs]
+    return []
+
+
+@router.get("/movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
+def movie_top250(page: int = 1,
+                 count: int = 30,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    movies = DoubanChain().movie_top250(page=page, count=count)
+    if movies:
+        return [media.to_dict() for media in movies]
+    return []
+
+
+@router.get("/tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
+def tv_weekly_chinese(page: int = 1,
+                      count: int = 30,
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    中国每周剧集口碑榜
+    """
+    tvs = DoubanChain().tv_weekly_chinese(page=page, count=count)
+    if tvs:
+        return [media.to_dict() for media in tvs]
+    return []
+
+
+@router.get("/tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
+def tv_weekly_global(page: int = 1,
+                     count: int = 30,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    全球每周剧集口碑榜
+    """
+    tvs = DoubanChain().tv_weekly_global(page=page, count=count)
+    if tvs:
+        return [media.to_dict() for media in tvs]
+    return []
+
+
+@router.get("/tv_animation", summary="豆瓣动画剧集", response_model=List[schemas.MediaInfo])
+def tv_animation(page: int = 1,
+                 count: int = 30,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门动画剧集
+    """
+    tvs = DoubanChain().tv_animation(page=page, count=count)
+    if tvs:
+        return [media.to_dict() for media in tvs]
+    return []
+
+
+@router.get("/movie_hot", summary="豆瓣热门电影", response_model=List[schemas.MediaInfo])
+def movie_hot(page: int = 1,
+              count: int = 30,
+              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门电影
+    """
+    movies = DoubanChain().movie_hot(page=page, count=count)
+    if movies:
+        return [media.to_dict() for media in movies]
+    return []
+
+
+@router.get("/tv_hot", summary="豆瓣热门电视剧", response_model=List[schemas.MediaInfo])
+def tv_hot(page: int = 1,
+           count: int = 30,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门电视剧
+    """
+    tvs = DoubanChain().tv_hot(page=page, count=count)
+    if tvs:
+        return [media.to_dict() for media in tvs]
+    return []
+
+
@router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.MediaPerson])
-async def douban_credits(doubanid: str,
-                         type_name: str,
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def douban_credits(doubanid: str,
+                   type_name: str,
+                   page: int = 1,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据豆瓣ID查询演员阵容，type_name: 电影/电视剧
    """
    mediatype = MediaType(type_name)
    if mediatype == MediaType.MOVIE:
-        return await DoubanChain().async_movie_credits(doubanid=doubanid)
+        return DoubanChain().movie_credits(doubanid=doubanid)
    elif mediatype == MediaType.TV:
-        return await DoubanChain().async_tv_credits(doubanid=doubanid)
+        return DoubanChain().tv_credits(doubanid=doubanid)
    return []


@router.get("/recommend/{doubanid}/{type_name}", summary="豆瓣推荐电影/电视剧", response_model=List[schemas.MediaInfo])
-async def douban_recommend(doubanid: str,
-                           type_name: str,
-                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def douban_recommend(doubanid: str,
+                     type_name: str,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据豆瓣ID查询推荐电影/电视剧，type_name: 电影/电视剧
    """
    mediatype = MediaType(type_name)
    if mediatype == MediaType.MOVIE:
-        medias = await DoubanChain().async_movie_recommend(doubanid=doubanid)
+        medias = DoubanChain().movie_recommend(doubanid=doubanid)
    elif mediatype == MediaType.TV:
-        medias = await DoubanChain().async_tv_recommend(doubanid=doubanid)
+        medias = DoubanChain().tv_recommend(doubanid=doubanid)
    else:
        return []
    if medias:
@@ -68,12 +209,12 @@ async def douban_recommend(doubanid: str,


@router.get("/{doubanid}", summary="查询豆瓣详情", response_model=schemas.MediaInfo)
-async def douban_info(doubanid: str,
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def douban_info(doubanid: str,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据豆瓣ID查询豆瓣媒体信息
    """
-    doubaninfo = await DoubanChain().async_douban_info(doubanid=doubanid)
+    doubaninfo = DoubanChain().douban_info(doubanid=doubanid)
    if doubaninfo:
        return MediaInfo(douban_info=doubaninfo).to_dict()
    else:
--- a/app/api/endpoints/download.py
+++ b/app/api/endpoints/download.py
@@ -1,38 +1,32 @@
-from typing import Any, List, Annotated, Optional
+from typing import Any, List

-from fastapi import APIRouter, Depends, Body
+from fastapi import APIRouter, Depends

 from app import schemas
 from app.chain.download import DownloadChain
 from app.chain.media import MediaChain
 from app.core.context import MediaInfo, Context, TorrentInfo
-from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
 from app.db.models.user import User
-from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_user
-from app.schemas.types import ChainEventType, SystemConfigKey
+from app.db.userauth import get_current_active_user

 router = APIRouter()


@router.get("/", summary="正在下载", response_model=List[schemas.DownloadingTorrent])
-def current(
-        name: Optional[str] = None,
+def read(
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询正在下载的任务
    """
-    return DownloadChain().downloading(name)
+    return DownloadChain().downloading()


@router.post("/", summary="添加下载（含媒体信息）", response_model=schemas.Response)
 def download(
        media_in: schemas.MediaInfo,
        torrent_in: schemas.TorrentInfo,
-        downloader: Annotated[str | None, Body()] = None,
-        save_path: Annotated[str | None, Body()] = None,
        current_user: User = Depends(get_current_active_user)) -> Any:
    """
    添加下载任务（含媒体信息）
@@ -41,20 +35,17 @@ def download(
    metainfo = MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
    # 媒体信息
    mediainfo = MediaInfo()
-    mediainfo.from_dict(media_in.model_dump())
+    mediainfo.from_dict(media_in.dict())
    # 种子信息
    torrentinfo = TorrentInfo()
-    torrentinfo.from_dict(torrent_in.model_dump())
-    # 手动下载始终使用选择的下载器
-    torrentinfo.site_downloader = downloader
+    torrentinfo.from_dict(torrent_in.dict())
    # 上下文
    context = Context(
        meta_info=metainfo,
        media_info=mediainfo,
        torrent_info=torrentinfo
    )
-    did = DownloadChain().download_single(context=context, username=current_user.name,
-                                          save_path=save_path, source="Manual")
+    did = DownloadChain().download_single(context=context, username=current_user.name)
    if not did:
        return schemas.Response(success=False, message="任务添加失败")
    return schemas.Response(success=True, data={
@@ -65,11 +56,6 @@ def download(
@router.post("/add", summary="添加下载（不含媒体信息）", response_model=schemas.Response)
 def add(
        torrent_in: schemas.TorrentInfo,
-        tmdbid: Annotated[int | None, Body()] = None,
-        doubanid: Annotated[str | None, Body()] = None,
-        downloader: Annotated[str | None, Body()] = None,
-        # 保存路径, 支持<storage>:<path>, 如rclone:/MP, smb:/server/share/Movies等
-        save_path: Annotated[str | None, Body()] = None,
        current_user: User = Depends(get_current_active_user)) -> Any:
    """
    添加下载任务（不含媒体信息）
@@ -77,25 +63,19 @@ def add(
    # 元数据
    metainfo = MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
    # 媒体信息
-    mediainfo = MediaChain().recognize_media(meta=metainfo, tmdbid=tmdbid, doubanid=doubanid)
+    mediainfo = MediaChain().recognize_media(meta=metainfo)
    if not mediainfo:
-        # 尝试使用辅助识别，如果有注册响应事件的话
-        if eventmanager.check(ChainEventType.NameRecognize):
-            mediainfo = MediaChain().recognize_help(title=torrent_in.title, org_meta=metainfo)
-        if not mediainfo:
-            return schemas.Response(success=False, message="无法识别媒体信息")
+        return schemas.Response(success=False, message="无法识别媒体信息")
    # 种子信息
    torrentinfo = TorrentInfo()
-    torrentinfo.from_dict(torrent_in.model_dump())
+    torrentinfo.from_dict(torrent_in.dict())
    # 上下文
    context = Context(
        meta_info=metainfo,
        media_info=mediainfo,
        torrent_info=torrentinfo
    )
-
-    did = DownloadChain().download_single(context=context, username=current_user.name,
-                                          downloader=downloader, save_path=save_path, source="Manual")
+    did = DownloadChain().download_single(context=context, username=current_user.name)
    if not did:
        return schemas.Response(success=False, message="任务添加失败")
    return schemas.Response(success=True, data={
@@ -105,41 +85,32 @@ def add(

@router.get("/start/{hashString}", summary="开始任务", response_model=schemas.Response)
 def start(
-        hashString: str, name: Optional[str] = None,
+        hashString: str,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    开如下载任务
    """
-    ret = DownloadChain().set_downloading(hashString, "start", name=name)
+    ret = DownloadChain().set_downloading(hashString, "start")
    return schemas.Response(success=True if ret else False)


@router.get("/stop/{hashString}", summary="暂停任务", response_model=schemas.Response)
-def stop(hashString: str, name: Optional[str] = None,
-         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def stop(
+        hashString: str,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    暂停下载任务
    """
-    ret = DownloadChain().set_downloading(hashString, "stop", name=name)
+    ret = DownloadChain().set_downloading(hashString, "stop")
    return schemas.Response(success=True if ret else False)


-@router.get("/clients", summary="查询可用下载器", response_model=List[dict])
-async def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询可用下载器
-    """
-    downloaders: List[dict] = SystemConfigOper().get(SystemConfigKey.Downloaders)
-    if downloaders:
-        return [{"name": d.get("name"), "type": d.get("type")} for d in downloaders if d.get("enabled")]
-    return []
-
-
@router.delete("/{hashString}", summary="删除下载任务", response_model=schemas.Response)
-def delete(hashString: str, name: Optional[str] = None,
-           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def info(
+        hashString: str,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    删除下载任务
    """
-    ret = DownloadChain().remove_downloading(hashString, name=name)
+    ret = DownloadChain().remove_downloading(hashString)
    return schemas.Response(success=True if ret else False)
--- a/app/api/endpoints/history.py
+++ b/app/api/endpoints/history.py
@@ -1,55 +1,54 @@
-from typing import List, Any, Optional
+from pathlib import Path
+from typing import List, Any

-import jieba
 from fastapi import APIRouter, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session

 from app import schemas
-from app.chain.storage import StorageChain
+from app.chain.transfer import TransferChain
 from app.core.event import eventmanager
 from app.core.security import verify_token
-from app.db import get_async_db, get_db
+from app.db import get_db
 from app.db.models import User
 from app.db.models.downloadhistory import DownloadHistory
 from app.db.models.transferhistory import TransferHistory
-from app.db.user_oper import get_current_active_superuser_async, get_current_active_superuser
+from app.db.userauth import get_current_active_superuser
 from app.schemas.types import EventType

 router = APIRouter()


@router.get("/download", summary="查询下载历史记录", response_model=List[schemas.DownloadHistory])
-async def download_history(page: Optional[int] = 1,
-                           count: Optional[int] = 30,
-                           db: AsyncSession = Depends(get_async_db),
-                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def download_history(page: int = 1,
+                     count: int = 30,
+                     db: Session = Depends(get_db),
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询下载历史记录
    """
-    return await DownloadHistory.async_list_by_page(db, page, count)
+    return DownloadHistory.list_by_page(db, page, count)


@router.delete("/download", summary="删除下载历史记录", response_model=schemas.Response)
-async def delete_download_history(history_in: schemas.DownloadHistory,
-                                  db: AsyncSession = Depends(get_async_db),
-                                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def delete_download_history(history_in: schemas.DownloadHistory,
+                            db: Session = Depends(get_db),
+                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    删除下载历史记录
    """
-    await DownloadHistory.async_delete(db, history_in.id)
+    DownloadHistory.delete(db, history_in.id)
    return schemas.Response(success=True)


-@router.get("/transfer", summary="查询整理记录", response_model=schemas.Response)
-async def transfer_history(title: Optional[str] = None,
-                           page: Optional[int] = 1,
-                           count: Optional[int] = 30,
-                           status: Optional[bool] = None,
-                           db: AsyncSession = Depends(get_async_db),
-                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/transfer", summary="查询转移历史记录", response_model=schemas.Response)
+def transfer_history(title: str = None,
+                     page: int = 1,
+                     count: int = 30,
+                     status: bool = None,
+                     db: Session = Depends(get_db),
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    查询整理记录
+    查询转移历史记录
    """
    if title == "失败":
        title = None
@@ -59,45 +58,42 @@ async def transfer_history(title: Optional[str] = None,
        status = True

    if title:
-        words = jieba.cut(title, HMM=False)
-        title = "%".join(words)
-        total = await TransferHistory.async_count_by_title(db, title=title, status=status)
-        result = await TransferHistory.async_list_by_title(db, title=title, page=page,
-                                                           count=count, status=status)
+        total = TransferHistory.count_by_title(db, title=title, status=status)
+        result = TransferHistory.list_by_title(db, title=title, page=page,
+                                               count=count, status=status)
    else:
-        result = await TransferHistory.async_list_by_page(db, page=page, count=count, status=status)
-        total = await TransferHistory.async_count(db, status=status)
+        result = TransferHistory.list_by_page(db, page=page, count=count, status=status)
+        total = TransferHistory.count(db, status=status)

    return schemas.Response(success=True,
                            data={
-                                "list": [item.to_dict() for item in result],
+                                "list": result,
                                "total": total,
                            })


-@router.delete("/transfer", summary="删除整理记录", response_model=schemas.Response)
+@router.delete("/transfer", summary="删除转移历史记录", response_model=schemas.Response)
 def delete_transfer_history(history_in: schemas.TransferHistory,
-                            deletesrc: Optional[bool] = False,
-                            deletedest: Optional[bool] = False,
+                            deletesrc: bool = False,
+                            deletedest: bool = False,
                            db: Session = Depends(get_db),
-                            _: User = Depends(get_current_active_superuser)) -> Any:
+                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    删除整理记录
+    删除转移历史记录
    """
-    history: TransferHistory = TransferHistory.get(db, history_in.id)
+    history = TransferHistory.get(db, history_in.id)
    if not history:
-        return schemas.Response(success=False, message="记录不存在")
+        return schemas.Response(success=False, msg="记录不存在")
    # 册除媒体库文件
-    if deletedest and history.dest_fileitem:
-        dest_fileitem = schemas.FileItem(**history.dest_fileitem)
-        StorageChain().delete_media_file(dest_fileitem)
-
-    # 删除源文件
-    if deletesrc and history.src_fileitem:
-        src_fileitem = schemas.FileItem(**history.src_fileitem)
-        state = StorageChain().delete_media_file(src_fileitem)
+    if deletedest and history.dest:
+        state, msg = TransferChain().delete_files(Path(history.dest))
        if not state:
-            return schemas.Response(success=False, message=f"{src_fileitem.path} 删除失败")
+            return schemas.Response(success=False, msg=msg)
+    # 删除源文件
+    if deletesrc and history.src:
+        state, msg = TransferChain().delete_files(Path(history.src))
+        if not state:
+            return schemas.Response(success=False, msg=msg)
        # 发送事件
        eventmanager.send_event(
            EventType.DownloadFileDeleted,
@@ -111,11 +107,11 @@ def delete_transfer_history(history_in: schemas.TransferHistory,
    return schemas.Response(success=True)


-@router.get("/empty/transfer", summary="清空整理记录", response_model=schemas.Response)
-async def empty_transfer_history(db: AsyncSession = Depends(get_async_db),
-                                 _: User = Depends(get_current_active_superuser_async)) -> Any:
+@router.get("/empty/transfer", summary="清空转移历史记录", response_model=schemas.Response)
+def delete_transfer_history(db: Session = Depends(get_db),
+                            _: User = Depends(get_current_active_superuser)) -> Any:
    """
-    清空整理记录
+    清空转移历史记录
    """
-    await TransferHistory.async_truncate(db)
+    TransferHistory.truncate(db)
    return schemas.Response(success=True)
--- a/app/api/endpoints/local.py
+++ b/app/api/endpoints/local.py
@@ -0,0 +1,273 @@
+import shutil
+from pathlib import Path
+from typing import Any, List
+
+from fastapi import APIRouter, Depends, HTTPException
+from starlette.responses import FileResponse, Response
+
+from app import schemas
+from app.chain.transfer import TransferChain
+from app.core.config import settings
+from app.core.metainfo import MetaInfoPath
+from app.core.security import verify_token, verify_uri_token
+from app.helper.progress import ProgressHelper
+from app.log import logger
+from app.schemas.types import ProgressKey
+from app.utils.system import SystemUtils
+
+router = APIRouter()
+
+IMAGE_TYPES = [".jpg", ".png", ".gif", ".bmp", ".jpeg", ".webp"]
+
+
+@router.post("/list", summary="所有目录和文件（本地）", response_model=List[schemas.FileItem])
+def list_local(fileitem: schemas.FileItem,
+               sort: str = 'time',
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询当前目录下所有目录和文件
+    :param fileitem: 文件项
+    :param sort: 排序方式，name:按名称排序，time:按修改时间排序
+    :param _: token
+    :return: 所有目录和文件
+    """
+    # 返回结果
+    ret_items = []
+    path = fileitem.path
+    if not fileitem.path or fileitem.path == "/":
+        if SystemUtils.is_windows():
+            partitions = SystemUtils.get_windows_drives() or ["C:/"]
+            for partition in partitions:
+                ret_items.append(schemas.FileItem(
+                    type="dir",
+                    path=partition + "/",
+                    name=partition,
+                    basename=partition
+                ))
+            return ret_items
+        else:
+            path = "/"
+    else:
+        if SystemUtils.is_windows():
+            path = path.lstrip("/")
+        elif not path.startswith("/"):
+            path = "/" + path
+
+    # 遍历目录
+    path_obj = Path(path)
+    if not path_obj.exists():
+        logger.warn(f"目录不存在：{path}")
+        return []
+
+    # 如果是文件
+    if path_obj.is_file():
+        ret_items.append(schemas.FileItem(
+            type="file",
+            path=str(path_obj).replace("\\", "/"),
+            name=path_obj.name,
+            basename=path_obj.stem,
+            extension=path_obj.suffix[1:],
+            size=path_obj.stat().st_size,
+            modify_time=path_obj.stat().st_mtime,
+        ))
+        return ret_items
+
+    # 扁历所有目录
+    for item in SystemUtils.list_sub_directory(path_obj):
+        ret_items.append(schemas.FileItem(
+            type="dir",
+            path=str(item).replace("\\", "/") + "/",
+            name=item.name,
+            basename=item.stem,
+            modify_time=item.stat().st_mtime,
+        ))
+
+    # 遍历所有文件，不含子目录
+    for item in SystemUtils.list_sub_files(path_obj,
+                                           settings.RMT_MEDIAEXT
+                                           + settings.RMT_SUBEXT
+                                           + IMAGE_TYPES
+                                           + [".nfo"]):
+        ret_items.append(schemas.FileItem(
+            type="file",
+            path=str(item).replace("\\", "/"),
+            name=item.name,
+            basename=item.stem,
+            extension=item.suffix[1:],
+            size=item.stat().st_size,
+            modify_time=item.stat().st_mtime,
+        ))
+    # 排序
+    if sort == 'time':
+        ret_items.sort(key=lambda x: x.modify_time, reverse=True)
+    else:
+        ret_items.sort(key=lambda x: x.name, reverse=False)
+    return ret_items
+
+
+@router.get("/listdir", summary="所有目录（本地，不含文件）", response_model=List[schemas.FileItem])
+def list_local_dir(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询当前目录下所有目录
+    """
+    # 返回结果
+    ret_items = []
+    if not path or path == "/":
+        if SystemUtils.is_windows():
+            partitions = SystemUtils.get_windows_drives() or ["C:/"]
+            for partition in partitions:
+                ret_items.append(schemas.FileItem(
+                    type="dir",
+                    path=partition + "/",
+                    name=partition,
+                    children=[]
+                ))
+            return ret_items
+        else:
+            path = "/"
+    else:
+        if not SystemUtils.is_windows() and not path.startswith("/"):
+            path = "/" + path
+
+    # 遍历目录
+    path_obj = Path(path)
+    if not path_obj.exists():
+        logger.warn(f"目录不存在：{path}")
+        return []
+
+    # 扁历所有目录
+    for item in SystemUtils.list_sub_directory(path_obj):
+        ret_items.append(schemas.FileItem(
+            type="dir",
+            path=str(item).replace("\\", "/") + "/",
+            name=item.name,
+            children=[]
+        ))
+    return ret_items
+
+
+@router.post("/mkdir", summary="创建目录（本地）", response_model=schemas.Response)
+def mkdir_local(fileitem: schemas.FileItem,
+                name: str,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    创建目录
+    """
+    if not fileitem.path:
+        return schemas.Response(success=False)
+    path_obj = Path(fileitem.path) / name
+    if path_obj.exists():
+        return schemas.Response(success=False)
+    path_obj.mkdir(parents=True, exist_ok=True)
+    return schemas.Response(success=True)
+
+
+@router.post("/delete", summary="删除文件或目录（本地）", response_model=schemas.Response)
+def delete_local(fileitem: schemas.FileItem, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    删除文件或目录
+    """
+    if not fileitem.path:
+        return schemas.Response(success=False)
+    path_obj = Path(fileitem.path)
+    if not path_obj.exists():
+        return schemas.Response(success=True)
+    if path_obj.is_file():
+        path_obj.unlink()
+    else:
+        shutil.rmtree(path_obj, ignore_errors=True)
+    return schemas.Response(success=True)
+
+
+@router.get("/download", summary="下载文件（本地）")
+def download_local(path: str, _: schemas.TokenPayload = Depends(verify_uri_token)) -> Any:
+    """
+    下载文件或目录
+    """
+    if not path:
+        return schemas.Response(success=False)
+    path_obj = Path(path)
+    if not path_obj.exists():
+        raise HTTPException(status_code=404, detail="文件不存在")
+    if path_obj.is_file():
+        # 做为文件流式下载
+        return FileResponse(path_obj)
+    else:
+        # 做为压缩包下载
+        shutil.make_archive(base_name=path_obj.stem, format="zip", root_dir=path_obj)
+        reponse = Response(content=path_obj.read_bytes(), media_type="application/zip")
+        # 删除压缩包
+        Path(f"{path_obj.stem}.zip").unlink()
+        return reponse
+
+
+@router.post("/rename", summary="重命名文件或目录（本地）", response_model=schemas.Response)
+def rename_local(fileitem: schemas.FileItem,
+                 new_name: str,
+                 recursive: bool = False,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    重命名文件或目录
+    """
+    if not fileitem.path or not new_name:
+        return schemas.Response(success=False)
+    path_obj = Path(fileitem.path)
+    if not path_obj.exists():
+        return schemas.Response(success=False)
+    path_obj.rename(path_obj.parent / new_name)
+    if recursive:
+        transferchain = TransferChain()
+        media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIO_TRACK_EXT
+        # 递归修改目录内文件（智能识别命名）
+        sub_files: List[schemas.FileItem] = list_local(fileitem=fileitem)
+        if sub_files:
+            # 开始进度
+            progress = ProgressHelper()
+            progress.start(ProgressKey.BatchRename)
+            total = len(sub_files)
+            handled = 0
+            for sub_file in sub_files:
+                handled += 1
+                progress.update(value=handled / total * 100,
+                                text=f"正在处理 {sub_file.name} ...",
+                                key=ProgressKey.BatchRename)
+                if sub_file.type == "dir":
+                    continue
+                if not sub_file.extension:
+                    continue
+                if f".{sub_file.extension.lower()}" not in media_exts:
+                    continue
+                sub_path = Path(sub_file.path)
+                meta = MetaInfoPath(sub_path)
+                mediainfo = transferchain.recognize_media(meta)
+                if not mediainfo:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
+                new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
+                if not new_path:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
+                ret: schemas.Response = rename_local(fileitem, new_name=Path(new_path).name, recursive=False)
+                if not ret.success:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
+            progress.end(ProgressKey.BatchRename)
+    return schemas.Response(success=True)
+
+
+@router.get("/image", summary="读取图片（本地）")
+def image_local(path: str, _: schemas.TokenPayload = Depends(verify_uri_token)) -> Any:
+    """
+    读取图片
+    """
+    if not path:
+        return None
+    path_obj = Path(path)
+    if not path_obj.exists():
+        return None
+    if not path_obj.is_file():
+        return None
+    # 判断是否图片文件
+    if path_obj.suffix.lower() not in IMAGE_TYPES:
+        raise HTTPException(status_code=500, detail="图片读取出错")
+    return Response(content=path_obj.read_bytes(), media_type="image/jpeg")
--- a/app/api/endpoints/login.py
+++ b/app/api/endpoints/login.py
@@ -1,56 +1,78 @@
 from datetime import timedelta
-from typing import Any, List, Annotated
+from typing import Any, List

-from fastapi import APIRouter, Depends, Form, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Form
 from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session

 from app import schemas
+from app.chain.tmdb import TmdbChain
 from app.chain.user import UserChain
 from app.core import security
 from app.core.config import settings
-from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.sites import SitesHelper  # noqa
-from app.helper.image import WallpaperHelper
-from app.schemas.types import SystemConfigKey
+from app.core.security import get_password_hash
+from app.db import get_db
+from app.db.models.user import User
+from app.helper.sites import SitesHelper
+from app.log import logger
+from app.utils.web import WebUtils

 router = APIRouter()


@router.post("/access-token", summary="获取token", response_model=schemas.Token)
-def login_access_token(
-        form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
-        otp_password: Annotated[str | None, Form()] = None
+async def login_access_token(
+        db: Session = Depends(get_db),
+        form_data: OAuth2PasswordRequestForm = Depends(),
+        otp_password: str = Form(None)
 ) -> Any:
    """
    获取认证Token
    """
-    success, user_or_message = UserChain().user_authenticate(username=form_data.username,
-                                                             password=form_data.password,
-                                                             mfa_code=otp_password)
-
+    # 检查数据库
+    success, user = User.authenticate(
+        db=db,
+        name=form_data.username,
+        password=form_data.password,
+        otp_password=otp_password
+    )
    if not success:
-        raise HTTPException(status_code=401, detail=user_or_message)
-
-    # 用户等级
+        # 认证不成功
+        if not user:
+            # 未找到用户，请求协助认证
+            logger.warn(f"登录用户 {form_data.username} 本地不存在，尝试辅助认证 ...")
+            token = UserChain().user_authenticate(form_data.username, form_data.password)
+            if not token:
+                logger.warn(f"用户 {form_data.username} 登录失败！")
+                raise HTTPException(status_code=401, detail="用户名、密码、二次校验码不正确")
+            else:
+                logger.info(f"用户 {form_data.username} 辅助认证成功，用户信息: {token}，以普通用户登录...")
+                # 加入用户信息表
+                logger.info(f"创建用户: {form_data.username}")
+                user = User(name=form_data.username, is_active=True,
+                            is_superuser=False, hashed_password=get_password_hash(token))
+                user.create(db)
+        else:
+            # 用户存在，但认证失败
+            logger.warn(f"用户 {user.name} 登录失败！")
+            raise HTTPException(status_code=401, detail="用户名、密码或二次校验码不正确")
+    elif user and not user.is_active:
+        raise HTTPException(status_code=403, detail="用户未启用")
+    logger.info(f"用户 {user.name} 登录成功！")
    level = SitesHelper().auth_level
-    # 是否显示配置向导
-    show_wizard = not SystemConfigOper().get(SystemConfigKey.SetupWizardState) and not settings.ADVANCED_MODE
    return schemas.Token(
        access_token=security.create_access_token(
-            userid=user_or_message.id,
-            username=user_or_message.name,
-            super_user=user_or_message.is_superuser,
+            userid=user.id,
+            username=user.name,
+            super_user=user.is_superuser,
            expires_delta=timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES),
            level=level
        ),
        token_type="bearer",
-        super_user=user_or_message.is_superuser,
-        user_id=user_or_message.id,
-        user_name=user_or_message.name,
-        avatar=user_or_message.avatar,
-        level=level,
-        permissions=user_or_message.permissions or {},
-        widzard=show_wizard
+        super_user=user.is_superuser,
+        user_name=user.name,
+        avatar=user.avatar,
+        level=level
    )


@@ -59,7 +81,10 @@ def wallpaper() -> Any:
    """
    获取登录页面电影海报
    """
-    url = WallpaperHelper().get_wallpaper()
+    if settings.WALLPAPER == "tmdb":
+        url = TmdbChain().get_random_wallpager()
+    else:
+        url = WebUtils.get_bing_wallpaper()
    if url:
        return schemas.Response(
            success=True,
@@ -73,4 +98,7 @@ def wallpapers() -> Any:
    """
    获取登录页面电影海报
    """
-    return WallpaperHelper().get_wallpapers()
+    if settings.WALLPAPER == "tmdb":
+        return TmdbChain().get_trending_wallpapers()
+    else:
+        return WebUtils.get_bing_wallpapers()
--- a/app/api/endpoints/mcp.py
+++ b/app/api/endpoints/mcp.py
@@ -1,161 +0,0 @@
-"""工具API端点
-通过HTTP API暴露MoviePilot的智能体工具功能
-"""
-
-from typing import List, Any, Dict, Annotated
-
-from fastapi import APIRouter, Depends, HTTPException
-
-from app import schemas
-from app.agent.tools.manager import MoviePilotToolsManager
-from app.core.security import verify_apikey
-from app.log import logger
-
-router = APIRouter()
-
-# 全局工具管理器实例（单例模式，按用户ID缓存）
-_tools_managers: Dict[str, MoviePilotToolsManager] = {}
-
-
-def get_tools_manager(user_id: str = "mcp_user", session_id: str = "mcp_session") -> MoviePilotToolsManager:
-    """
-    获取工具管理器实例（按用户ID缓存）
-    
-    Args:
-        user_id: 用户ID
-        session_id: 会话ID
-        
-    Returns:
-        MoviePilotToolsManager实例
-    """
-    global _tools_managers
-    # 使用用户ID作为缓存键
-    cache_key = f"{user_id}_{session_id}"
-    if cache_key not in _tools_managers:
-        _tools_managers[cache_key] = MoviePilotToolsManager(
-            user_id=user_id,
-            session_id=session_id
-        )
-    return _tools_managers[cache_key]
-
-
-@router.get("/tools", summary="列出所有可用工具", response_model=List[Dict[str, Any]])
-async def list_tools(
-        _: Annotated[str, Depends(verify_apikey)]
-) -> Any:
-    """
-    获取所有可用的工具列表
-    
-    返回每个工具的名称、描述和参数定义
-    """
-    try:
-        manager = get_tools_manager()
-        # 获取所有工具定义
-        tools = manager.list_tools()
-
-        # 转换为字典格式
-        tools_list = []
-        for tool in tools:
-            tool_dict = {
-                "name": tool.name,
-                "description": tool.description,
-                "inputSchema": tool.input_schema
-            }
-            tools_list.append(tool_dict)
-
-        return tools_list
-    except Exception as e:
-        logger.error(f"获取工具列表失败: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"获取工具列表失败: {str(e)}")
-
-
-@router.post("/tools/call", summary="调用工具", response_model=schemas.ToolCallResponse)
-async def call_tool(
-        request: schemas.ToolCallRequest,
-
-) -> Any:
-    """
-    调用指定的工具
-        
-    Returns:
-        工具执行结果
-    """
-    try:
-        # 使用当前用户ID创建管理器实例
-        manager = get_tools_manager()
-
-        # 调用工具
-        result_text = await manager.call_tool(request.tool_name, request.arguments)
-
-        return schemas.ToolCallResponse(
-            success=True,
-            result=result_text
-        )
-    except Exception as e:
-        logger.error(f"调用工具 {request.tool_name} 失败: {e}", exc_info=True)
-        return schemas.ToolCallResponse(
-            success=False,
-            error=f"调用工具失败: {str(e)}"
-        )
-
-
-@router.get("/tools/{tool_name}", summary="获取工具详情", response_model=Dict[str, Any])
-async def get_tool_info(
-        tool_name: str,
-        _: Annotated[str, Depends(verify_apikey)]
-) -> Any:
-    """
-    获取指定工具的详细信息
-        
-    Returns:
-        工具的详细信息，包括名称、描述和参数定义
-    """
-    try:
-        manager = get_tools_manager()
-        # 获取所有工具
-        tools = manager.list_tools()
-
-        # 查找指定工具
-        for tool in tools:
-            if tool.name == tool_name:
-                return {
-                    "name": tool.name,
-                    "description": tool.description,
-                    "inputSchema": tool.input_schema
-                }
-
-        raise HTTPException(status_code=404, detail=f"工具 '{tool_name}' 未找到")
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"获取工具信息失败: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"获取工具信息失败: {str(e)}")
-
-
-@router.get("/tools/{tool_name}/schema", summary="获取工具参数Schema", response_model=Dict[str, Any])
-async def get_tool_schema(
-        tool_name: str,
-        _: Annotated[str, Depends(verify_apikey)]
-) -> Any:
-    """
-    获取指定工具的参数Schema（JSON Schema格式）
-        
-    Returns:
-        工具的JSON Schema定义
-    """
-    try:
-        manager = get_tools_manager()
-        # 获取所有工具
-        tools = manager.list_tools()
-
-        # 查找指定工具
-        for tool in tools:
-            if tool.name == tool_name:
-                return tool.input_schema
-
-        raise HTTPException(status_code=404, detail=f"工具 '{tool_name}' 未找到")
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"获取工具Schema失败: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail=f"获取工具Schema失败: {str(e)}")
--- a/app/api/endpoints/media.py
+++ b/app/api/endpoints/media.py
@@ -1,83 +1,78 @@
 from pathlib import Path
-from typing import List, Any, Union, Annotated, Optional
+from typing import List, Any, Union

 from fastapi import APIRouter, Depends

 from app import schemas
 from app.chain.media import MediaChain
-from app.chain.tmdb import TmdbChain
 from app.core.config import settings
 from app.core.context import Context
-from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo, MetaInfoPath
 from app.core.security import verify_token, verify_apitoken
-from app.schemas import MediaType, MediaRecognizeConvertEventData
-from app.schemas.types import ChainEventType
+from app.schemas import MediaType

 router = APIRouter()


@router.get("/recognize", summary="识别媒体信息（种子）", response_model=schemas.Context)
-async def recognize(title: str,
-                    subtitle: Optional[str] = None,
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def recognize(title: str,
+              subtitle: str = None,
+              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据标题、副标题识别媒体信息
    """
    # 识别媒体信息
    metainfo = MetaInfo(title, subtitle)
-    mediainfo = await MediaChain().async_recognize_by_meta(metainfo)
+    mediainfo = MediaChain().recognize_by_meta(metainfo)
    if mediainfo:
        return Context(meta_info=metainfo, media_info=mediainfo).to_dict()
    return schemas.Context()


@router.get("/recognize2", summary="识别种子媒体信息（API_TOKEN）", response_model=schemas.Context)
-async def recognize2(_: Annotated[str, Depends(verify_apitoken)],
-                     title: str,
-                     subtitle: Optional[str] = None
-                     ) -> Any:
+def recognize2(title: str,
+               subtitle: str = None,
+               _: str = Depends(verify_apitoken)) -> Any:
    """
    根据标题、副标题识别媒体信息 API_TOKEN认证（?token=xxx）
    """
    # 识别媒体信息
-    return await recognize(title, subtitle)
+    return recognize(title, subtitle)


@router.get("/recognize_file", summary="识别媒体信息（文件）", response_model=schemas.Context)
-async def recognize_file(path: str,
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def recognize_file(path: str,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据文件路径识别媒体信息
    """
    # 识别媒体信息
-    context = await MediaChain().async_recognize_by_path(path)
+    context = MediaChain().recognize_by_path(path)
    if context:
        return context.to_dict()
    return schemas.Context()


@router.get("/recognize_file2", summary="识别文件媒体信息（API_TOKEN）", response_model=schemas.Context)
-async def recognize_file2(path: str,
-                          _: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def recognize_file2(path: str,
+                    _: str = Depends(verify_apitoken)) -> Any:
    """
    根据文件路径识别媒体信息 API_TOKEN认证（?token=xxx）
    """
    # 识别媒体信息
-    return await recognize_file(path)
+    return recognize_file(path)


@router.get("/search", summary="搜索媒体/人物信息", response_model=List[dict])
-async def search(title: str,
-                 type: Optional[str] = "media",
-                 page: int = 1,
-                 count: int = 8,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def search(title: str,
+           type: str = "media",
+           page: int = 1,
+           count: int = 8,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    模糊搜索媒体/人物信息列表 media：媒体信息，person：人物信息
    """
-
-    def __get_source(obj: Union[schemas.MediaInfo, schemas.MediaPerson, dict]):
+    def __get_source(obj: Union[dict, schemas.MediaPerson]):
        """
        获取对象属性
        """
@@ -85,31 +80,26 @@ async def search(title: str,
            return obj.get("source")
        return obj.source

-    media_chain = MediaChain()
+    result = []
    if type == "media":
-        _, medias = await media_chain.async_search(title=title)
-        result = [media.to_dict() for media in medias] if medias else []
-    elif type == "collection":
-        collections = await media_chain.async_search_collections(name=title)
-        result = [collection.to_dict() for collection in collections] if collections else []
-    else:  # person
-        persons = await media_chain.async_search_persons(name=title)
-        result = [person.model_dump() for person in persons] if persons else []
-
-    if not result:
-        return []
-
-    # 排序和分页
-    setting_order = settings.SEARCH_SOURCE.split(',') if settings.SEARCH_SOURCE else []
-    sort_order = {source: index for index, source in enumerate(setting_order)}
-
-    sorted_result = sorted(result, key=lambda x: sort_order.get(__get_source(x), 4))
-    return sorted_result[(page - 1) * count:page * count]
+        _, medias = MediaChain().search(title=title)
+        if medias:
+            result = [media.to_dict() for media in medias]
+    else:
+        result = MediaChain().search_persons(name=title)
+    if result:
+        # 按设置的顺序对结果进行排序
+        setting_order = settings.SEARCH_SOURCE.split(',') or []
+        sort_order = {}
+        for index, source in enumerate(setting_order):
+            sort_order[source] = index
+        result = sorted(result, key=lambda x: sort_order.get(__get_source(x), 4))
+    return result[(page - 1) * count:page * count]


@router.post("/scrape/{storage}", summary="刮削媒体信息", response_model=schemas.Response)
 def scrape(fileitem: schemas.FileItem,
-           storage: Optional[str] = "local",
+           storage: str = "local",
           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    刮削媒体信息
@@ -121,127 +111,46 @@ def scrape(fileitem: schemas.FileItem,
    scrape_path = Path(fileitem.path)
    meta = MetaInfoPath(scrape_path)
    mediainfo = chain.recognize_by_meta(meta)
-    if not mediainfo:
+    if not media_info:
        return schemas.Response(success=False, message="刮削失败，无法识别媒体信息")
    if storage == "local":
        if not scrape_path.exists():
            return schemas.Response(success=False, message="刮削路径不存在")
-    # 手动刮削 (暂时使用同步版本，可以后续优化为异步)
-    chain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo, overwrite=True)
+    else:
+        if not fileitem.fileid:
+            return schemas.Response(success=False, message="刮削文件ID无效")
+    # 手动刮削
+    chain.manual_scrape(storage=storage, fileitem=fileitem, meta=meta, mediainfo=mediainfo)
    return schemas.Response(success=True, message=f"{fileitem.path} 刮削完成")


@router.get("/category", summary="查询自动分类配置", response_model=dict)
-async def category(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def category(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询自动分类配置
    """
    return MediaChain().media_category() or {}


-@router.get("/group/seasons/{episode_group}", summary="查询剧集组季信息", response_model=List[schemas.MediaSeason])
-async def group_seasons(episode_group: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询剧集组季信息（themoviedb）
-    """
-    return await TmdbChain().async_tmdb_group_seasons(group_id=episode_group)
-
-
-@router.get("/groups/{tmdbid}", summary="查询媒体剧集组", response_model=List[dict])
-async def groups(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询媒体剧集组列表（themoviedb）
-    """
-    mediainfo = await MediaChain().async_recognize_media(tmdbid=tmdbid, mtype=MediaType.TV)
-    if not mediainfo:
-        return []
-    return mediainfo.episode_groups
-
-
-@router.get("/seasons", summary="查询媒体季信息", response_model=List[schemas.MediaSeason])
-async def seasons(mediaid: Optional[str] = None,
-                  title: Optional[str] = None,
-                  year: str = None,
-                  season: int = None,
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询媒体季信息
-    """
-    if mediaid:
-        if mediaid.startswith("tmdb:"):
-            tmdbid = int(mediaid[5:])
-            seasons_info = await TmdbChain().async_tmdb_seasons(tmdbid=tmdbid)
-            if seasons_info:
-                if season:
-                    return [sea for sea in seasons_info if sea.season_number == season]
-                return seasons_info
-    if title:
-        meta = MetaInfo(title)
-        if year:
-            meta.year = year
-        mediainfo = await MediaChain().async_recognize_media(meta, mtype=MediaType.TV)
-        if mediainfo:
-            if settings.RECOGNIZE_SOURCE == "themoviedb":
-                seasons_info = await TmdbChain().async_tmdb_seasons(tmdbid=mediainfo.tmdb_id)
-                if seasons_info:
-                    if season:
-                        return [sea for sea in seasons_info if sea.season_number == season]
-                    return seasons_info
-            else:
-                sea = season or 1
-                return [schemas.MediaSeason(
-                    season_number=sea,
-                    poster_path=mediainfo.poster_path,
-                    name=f"第 {sea} 季",
-                    air_date=mediainfo.release_date,
-                    overview=mediainfo.overview,
-                    vote_average=mediainfo.vote_average,
-                    episode_count=mediainfo.number_of_episodes
-                )]
-    return []
-
-
@router.get("/{mediaid}", summary="查询媒体详情", response_model=schemas.MediaInfo)
-async def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: str = None,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def media_info(mediaid: str, type_name: str,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据媒体ID查询themoviedb或豆瓣媒体信息，type_name: 电影/电视剧
    """
    mtype = MediaType(type_name)
-    mediainfo = None
-    mediachain = MediaChain()
+    tmdbid, doubanid, bangumiid = None, None, None
    if mediaid.startswith("tmdb:"):
-        mediainfo = await mediachain.async_recognize_media(tmdbid=int(mediaid[5:]), mtype=mtype)
+        tmdbid = int(mediaid[5:])
    elif mediaid.startswith("douban:"):
-        mediainfo = await mediachain.async_recognize_media(doubanid=mediaid[7:], mtype=mtype)
+        doubanid = mediaid[7:]
    elif mediaid.startswith("bangumi:"):
-        mediainfo = await mediachain.async_recognize_media(bangumiid=int(mediaid[8:]), mtype=mtype)
-    else:
-        # 广播事件解析媒体信息
-        event_data = MediaRecognizeConvertEventData(
-            mediaid=mediaid,
-            convert_type=settings.RECOGNIZE_SOURCE
-        )
-        event = await eventmanager.async_send_event(ChainEventType.MediaRecognizeConvert, event_data)
-        # 使用事件返回的上下文数据
-        if event and event.event_data and event.event_data.media_dict:
-            event_data: MediaRecognizeConvertEventData = event.event_data
-            new_id = event_data.media_dict.get("id")
-            if event_data.convert_type == "themoviedb":
-                mediainfo = await mediachain.async_recognize_media(tmdbid=new_id, mtype=mtype)
-            elif event_data.convert_type == "douban":
-                mediainfo = await mediachain.async_recognize_media(doubanid=new_id, mtype=mtype)
-        elif title:
-            # 使用名称识别兜底
-            meta = MetaInfo(title)
-            if year:
-                meta.year = year
-            if mtype:
-                meta.type = mtype
-            mediainfo = await mediachain.async_recognize_media(meta=meta)
+        bangumiid = int(mediaid[8:])
+    if not tmdbid and not doubanid and not bangumiid:
+        return schemas.MediaInfo()
    # 识别
+    mediainfo = MediaChain().recognize_media(tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid, mtype=mtype)
    if mediainfo:
-        await mediachain.async_obtain_images(mediainfo)
+        MediaChain().obtain_images(mediainfo)
        return mediainfo.to_dict()
-
    return schemas.MediaInfo()
--- a/app/api/endpoints/mediaserver.py
+++ b/app/api/endpoints/mediaserver.py
@@ -1,55 +1,53 @@
-from typing import Any, List, Dict, Optional
+from typing import Any, List, Dict

 from fastapi import APIRouter, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session

 from app import schemas
 from app.chain.download import DownloadChain
 from app.chain.mediaserver import MediaServerChain
+from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
-from app.db import get_async_db
+from app.db import get_db
 from app.db.mediaserver_oper import MediaServerOper
 from app.db.models import MediaServerItem
-from app.db.systemconfig_oper import SystemConfigOper
-from app.helper.mediaserver import MediaServerHelper
 from app.schemas import MediaType, NotExistMediaInfo
-from app.schemas.types import SystemConfigKey

 router = APIRouter()


-@router.get("/play/{itemid:path}", summary="在线播放")
-def play_item(itemid: str, _: schemas.TokenPayload = Depends(verify_token)) -> schemas.Response:
+@router.get("/play/{itemid}", summary="在线播放")
+def play_item(itemid: str) -> schemas.Response:
    """
    获取媒体服务器播放页面地址
    """
    if not itemid:
-        return schemas.Response(success=False, message="参数错误")
-    configs = MediaServerHelper().get_configs()
-    if not configs:
-        return schemas.Response(success=False, message="未配置媒体服务器")
-    media_chain = MediaServerChain()
-    for name in configs.keys():
-        item = media_chain.iteminfo(server=name, item_id=itemid)
-        if item:
-            play_url = media_chain.get_play_url(server=name, item_id=itemid)
-            if play_url:
-                return schemas.Response(success=True, data={
-                    "url": play_url
-                })
-    return schemas.Response(success=False, message="未找到播放地址")
+        return schemas.Response(success=False, msg="参数错误")
+    if not settings.MEDIASERVER:
+        return schemas.Response(success=False, msg="未配置媒体服务器")
+    # 查找一个不为空的值
+    mediaserver = next((server for server in settings.MEDIASERVER.split(",") if server), None)
+    if not mediaserver:
+        return schemas.Response(success=False, msg="未配置媒体服务器")
+    play_url = MediaServerChain().get_play_url(server=mediaserver, item_id=itemid)
+    # 重定向到play_url
+    if not play_url:
+        return schemas.Response(success=False, msg="未找到播放地址")
+    return schemas.Response(success=True, data={
+        "url": play_url
+    })


@router.get("/exists", summary="查询本地是否存在（数据库）", response_model=schemas.Response)
-async def exists_local(title: Optional[str] = None,
-                       year: Optional[str] = None,
-                       mtype: Optional[str] = None,
-                       tmdbid: Optional[int] = None,
-                       season: Optional[int] = None,
-                       db: AsyncSession = Depends(get_async_db),
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def exists_local(title: str = None,
+                 year: int = None,
+                 mtype: str = None,
+                 tmdbid: int = None,
+                 season: int = None,
+                 db: Session = Depends(get_db),
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    判断本地是否存在
    """
@@ -59,7 +57,7 @@ async def exists_local(title: Optional[str] = None,
    # 返回对象
    ret_info = {}
    # 本地数据库是否存在
-    exist: MediaServerItem = await MediaServerOper(db).async_exists(
+    exist: MediaServerItem = MediaServerOper(db).exists(
        title=meta.name, year=year, mtype=mtype, tmdbid=tmdbid, season=season
    )
    if exist:
@@ -79,7 +77,7 @@ def exists(media_in: schemas.MediaInfo,
    """
    # 转化为媒体信息对象
    mediainfo = MediaInfo()
-    mediainfo.from_dict(media_in.model_dump())
+    mediainfo.from_dict(media_in.dict())
    existsinfo: schemas.ExistMediaInfo = MediaServerChain().media_exists(mediainfo=mediainfo)
    if not existsinfo:
        return []
@@ -108,7 +106,7 @@ def not_exists(media_in: schemas.MediaInfo,
        meta.year = media_in.year
    # 转化为媒体信息对象
    mediainfo = MediaInfo()
-    mediainfo.from_dict(media_in.model_dump())
+    mediainfo.from_dict(media_in.dict())
    exist_flag, no_exists = DownloadChain().get_no_exists_info(meta=meta, mediainfo=mediainfo)
    mediakey = mediainfo.tmdb_id or mediainfo.douban_id
    if mediainfo.type == MediaType.MOVIE:
@@ -121,38 +119,26 @@ def not_exists(media_in: schemas.MediaInfo,


@router.get("/latest", summary="最新入库条目", response_model=List[schemas.MediaServerPlayItem])
-def latest(server: str, count: Optional[int] = 20,
+def latest(count: int = 18,
           userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    获取媒体服务器最新入库条目
    """
-    return MediaServerChain().latest(server=server, count=count, username=userinfo.username) or []
+    return MediaServerChain().latest(count=count, username=userinfo.username) or []


@router.get("/playing", summary="正在播放条目", response_model=List[schemas.MediaServerPlayItem])
-def playing(server: str, count: Optional[int] = 12,
+def playing(count: int = 12,
            userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    获取媒体服务器正在播放条目
    """
-    return MediaServerChain().playing(server=server, count=count, username=userinfo.username) or []
+    return MediaServerChain().playing(count=count, username=userinfo.username) or []


@router.get("/library", summary="媒体库列表", response_model=List[schemas.MediaServerLibrary])
-def library(server: str, hidden: Optional[bool] = False,
-            userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def library(userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    获取媒体服务器媒体库列表
    """
-    return MediaServerChain().librarys(server=server, username=userinfo.username, hidden=hidden) or []
-
-
-@router.get("/clients", summary="查询可用媒体服务器", response_model=List[dict])
-async def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询可用媒体服务器
-    """
-    mediaservers: List[dict] = SystemConfigOper().get(SystemConfigKey.MediaServers)
-    if mediaservers:
-        return [{"name": d.get("name"), "type": d.get("type")} for d in mediaservers if d.get("enabled")]
-    return []
+    return MediaServerChain().librarys(username=userinfo.username) or []
--- a/app/api/endpoints/message.py
+++ b/app/api/endpoints/message.py
@@ -1,23 +1,25 @@
 import json
-from typing import Union, Any, List, Optional
+from typing import Union, Any, List

-from fastapi import APIRouter, BackgroundTasks, Depends, Request
+from fastapi import APIRouter, BackgroundTasks, Depends
+from fastapi import Request
 from pywebpush import WebPushException, webpush
-from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
 from starlette.responses import PlainTextResponse

 from app import schemas
 from app.chain.message import MessageChain
 from app.core.config import settings, global_vars
-from app.core.security import verify_token, verify_apitoken
-from app.db import get_async_db
+from app.core.security import verify_token
+from app.db import get_db
 from app.db.models import User
 from app.db.models.message import Message
-from app.db.user_oper import get_current_active_superuser
-from app.helper.service import ServiceConfigHelper
+from app.db.systemconfig_oper import SystemConfigOper
+from app.db.userauth import get_current_active_superuser
 from app.log import logger
 from app.modules.wechat.WXBizMsgCrypt3 import WXBizMsgCrypt
-from app.schemas.types import MessageChannel
+from app.schemas import NotificationSwitch
+from app.schemas.types import SystemConfigKey, NotificationType, MessageChannel

 router = APIRouter()

@@ -30,10 +32,9 @@ def start_message_chain(body: Any, form: Any, args: Any):


@router.post("/", summary="接收用户消息", response_model=schemas.Response)
-async def user_message(background_tasks: BackgroundTasks, request: Request,
-                       _: schemas.TokenPayload = Depends(verify_apitoken)):
+async def user_message(background_tasks: BackgroundTasks, request: Request):
    """
-    用户消息响应，配置请求中需要添加参数：token=API_TOKEN&source=消息配置名
+    用户消息响应
    """
    body = await request.body()
    form = await request.form()
@@ -49,7 +50,6 @@ def web_message(text: str, current_user: User = Depends(get_current_active_super
    """
    MessageChain().handle_message(
        channel=MessageChannel.Web,
-        source=current_user.name,
        userid=current_user.name,
        username=current_user.name,
        text=text
@@ -58,15 +58,15 @@ def web_message(text: str, current_user: User = Depends(get_current_active_super


@router.get("/web", summary="获取WEB消息", response_model=List[dict])
-async def get_web_message(_: schemas.TokenPayload = Depends(verify_token),
-                          db: AsyncSession = Depends(get_async_db),
-                          page: Optional[int] = 1,
-                          count: Optional[int] = 20):
+def get_web_message(_: schemas.TokenPayload = Depends(verify_token),
+                    db: Session = Depends(get_db),
+                    page: int = 1,
+                    count: int = 20):
    """
    获取WEB消息列表
    """
    ret_messages = []
-    messages = await Message.async_list_by_page(db, page=page, count=count)
+    messages = Message.list_by_page(db, page=page, count=count)
    for message in messages:
        try:
            ret_messages.append(message.to_dict())
@@ -76,63 +76,95 @@ async def get_web_message(_: schemas.TokenPayload = Depends(verify_token),
    return ret_messages


-def wechat_verify(echostr: str, msg_signature: str, timestamp: Union[str, int], nonce: str,
-                  source: Optional[str] = None) -> Any:
+def wechat_verify(echostr: str, msg_signature: str,
+                  timestamp: Union[str, int], nonce: str) -> Any:
    """
    微信验证响应
    """
-    # 获取服务配置
-    client_configs = ServiceConfigHelper.get_notification_configs()
-    if not client_configs:
-        return "未找到对应的消息配置"
-    client_config = next((config for config in client_configs if
-                          config.type == "wechat" and config.enabled and (not source or config.name == source)), None)
-    if not client_config:
-        return "未找到对应的消息配置"
    try:
-        wxcpt = WXBizMsgCrypt(sToken=client_config.config.get('WECHAT_TOKEN'),
-                              sEncodingAESKey=client_config.config.get('WECHAT_ENCODING_AESKEY'),
-                              sReceiveId=client_config.config.get('WECHAT_CORPID'))
-        ret, sEchoStr = wxcpt.VerifyURL(sMsgSignature=msg_signature,
-                                        sTimeStamp=timestamp,
-                                        sNonce=nonce,
-                                        sEchoStr=echostr)
-        if ret == 0:
-            # 验证URL成功，将sEchoStr返回给企业号
-            return PlainTextResponse(sEchoStr)
-        return "微信验证失败"
+        wxcpt = WXBizMsgCrypt(sToken=settings.WECHAT_TOKEN,
+                              sEncodingAESKey=settings.WECHAT_ENCODING_AESKEY,
+                              sReceiveId=settings.WECHAT_CORPID)
    except Exception as err:
        logger.error(f"微信请求验证失败: {str(err)}")
        return str(err)
+    ret, sEchoStr = wxcpt.VerifyURL(sMsgSignature=msg_signature,
+                                    sTimeStamp=timestamp,
+                                    sNonce=nonce,
+                                    sEchoStr=echostr)
+    if ret != 0:
+        logger.error("微信请求验证失败 VerifyURL ret: %s" % str(ret))
+    # 验证URL成功，将sEchoStr返回给企业号
+    return PlainTextResponse(sEchoStr)


-def vocechat_verify() -> Any:
+def vocechat_verify(token: str) -> Any:
    """
    VoceChat验证响应
    """
-    return {"status": "OK"}
+    if token == settings.API_TOKEN:
+        return {"status": "OK"}
+    return {"status": "ERROR"}


@router.get("/", summary="回调请求验证")
-def incoming_verify(token: Optional[str] = None, echostr: Optional[str] = None, msg_signature: Optional[str] = None,
-                    timestamp: Union[str, int] = None, nonce: Optional[str] = None, source: Optional[str] = None,
-                    _: schemas.TokenPayload = Depends(verify_apitoken)) -> Any:
+def incoming_verify(token: str = None, echostr: str = None, msg_signature: str = None,
+                    timestamp: Union[str, int] = None, nonce: str = None) -> Any:
    """
    微信/VoceChat等验证响应
    """
    logger.info(f"收到验证请求: token={token}, echostr={echostr}, "
                f"msg_signature={msg_signature}, timestamp={timestamp}, nonce={nonce}")
    if echostr and msg_signature and timestamp and nonce:
-        return wechat_verify(echostr, msg_signature, timestamp, nonce, source)
-    return vocechat_verify()
+        return wechat_verify(echostr, msg_signature, timestamp, nonce)
+    return vocechat_verify(token)
+
+
+@router.get("/switchs", summary="查询通知消息渠道开关", response_model=List[NotificationSwitch])
+def read_switchs(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询通知消息渠道开关
+    """
+    return_list = []
+    # 读取数据库
+    switchs = SystemConfigOper().get(SystemConfigKey.NotificationChannels)
+    if not switchs:
+        for noti in NotificationType:
+            return_list.append(NotificationSwitch(mtype=noti.value, wechat=True,
+                                                  telegram=True, slack=True,
+                                                  synologychat=True, vocechat=True))
+    else:
+        for switch in switchs:
+            return_list.append(NotificationSwitch(**switch))
+        for noti in NotificationType:
+            if not any([x.mtype == noti.value for x in return_list]):
+                return_list.append(NotificationSwitch(mtype=noti.value, wechat=True,
+                                                      telegram=True, slack=True,
+                                                      synologychat=True, vocechat=True))
+    return return_list
+
+
+@router.post("/switchs", summary="设置通知消息渠道开关", response_model=schemas.Response)
+def set_switchs(switchs: List[NotificationSwitch],
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    设置通知消息渠道开关
+    """
+    switch_list = []
+    for switch in switchs:
+        switch_list.append(switch.dict())
+    # 存入数据库
+    SystemConfigOper().set(SystemConfigKey.NotificationChannels, switch_list)
+
+    return schemas.Response(success=True)


@router.post("/webpush/subscribe", summary="客户端webpush通知订阅", response_model=schemas.Response)
-async def subscribe(subscription: schemas.Subscription, _: schemas.TokenPayload = Depends(verify_token)):
+def subscribe(subscription: schemas.Subscription, _: schemas.TokenPayload = Depends(verify_token)):
    """
    客户端webpush通知订阅
    """
-    subinfo = subscription.model_dump()
+    subinfo = subscription.dict()
    if subinfo not in global_vars.get_subscriptions():
        global_vars.push_subscription(subinfo)
    logger.debug(f"通知订阅成功: {subinfo}")
@@ -148,7 +180,7 @@ def send_notification(payload: schemas.SubscriptionMessage, _: schemas.TokenPayl
        try:
            webpush(
                subscription_info=sub,
-                data=json.dumps(payload.model_dump()),
+                data=json.dumps(payload.dict()),
                vapid_private_key=settings.VAPID.get("privateKey"),
                vapid_claims={
                    "sub": settings.VAPID.get("subject")
--- a/app/api/endpoints/plugin.py
+++ b/app/api/endpoints/plugin.py
@@ -1,162 +1,57 @@
-import mimetypes
-import shutil
-from typing import Annotated, Any, List, Optional
+from typing import Any, List, Annotated

-import aiofiles
-from anyio import Path as AsyncPath
-from fastapi import APIRouter, Depends, Header, HTTPException
-from fastapi.concurrency import run_in_threadpool
-from starlette import status
-from starlette.responses import StreamingResponse
+from fastapi import APIRouter, Depends, Header

 from app import schemas
-from app.command import Command
-from app.core.config import settings
 from app.core.plugin import PluginManager
-from app.core.security import verify_apikey, verify_token
-from app.db.models import User
+from app.core.security import verify_token
 from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async
-from app.factory import app
 from app.helper.plugin import PluginHelper
-from app.log import logger
 from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey

-PROTECTED_ROUTES = {"/api/v1/openapi.json", "/docs", "/docs/oauth2-redirect", "/redoc"}
-PLUGIN_PREFIX = f"{settings.API_V1_STR}/plugin"
-
 router = APIRouter()


-def register_plugin_api(plugin_id: Optional[str] = None):
+def register_plugin_api(plugin_id: str = None):
    """
-    动态注册插件 API
-    :param plugin_id: 插件 ID，如果为 None，则注册所有插件
+    注册插件API（先删除后新增）
    """
-    _update_plugin_api_routes(plugin_id, action="add")
+    for api in PluginManager().get_plugin_apis(plugin_id):
+        for r in router.routes:
+            if r.path == api.get("path"):
+                router.routes.remove(r)
+                break
+        router.add_api_route(**api)


 def remove_plugin_api(plugin_id: str):
    """
-    动态移除单个插件的 API
-    :param plugin_id: 插件 ID
+    移除插件API
    """
-    _update_plugin_api_routes(plugin_id, action="remove")
-
-
-def _update_plugin_api_routes(plugin_id: Optional[str], action: str):
-    """
-    插件 API 路由注册和移除
-    :param plugin_id: 插件 ID，如果 action 为 "add" 且 plugin_id 为 None，则处理所有插件
-                      如果 action 为 "remove"，plugin_id 必须是有效的插件 ID
-    :param action: "add" 或 "remove"，决定是添加还是移除路由
-    """
-    if action not in {"add", "remove"}:
-        raise ValueError("Action must be 'add' or 'remove'")
-
-    is_modified = False
-    existing_paths = {route.path: route for route in app.routes}
-
-    plugin_ids = [plugin_id] if plugin_id else PluginManager().get_running_plugin_ids()
-    for plugin_id in plugin_ids:
-        routes_removed = _remove_routes(plugin_id)
-        if routes_removed:
-            is_modified = True
-
-        if action != "add":
-            continue
-        # 获取插件的 API 路由信息
-        plugin_apis = PluginManager().get_plugin_apis(plugin_id)
-        for api in plugin_apis:
-            api_path = f"{PLUGIN_PREFIX}{api.get('path', '')}"
-            try:
-                api["path"] = api_path
-                allow_anonymous = api.pop("allow_anonymous", False)
-                auth_mode = api.pop("auth", "apikey")
-                dependencies = api.setdefault("dependencies", [])
-                if not allow_anonymous:
-                    if auth_mode == "bear" and Depends(verify_token) not in dependencies:
-                        dependencies.append(Depends(verify_token))
-                    elif Depends(verify_apikey) not in dependencies:
-                        dependencies.append(Depends(verify_apikey))
-                app.add_api_route(**api, tags=["plugin"])
-                is_modified = True
-                logger.debug(f"Added plugin route: {api_path}")
-            except Exception as e:
-                logger.error(f"Error adding plugin route {api_path}: {str(e)}")
-
-    if is_modified:
-        _clean_protected_routes(existing_paths)
-        app.openapi_schema = None
-        app.setup()
-
-
-def _remove_routes(plugin_id: str) -> bool:
-    """
-    移除与单个插件相关的路由
-    :param plugin_id: 插件 ID
-    :return: 是否有路由被移除
-    """
-    if not plugin_id:
-        return False
-    prefix = f"{PLUGIN_PREFIX}/{plugin_id}/"
-    routes_to_remove = [route for route in app.routes if route.path.startswith(prefix)]
-    removed = False
-    for route in routes_to_remove:
-        try:
-            app.routes.remove(route)
-            removed = True
-            logger.debug(f"Removed plugin route: {route.path}")
-        except Exception as e:
-            logger.error(f"Error removing plugin route {route.path}: {str(e)}")
-    return removed
-
-
-def _clean_protected_routes(existing_paths: dict):
-    """
-    清理受保护的路由，防止在插件操作中被删除或重复添加
-    :param existing_paths: 当前应用的路由路径映射
-    """
-    for protected_route in PROTECTED_ROUTES:
-        try:
-            existing_route = existing_paths.get(protected_route)
-            if existing_route:
-                app.routes.remove(existing_route)
-        except Exception as e:
-            logger.error(f"Error removing protected route {protected_route}: {str(e)}")
-
-
-def register_plugin(plugin_id: str):
-    """
-    注册一个插件相关的服务
-    """
-    # 注册插件服务
-    Scheduler().update_plugin_job(plugin_id)
-    # 注册菜单命令
-    Command().init_commands(plugin_id)
-    # 注册插件API
-    register_plugin_api(plugin_id)
+    for api in PluginManager().get_plugin_apis(plugin_id):
+        for r in router.routes:
+            if r.path == api.get("path"):
+                router.routes.remove(r)
+                break


@router.get("/", summary="所有插件", response_model=List[schemas.Plugin])
-async def all_plugins(_: User = Depends(get_current_active_superuser_async),
-                      state: Optional[str] = "all", force: bool = False) -> List[schemas.Plugin]:
+def all_plugins(_: schemas.TokenPayload = Depends(verify_token), state: str = "all") -> List[schemas.Plugin]:
    """
    查询所有插件清单，包括本地插件和在线插件，插件状态：installed, market, all
    """
    # 本地插件
-    plugin_manager = PluginManager()
-    local_plugins = plugin_manager.get_local_plugins()
+    local_plugins = PluginManager().get_local_plugins()
    # 已安装插件
    installed_plugins = [plugin for plugin in local_plugins if plugin.installed]
+    # 未安装的本地插件
+    not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
    if state == "installed":
        return installed_plugins

-    # 未安装的本地插件
-    not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
    # 在线插件
-    online_plugins = await plugin_manager.async_get_online_plugins(force)
+    online_plugins = PluginManager().get_online_plugins()
    if not online_plugins:
        # 没有获取在线插件
        if state == "market":
@@ -183,13 +78,12 @@ async def all_plugins(_: User = Depends(get_current_active_superuser_async),
    if state == "market":
        # 返回未安装的插件
        return market_plugins
-
    # 返回所有插件
    return installed_plugins + market_plugins


@router.get("/installed", summary="已安装插件", response_model=List[str])
-async def installed(_: User = Depends(get_current_active_superuser_async)) -> Any:
+def installed(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询用户已安装插件清单
    """
@@ -197,43 +91,30 @@ async def installed(_: User = Depends(get_current_active_superuser_async)) -> An


@router.get("/statistic", summary="插件安装统计", response_model=dict)
-async def statistic(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def statistic(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    插件安装统计
    """
-    return await PluginHelper().async_get_statistic()
-
-
-@router.get("/reload/{plugin_id}", summary="重新加载插件", response_model=schemas.Response)
-def reload_plugin(plugin_id: str, _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    重新加载插件
-    """
-    # 重新加载插件
-    PluginManager().reload_plugin(plugin_id)
-    # 注册插件服务
-    register_plugin(plugin_id)
-    return schemas.Response(success=True)
+    return PluginHelper().get_statistic()


@router.get("/install/{plugin_id}", summary="安装插件", response_model=schemas.Response)
-async def install(plugin_id: str,
-                  repo_url: Optional[str] = "",
-                  force: Optional[bool] = False,
-                  _: User = Depends(get_current_active_superuser_async)) -> Any:
+def install(plugin_id: str,
+            repo_url: str = "",
+            force: bool = False,
+            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    安装插件
    """
    # 已安装插件
    install_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
    # 首先检查插件是否已经存在，并且是否强制安装，否则只进行安装统计
-    plugin_helper = PluginHelper()
    if not force and plugin_id in PluginManager().get_plugin_ids():
-        await plugin_helper.async_install_reg(pid=plugin_id)
+        PluginHelper().install_reg(pid=plugin_id)
    else:
        # 插件不存在或需要强制安装，下载安装并注册插件
        if repo_url:
-            state, msg = await plugin_helper.async_install(pid=plugin_id, repo_url=repo_url)
+            state, msg = PluginHelper().install(pid=plugin_id, repo_url=repo_url)
            # 安装失败则直接响应
            if not state:
                return schemas.Response(success=False, message=msg)
@@ -244,67 +125,35 @@ async def install(plugin_id: str,
    if plugin_id not in install_plugins:
        install_plugins.append(plugin_id)
        # 保存设置
-        await SystemConfigOper().async_set(SystemConfigKey.UserInstalledPlugins, install_plugins)
-    # 重新加载插件
-    await run_in_threadpool(reload_plugin, plugin_id)
+        SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
+    # 加载插件到内存
+    PluginManager().reload_plugin(plugin_id)
+    # 注册插件服务
+    Scheduler().update_plugin_job(plugin_id)
+    # 注册插件API
+    register_plugin_api(plugin_id)
    return schemas.Response(success=True)


-@router.get("/remotes", summary="获取插件联邦组件列表", response_model=List[dict])
-async def remotes(token: str) -> Any:
-    """
-    获取插件联邦组件列表
-    """
-    if token != "moviepilot":
-        raise HTTPException(status_code=403, detail="Forbidden")
-    return PluginManager().get_plugin_remotes()
-
-
@router.get("/form/{plugin_id}", summary="获取插件表单页面")
 def plugin_form(plugin_id: str,
-                _: User = Depends(get_current_active_superuser)) -> dict:
+                _: schemas.TokenPayload = Depends(verify_token)) -> dict:
    """
-    根据插件ID获取插件配置表单或Vue组件URL
+    根据插件ID获取插件配置表单
    """
-    plugin_manager = PluginManager()
-    plugin_instance = plugin_manager.running_plugins.get(plugin_id)
-    if not plugin_instance:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"插件 {plugin_id} 不存在或未加载")
-
-    # 渲染模式
-    render_mode, _ = plugin_instance.get_render_mode()
-    try:
-        conf, model = plugin_instance.get_form()
-        return {
-            "render_mode": render_mode,
-            "conf": conf,
-            "model": plugin_manager.get_plugin_config(plugin_id) or model
-        }
-    except Exception as e:
-        logger.error(f"插件 {plugin_id} 调用方法 get_form 出错: {str(e)}")
-    return {}
+    conf, model = PluginManager().get_plugin_form(plugin_id)
+    return {
+        "conf": conf,
+        "model": model
+    }


@router.get("/page/{plugin_id}", summary="获取插件数据页面")
-def plugin_page(plugin_id: str, _: User = Depends(get_current_active_superuser)) -> dict:
+def plugin_page(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
    """
    根据插件ID获取插件数据页面
    """
-    plugin_instance = PluginManager().running_plugins.get(plugin_id)
-    if not plugin_instance:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"插件 {plugin_id} 不存在或未加载")
-
-    # 渲染模式
-    render_mode, _ = plugin_instance.get_render_mode()
-    try:
-        page = plugin_instance.get_page()
-        return {
-            "render_mode": render_mode,
-            "page": page or []
-        }
-    except Exception as e:
-        logger.error(f"插件 {plugin_id} 调用方法 get_page 出错: {str(e)}")
-    return {}
+    return PluginManager().get_plugin_page(plugin_id)


@router.get("/dashboard/meta", summary="获取所有插件仪表板元信息")
@@ -315,187 +164,47 @@ def plugin_dashboard_meta(_: schemas.TokenPayload = Depends(verify_token)) -> Li
    return PluginManager().get_plugin_dashboard_meta()


-@router.get("/dashboard/{plugin_id}/{key}", summary="获取插件仪表板配置")
-def plugin_dashboard_by_key(plugin_id: str, key: str, user_agent: Annotated[str | None, Header()] = None,
-                            _: schemas.TokenPayload = Depends(verify_token)) -> Optional[schemas.PluginDashboard]:
-    """
-    根据插件ID获取插件仪表板
-    """
-    return PluginManager().get_plugin_dashboard(plugin_id, key, user_agent)
-
-
@router.get("/dashboard/{plugin_id}", summary="获取插件仪表板配置")
 def plugin_dashboard(plugin_id: str, user_agent: Annotated[str | None, Header()] = None,
                     _: schemas.TokenPayload = Depends(verify_token)) -> schemas.PluginDashboard:
    """
    根据插件ID获取插件仪表板
    """
-    return plugin_dashboard_by_key(plugin_id, "", user_agent)
+    return PluginManager().get_plugin_dashboard(plugin_id, key=None, user_agent=user_agent)
+
+
+@router.get("/dashboard/{plugin_id}/{key}", summary="获取插件仪表板配置")
+def plugin_dashboard(plugin_id: str, key: str, user_agent: Annotated[str | None, Header()] = None,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> schemas.PluginDashboard:
+    """
+    根据插件ID获取插件仪表板
+    """
+    return PluginManager().get_plugin_dashboard(plugin_id, key=key, user_agent=user_agent)


@router.get("/reset/{plugin_id}", summary="重置插件配置及数据", response_model=schemas.Response)
-def reset_plugin(plugin_id: str,
-                 _: User = Depends(get_current_active_superuser)) -> Any:
+def reset_plugin(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据插件ID重置插件配置及数据
    """
-    plugin_manager = PluginManager()
    # 删除配置
-    plugin_manager.delete_plugin_config(plugin_id)
+    PluginManager().delete_plugin_config(plugin_id)
    # 删除插件所有数据
-    plugin_manager.delete_plugin_data(plugin_id)
-    # 重新加载插件
-    reload_plugin(plugin_id)
+    PluginManager().delete_plugin_data(plugin_id)
+    # 重新生效插件
+    PluginManager().init_plugin(plugin_id, {
+        "enabled": False,
+        "enable": False
+    })
+    # 注册插件服务
+    Scheduler().update_plugin_job(plugin_id)
+    # 注册插件API
+    register_plugin_api(plugin_id)
    return schemas.Response(success=True)


-@router.get("/file/{plugin_id}/{filepath:path}", summary="获取插件静态文件")
-async def plugin_static_file(plugin_id: str, filepath: str):
-    """
-    获取插件静态文件
-    """
-    # 基础安全检查
-    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")
-
-    plugin_base_dir = AsyncPath(settings.ROOT_PATH) / "app" / "plugins" / plugin_id.lower()
-    plugin_file_path = plugin_base_dir / filepath
-    if not await plugin_file_path.exists():
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"{plugin_file_path} 不存在")
-    if not await plugin_file_path.is_file():
-        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=f"{plugin_file_path} 不是文件")
-
-    # 判断 MIME 类型
-    response_type, _ = mimetypes.guess_type(str(plugin_file_path))
-    suffix = plugin_file_path.suffix.lower()
-    # 强制修正 .mjs 和 .js 的 MIME 类型
-    if suffix in ['.js', '.mjs']:
-        response_type = 'application/javascript'
-    elif suffix == '.css' and not response_type:  # 如果 guess_type 没猜对 css，也修正
-        response_type = 'text/css'
-    elif not response_type:  # 对于其他猜不出的类型
-        response_type = 'application/octet-stream'
-
-    try:
-        # 异步生成器函数，用于流式读取文件
-        async def file_generator():
-            async with aiofiles.open(plugin_file_path, mode='rb') as file:
-                # 8KB 块大小
-                while chunk := await file.read(8192):
-                    yield chunk
-
-        return StreamingResponse(
-            file_generator(),
-            media_type=response_type,
-            headers={"Content-Disposition": f"inline; filename={plugin_file_path.name}"}
-        )
-    except Exception as e:
-        logger.error(f"Error creating/sending StreamingResponse for {plugin_file_path}: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Internal Server Error")
-
-
-@router.get("/folders", summary="获取插件文件夹配置", response_model=dict)
-async def get_plugin_folders(_: User = Depends(get_current_active_superuser_async)) -> dict:
-    """
-    获取插件文件夹分组配置
-    """
-    try:
-        result = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
-        return result
-    except Exception as e:
-        logger.error(f"[文件夹API] 获取文件夹配置失败: {str(e)}")
-        return {}
-
-
-@router.post("/folders", summary="保存插件文件夹配置", response_model=schemas.Response)
-async def save_plugin_folders(folders: dict, _: User = Depends(get_current_active_superuser_async)) -> Any:
-    """
-    保存插件文件夹分组配置
-    """
-    try:
-        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
-        return schemas.Response(success=True)
-    except Exception as e:
-        logger.error(f"[文件夹API] 保存文件夹配置失败: {str(e)}")
-        return schemas.Response(success=False, message=str(e))
-
-
-@router.post("/folders/{folder_name}", summary="创建插件文件夹", response_model=schemas.Response)
-async def create_plugin_folder(folder_name: str,
-                               _: User = Depends(get_current_active_superuser_async)) -> Any:
-    """
-    创建新的插件文件夹
-    """
-    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
-    if folder_name not in folders:
-        folders[folder_name] = []
-        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
-        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 创建成功")
-    else:
-        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 已存在")
-
-
-@router.delete("/folders/{folder_name}", summary="删除插件文件夹", response_model=schemas.Response)
-async def delete_plugin_folder(folder_name: str,
-                               _: User = Depends(get_current_active_superuser_async)) -> Any:
-    """
-    删除插件文件夹
-    """
-    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
-    if folder_name in folders:
-        del folders[folder_name]
-        await SystemConfigOper().async_set(SystemConfigKey.PluginFolders, folders)
-        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 删除成功")
-    else:
-        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 不存在")
-
-
-@router.put("/folders/{folder_name}/plugins", summary="更新文件夹中的插件", response_model=schemas.Response)
-async def update_folder_plugins(folder_name: str, plugin_ids: List[str],
-                                _: User = Depends(get_current_active_superuser_async)) -> Any:
-    """
-    更新指定文件夹中的插件列表
-    """
-    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
-    folders[folder_name] = plugin_ids
-    await SystemConfigOper().async_set(SystemConfigKey.PluginFolders, folders)
-    return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 中的插件已更新")
-
-
-@router.post("/clone/{plugin_id}", summary="创建插件分身", response_model=schemas.Response)
-def clone_plugin(plugin_id: str,
-                 clone_data: dict,
-                 _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    创建插件分身
-    """
-    try:
-        success, message = PluginManager().clone_plugin(
-            plugin_id=plugin_id,
-            suffix=clone_data.get("suffix", ""),
-            name=clone_data.get("name", ""),
-            description=clone_data.get("description", ""),
-            version=clone_data.get("version", ""),
-            icon=clone_data.get("icon", "")
-        )
-
-        if success:
-            # 注册插件服务
-            reload_plugin(message)
-            # 将分身插件添加到原插件所在的文件夹中
-            _add_clone_to_plugin_folder(plugin_id, message)
-            return schemas.Response(success=True, message="插件分身创建成功")
-        else:
-            return schemas.Response(success=False, message=message)
-    except Exception as e:
-        logger.error(f"创建插件分身失败：{str(e)}")
-        return schemas.Response(success=False, message=f"创建插件分身失败：{str(e)}")
-
-
@router.get("/{plugin_id}", summary="获取插件配置")
-async def plugin_config(plugin_id: str,
-                        _: User = Depends(get_current_active_superuser_async)) -> dict:
+def plugin_config(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> dict:
    """
    根据插件ID获取插件配置信息
    """
@@ -504,143 +213,43 @@ async def plugin_config(plugin_id: str,

@router.put("/{plugin_id}", summary="更新插件配置", response_model=schemas.Response)
 def set_plugin_config(plugin_id: str, conf: dict,
-                      _: User = Depends(get_current_active_superuser)) -> Any:
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    更新插件配置
    """
-    plugin_manager = PluginManager()
    # 保存配置
-    plugin_manager.save_plugin_config(plugin_id, conf)
+    PluginManager().save_plugin_config(plugin_id, conf)
    # 重新生效插件
-    plugin_manager.init_plugin(plugin_id, conf)
+    PluginManager().init_plugin(plugin_id, conf)
    # 注册插件服务
-    register_plugin(plugin_id)
+    Scheduler().update_plugin_job(plugin_id)
+    # 注册插件API
+    register_plugin_api(plugin_id)
    return schemas.Response(success=True)


@router.delete("/{plugin_id}", summary="卸载插件", response_model=schemas.Response)
 def uninstall_plugin(plugin_id: str,
-                     _: User = Depends(get_current_active_superuser)) -> Any:
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    卸载插件
    """
-    config_oper = SystemConfigOper()
    # 删除已安装信息
-    install_plugins = config_oper.get(SystemConfigKey.UserInstalledPlugins) or []
+    install_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
    for plugin in install_plugins:
        if plugin == plugin_id:
            install_plugins.remove(plugin)
            break
-    config_oper.set(SystemConfigKey.UserInstalledPlugins, install_plugins)
-    # 移除插件API
-    remove_plugin_api(plugin_id)
+    # 保存
+    SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
+    # 移除插件
+    PluginManager().remove_plugin(plugin_id)
    # 移除插件服务
    Scheduler().remove_plugin_job(plugin_id)
-    # 判断是否为分身
-    plugin_manager = PluginManager()
-    plugin_class = plugin_manager.plugins.get(plugin_id)
-    if getattr(plugin_class, "is_clone", False):
-        # 如果是分身插件，则删除分身数据和配置
-        plugin_manager.delete_plugin_config(plugin_id)
-        plugin_manager.delete_plugin_data(plugin_id)
-        # 删除分身文件
-        plugin_base_dir = settings.ROOT_PATH / "app" / "plugins" / plugin_id.lower()
-        if plugin_base_dir.exists():
-            try:
-                shutil.rmtree(plugin_base_dir)
-                plugin_manager.plugins.pop(plugin_id, None)
-            except Exception as e:
-                logger.error(f"删除插件分身目录 {plugin_base_dir} 失败: {str(e)}")
-    # 从插件文件夹中移除该插件
-    _remove_plugin_from_folders(plugin_id)
-    # 移除插件
-    plugin_manager.remove_plugin(plugin_id)
+    # 移除插件API
+    remove_plugin_api(plugin_id)
    return schemas.Response(success=True)


-def _add_clone_to_plugin_folder(original_plugin_id: str, clone_plugin_id: str):
-    """
-    将分身插件添加到原插件所在的文件夹中
-    :param original_plugin_id: 原插件ID
-    :param clone_plugin_id: 分身插件ID
-    """
-    try:
-        config_oper = SystemConfigOper()
-        # 获取插件文件夹配置
-        folders = config_oper.get(SystemConfigKey.PluginFolders) or {}
-
-        # 查找原插件所在的文件夹
-        target_folder = None
-        for folder_name, folder_data in folders.items():
-            if isinstance(folder_data, dict) and 'plugins' in folder_data:
-                # 新格式：{"plugins": [...], "order": ..., "icon": ...}
-                if original_plugin_id in folder_data['plugins']:
-                    target_folder = folder_name
-                    break
-            elif isinstance(folder_data, list):
-                # 旧格式：直接是插件列表
-                if original_plugin_id in folder_data:
-                    target_folder = folder_name
-                    break
-
-        # 如果找到了原插件所在的文件夹，则将分身插件也添加到该文件夹中
-        if target_folder:
-            folder_data = folders[target_folder]
-            if isinstance(folder_data, dict) and 'plugins' in folder_data:
-                # 新格式
-                if clone_plugin_id not in folder_data['plugins']:
-                    folder_data['plugins'].append(clone_plugin_id)
-                    logger.info(f"已将分身插件 {clone_plugin_id} 添加到文件夹 '{target_folder}' 中")
-            elif isinstance(folder_data, list):
-                # 旧格式
-                if clone_plugin_id not in folder_data:
-                    folder_data.append(clone_plugin_id)
-                    logger.info(f"已将分身插件 {clone_plugin_id} 添加到文件夹 '{target_folder}' 中")
-
-            # 保存更新后的文件夹配置
-            config_oper.set(SystemConfigKey.PluginFolders, folders)
-        else:
-            logger.info(f"原插件 {original_plugin_id} 不在任何文件夹中，分身插件 {clone_plugin_id} 将保持独立")
-
-    except Exception as e:
-        logger.error(f"处理插件文件夹时出错：{str(e)}")
-        # 文件夹处理失败不影响插件分身创建的整体流程
-
-
-def _remove_plugin_from_folders(plugin_id: str):
-    """
-    从所有文件夹中移除指定的插件
-    :param plugin_id: 要移除的插件ID
-    """
-    try:
-        config_oper = SystemConfigOper()
-        # 获取插件文件夹配置
-        folders = config_oper.get(SystemConfigKey.PluginFolders) or {}
-
-        # 标记是否有修改
-        modified = False
-
-        # 遍历所有文件夹，移除指定插件
-        for folder_name, folder_data in folders.items():
-            if isinstance(folder_data, dict) and 'plugins' in folder_data:
-                # 新格式：{"plugins": [...], "order": ..., "icon": ...}
-                if plugin_id in folder_data['plugins']:
-                    folder_data['plugins'].remove(plugin_id)
-                    logger.info(f"已从文件夹 '{folder_name}' 中移除插件 {plugin_id}")
-                    modified = True
-            elif isinstance(folder_data, list):
-                # 旧格式：直接是插件列表
-                if plugin_id in folder_data:
-                    folder_data.remove(plugin_id)
-                    logger.info(f"已从文件夹 '{folder_name}' 中移除插件 {plugin_id}")
-                    modified = True
-
-        # 如果有修改，保存更新后的文件夹配置
-        if modified:
-            config_oper.set(SystemConfigKey.PluginFolders, folders)
-        else:
-            logger.debug(f"插件 {plugin_id} 不在任何文件夹中，无需移除")
-
-    except Exception as e:
-        logger.error(f"从文件夹中移除插件时出错：{str(e)}")
-        # 文件夹处理失败不影响插件卸载的整体流程
+# 注册全部插件API
+register_plugin_api()
--- a/app/api/endpoints/recommend.py
+++ b/app/api/endpoints/recommend.py
@@ -1,191 +0,0 @@
-from typing import Any, List, Optional
-
-from fastapi import APIRouter, Depends
-
-from app import schemas
-from app.chain.recommend import RecommendChain
-from app.core.event import eventmanager
-from app.core.security import verify_token
-from app.schemas import RecommendSourceEventData
-from app.schemas.types import ChainEventType
-
-router = APIRouter()
-
-
-@router.get("/source", summary="获取推荐数据源", response_model=List[schemas.RecommendMediaSource])
-def source(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取推荐数据源
-    """
-    # 广播事件，请示额外的推荐数据源支持
-    event_data = RecommendSourceEventData()
-    event = eventmanager.send_event(ChainEventType.RecommendSource, event_data)
-    # 使用事件返回的上下文数据
-    if event and event.event_data:
-        event_data: RecommendSourceEventData = event.event_data
-        if event_data.extra_sources:
-            return event_data.extra_sources
-    return []
-
-
-@router.get("/bangumi_calendar", summary="Bangumi每日放送", response_model=List[schemas.MediaInfo])
-async def bangumi_calendar(page: Optional[int] = 1,
-                           count: Optional[int] = 30,
-                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览Bangumi每日放送
-    """
-    return await RecommendChain().async_bangumi_calendar(page=page, count=count)
-
-
-@router.get("/douban_showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
-async def douban_showing(page: Optional[int] = 1,
-                         count: Optional[int] = 30,
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣正在热映
-    """
-    return await RecommendChain().async_douban_movie_showing(page=page, count=count)
-
-
-@router.get("/douban_movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
-async def douban_movies(sort: Optional[str] = "R",
-                        tags: Optional[str] = "",
-                        page: Optional[int] = 1,
-                        count: Optional[int] = 30,
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣电影信息
-    """
-    return await RecommendChain().async_douban_movies(sort=sort, tags=tags, page=page, count=count)
-
-
-@router.get("/douban_tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
-async def douban_tvs(sort: Optional[str] = "R",
-                     tags: Optional[str] = "",
-                     page: Optional[int] = 1,
-                     count: Optional[int] = 30,
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    return await RecommendChain().async_douban_tvs(sort=sort, tags=tags, page=page, count=count)
-
-
-@router.get("/douban_movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
-async def douban_movie_top250(page: Optional[int] = 1,
-                              count: Optional[int] = 30,
-                              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    return await RecommendChain().async_douban_movie_top250(page=page, count=count)
-
-
-@router.get("/douban_tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
-async def douban_tv_weekly_chinese(page: Optional[int] = 1,
-                                   count: Optional[int] = 30,
-                                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    中国每周剧集口碑榜
-    """
-    return await RecommendChain().async_douban_tv_weekly_chinese(page=page, count=count)
-
-
-@router.get("/douban_tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
-async def douban_tv_weekly_global(page: Optional[int] = 1,
-                                  count: Optional[int] = 30,
-                                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    全球每周剧集口碑榜
-    """
-    return await RecommendChain().async_douban_tv_weekly_global(page=page, count=count)
-
-
-@router.get("/douban_tv_animation", summary="豆瓣动画剧集", response_model=List[schemas.MediaInfo])
-async def douban_tv_animation(page: Optional[int] = 1,
-                              count: Optional[int] = 30,
-                              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    热门动画剧集
-    """
-    return await RecommendChain().async_douban_tv_animation(page=page, count=count)
-
-
-@router.get("/douban_movie_hot", summary="豆瓣热门电影", response_model=List[schemas.MediaInfo])
-async def douban_movie_hot(page: Optional[int] = 1,
-                           count: Optional[int] = 30,
-                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    热门电影
-    """
-    return await RecommendChain().async_douban_movie_hot(page=page, count=count)
-
-
-@router.get("/douban_tv_hot", summary="豆瓣热门电视剧", response_model=List[schemas.MediaInfo])
-async def douban_tv_hot(page: Optional[int] = 1,
-                        count: Optional[int] = 30,
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    热门电视剧
-    """
-    return await RecommendChain().async_douban_tv_hot(page=page, count=count)
-
-
-@router.get("/tmdb_movies", summary="TMDB电影", response_model=List[schemas.MediaInfo])
-async def tmdb_movies(sort_by: Optional[str] = "popularity.desc",
-                      with_genres: Optional[str] = "",
-                      with_original_language: Optional[str] = "",
-                      with_keywords: Optional[str] = "",
-                      with_watch_providers: Optional[str] = "",
-                      vote_average: Optional[float] = 0.0,
-                      vote_count: Optional[int] = 0,
-                      release_date: Optional[str] = "",
-                      page: Optional[int] = 1,
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB电影信息
-    """
-    return await RecommendChain().async_tmdb_movies(sort_by=sort_by,
-                                                    with_genres=with_genres,
-                                                    with_original_language=with_original_language,
-                                                    with_keywords=with_keywords,
-                                                    with_watch_providers=with_watch_providers,
-                                                    vote_average=vote_average,
-                                                    vote_count=vote_count,
-                                                    release_date=release_date,
-                                                    page=page)
-
-
-@router.get("/tmdb_tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
-async def tmdb_tvs(sort_by: Optional[str] = "popularity.desc",
-                   with_genres: Optional[str] = "",
-                   with_original_language: Optional[str] = "",
-                   with_keywords: Optional[str] = "",
-                   with_watch_providers: Optional[str] = "",
-                   vote_average: Optional[float] = 0.0,
-                   vote_count: Optional[int] = 0,
-                   release_date: Optional[str] = "",
-                   page: Optional[int] = 1,
-                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB剧集信息
-    """
-    return await RecommendChain().async_tmdb_tvs(sort_by=sort_by,
-                                                 with_genres=with_genres,
-                                                 with_original_language=with_original_language,
-                                                 with_keywords=with_keywords,
-                                                 with_watch_providers=with_watch_providers,
-                                                 vote_average=vote_average,
-                                                 vote_count=vote_count,
-                                                 release_date=release_date,
-                                                 page=page)
-
-
-@router.get("/tmdb_trending", summary="TMDB流行趋势", response_model=List[schemas.MediaInfo])
-async def tmdb_trending(page: Optional[int] = 1,
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    TMDB流行趋势
-    """
-    return await RecommendChain().async_tmdb_trending(page=page)
--- a/app/api/endpoints/search.py
+++ b/app/api/endpoints/search.py
@@ -1,4 +1,4 @@
-from typing import List, Any, Optional
+from typing import List, Any

 from fastapi import APIRouter, Depends

@@ -6,145 +6,81 @@ from app import schemas
 from app.chain.media import MediaChain
 from app.chain.search import SearchChain
 from app.core.config import settings
-from app.core.event import eventmanager
-from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
-from app.schemas import MediaRecognizeConvertEventData
-from app.schemas.types import MediaType, ChainEventType
+from app.schemas.types import MediaType

 router = APIRouter()


@router.get("/last", summary="查询搜索结果", response_model=List[schemas.Context])
-async def search_latest(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def search_latest(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询搜索结果
    """
-    torrents = await SearchChain().async_last_search_results() or []
+    torrents = SearchChain().last_search_results()
    return [torrent.to_dict() for torrent in torrents]


@router.get("/media/{mediaid}", summary="精确搜索资源", response_model=schemas.Response)
-async def search_by_id(mediaid: str,
-                       mtype: Optional[str] = None,
-                       area: Optional[str] = "title",
-                       title: Optional[str] = None,
-                       year: Optional[str] = None,
-                       season: Optional[str] = None,
-                       sites: Optional[str] = None,
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def search_by_id(mediaid: str,
+                 mtype: str = None,
+                 area: str = "title",
+                 season: str = None,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID/豆瓣ID精确搜索站点资源 tmdb:/douban:/bangumi:
    """
    if mtype:
-        media_type = MediaType(mtype)
-    else:
-        media_type = None
+        mtype = MediaType(mtype)
    if season:
-        media_season = int(season)
-    else:
-        media_season = None
-    if sites:
-        site_list = [int(site) for site in sites.split(",") if site]
-    else:
-        site_list = None
-    torrents = None
-    media_chain = MediaChain()
-    search_chain = SearchChain()
-    # 根据前缀识别媒体ID
+        season = int(season)
    if mediaid.startswith("tmdb:"):
        tmdbid = int(mediaid.replace("tmdb:", ""))
        if settings.RECOGNIZE_SOURCE == "douban":
            # 通过TMDBID识别豆瓣ID
-            doubaninfo = await media_chain.async_get_doubaninfo_by_tmdbid(tmdbid=tmdbid, mtype=media_type)
+            doubaninfo = MediaChain().get_doubaninfo_by_tmdbid(tmdbid=tmdbid, mtype=mtype)
            if doubaninfo:
-                torrents = await search_chain.async_search_by_id(doubanid=doubaninfo.get("id"),
-                                                                 mtype=media_type, area=area, season=media_season,
-                                                                 sites=site_list, cache_local=True)
+                torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
+                                                      mtype=mtype, area=area, season=season)
            else:
                return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
        else:
-            torrents = await search_chain.async_search_by_id(tmdbid=tmdbid, mtype=media_type, area=area,
-                                                             season=media_season,
-                                                             sites=site_list, cache_local=True)
+            torrents = SearchChain().search_by_id(tmdbid=tmdbid, mtype=mtype, area=area, season=season)
    elif mediaid.startswith("douban:"):
        doubanid = mediaid.replace("douban:", "")
        if settings.RECOGNIZE_SOURCE == "themoviedb":
            # 通过豆瓣ID识别TMDBID
-            tmdbinfo = await media_chain.async_get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=media_type)
+            tmdbinfo = MediaChain().get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=mtype)
            if tmdbinfo:
-                if tmdbinfo.get('season') and not media_season:
-                    media_season = tmdbinfo.get('season')
-                torrents = await search_chain.async_search_by_id(tmdbid=tmdbinfo.get("id"),
-                                                                 mtype=media_type, area=area, season=media_season,
-                                                                 sites=site_list, cache_local=True)
+                if tmdbinfo.get('season') and not season:
+                    season = tmdbinfo.get('season')
+                torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
+                                                      mtype=mtype, area=area, season=season)
            else:
                return schemas.Response(success=False, message="未识别到TMDB媒体信息")
        else:
-            torrents = await search_chain.async_search_by_id(doubanid=doubanid, mtype=media_type, area=area,
-                                                             season=media_season,
-                                                             sites=site_list, cache_local=True)
+            torrents = SearchChain().search_by_id(doubanid=doubanid, mtype=mtype, area=area, season=season)
    elif mediaid.startswith("bangumi:"):
        bangumiid = int(mediaid.replace("bangumi:", ""))
        if settings.RECOGNIZE_SOURCE == "themoviedb":
            # 通过BangumiID识别TMDBID
-            tmdbinfo = await media_chain.async_get_tmdbinfo_by_bangumiid(bangumiid=bangumiid)
+            tmdbinfo = MediaChain().get_tmdbinfo_by_bangumiid(bangumiid=bangumiid)
            if tmdbinfo:
-                torrents = await search_chain.async_search_by_id(tmdbid=tmdbinfo.get("id"),
-                                                                 mtype=media_type, area=area, season=media_season,
-                                                                 sites=site_list, cache_local=True)
+                torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
+                                                      mtype=mtype, area=area, season=season)
            else:
                return schemas.Response(success=False, message="未识别到TMDB媒体信息")
        else:
            # 通过BangumiID识别豆瓣ID
-            doubaninfo = await media_chain.async_get_doubaninfo_by_bangumiid(bangumiid=bangumiid)
+            doubaninfo = MediaChain().get_doubaninfo_by_bangumiid(bangumiid=bangumiid)
            if doubaninfo:
-                torrents = await search_chain.async_search_by_id(doubanid=doubaninfo.get("id"),
-                                                                 mtype=media_type, area=area, season=media_season,
-                                                                 sites=site_list, cache_local=True)
+                torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
+                                                      mtype=mtype, area=area, season=season)
            else:
                return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
    else:
-        # 未知前缀，广播事件解析媒体信息
-        event_data = MediaRecognizeConvertEventData(
-            mediaid=mediaid,
-            convert_type=settings.RECOGNIZE_SOURCE
-        )
-        event = await eventmanager.async_send_event(ChainEventType.MediaRecognizeConvert, event_data)
-        # 使用事件返回的上下文数据
-        if event and event.event_data:
-            event_data: MediaRecognizeConvertEventData = event.event_data
-            if event_data.media_dict:
-                search_id = event_data.media_dict.get("id")
-                if event_data.convert_type == "themoviedb":
-                    torrents = await search_chain.async_search_by_id(tmdbid=search_id, mtype=media_type, area=area,
-                                                                     season=media_season, cache_local=True)
-                elif event_data.convert_type == "douban":
-                    torrents = await search_chain.async_search_by_id(doubanid=search_id, mtype=media_type, area=area,
-                                                                     season=media_season, cache_local=True)
-        else:
-            if not title:
-                return schemas.Response(success=False, message="未知的媒体ID")
-            # 使用名称识别兜底
-            meta = MetaInfo(title)
-            if year:
-                meta.year = year
-            if media_type:
-                meta.type = media_type
-            if media_season:
-                meta.type = MediaType.TV
-                meta.begin_season = media_season
-            mediainfo = await media_chain.async_recognize_media(meta=meta)
-            if mediainfo:
-                if settings.RECOGNIZE_SOURCE == "themoviedb":
-                    torrents = await search_chain.async_search_by_id(tmdbid=mediainfo.tmdb_id, mtype=media_type,
-                                                                     area=area,
-                                                                     season=media_season, cache_local=True)
-                else:
-                    torrents = await search_chain.async_search_by_id(doubanid=mediainfo.douban_id, mtype=media_type,
-                                                                     area=area,
-                                                                     season=media_season, cache_local=True)
-    # 返回搜索结果
+        return schemas.Response(success=False, message="未知的媒体ID")
+
    if not torrents:
        return schemas.Response(success=False, message="未搜索到任何资源")
    else:
@@ -152,18 +88,14 @@ async def search_by_id(mediaid: str,


@router.get("/title", summary="模糊搜索资源", response_model=schemas.Response)
-async def search_by_title(keyword: Optional[str] = None,
-                          page: Optional[int] = 0,
-                          sites: Optional[str] = None,
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def search_by_title(keyword: str = None,
+                    page: int = 0,
+                    site: int = None,
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据名称模糊搜索站点资源，支持分页，关键词为空是返回首页资源
    """
-    torrents = await SearchChain().async_search_by_title(
-        title=keyword, page=page,
-        sites=[int(site) for site in sites.split(",") if site] if sites else None,
-        cache_local=True
-    )
+    torrents = SearchChain().search_by_title(title=keyword, page=page, site=site)
    if not torrents:
        return schemas.Response(success=False, message="未搜索到任何资源")
    return schemas.Response(success=True, data=[torrent.to_dict() for torrent in torrents])
--- a/app/api/endpoints/site.py
+++ b/app/api/endpoints/site.py
@@ -1,28 +1,22 @@
-from typing import List, Any, Dict, Optional
+from typing import List, Any

 from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 from starlette.background import BackgroundTasks

 from app import schemas
-from app.api.endpoints.plugin import register_plugin_api
 from app.chain.site import SiteChain
 from app.chain.torrents import TorrentsChain
-from app.command import Command
-from app.core.event import eventmanager
-from app.core.plugin import PluginManager
+from app.core.event import EventManager
 from app.core.security import verify_token
-from app.db import get_db, get_async_db
+from app.db import get_db
 from app.db.models import User
 from app.db.models.site import Site
 from app.db.models.siteicon import SiteIcon
 from app.db.models.sitestatistic import SiteStatistic
-from app.db.models.siteuserdata import SiteUserData
-from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async
-from app.helper.sites import SitesHelper  # noqa
+from app.db.userauth import get_current_active_superuser
+from app.helper.sites import SitesHelper
 from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey, EventType
 from app.utils.string import StringUtils
@@ -31,20 +25,20 @@ router = APIRouter()


@router.get("/", summary="所有站点", response_model=List[schemas.Site])
-async def read_sites(db: AsyncSession = Depends(get_async_db),
-                     _: User = Depends(get_current_active_superuser)) -> List[dict]:
+def read_sites(db: Session = Depends(get_db),
+               _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
    """
    获取站点列表
    """
-    return await Site.async_list_order_by_pri(db)
+    return Site.list_order_by_pri(db)


@router.post("/", summary="新增站点", response_model=schemas.Response)
-async def add_site(
+def add_site(
        *,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        site_in: schemas.Site,
-        _: User = Depends(get_current_active_superuser)
+        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    新增站点
@@ -54,10 +48,10 @@ async def add_site(
    if SitesHelper().auth_level < 2:
        return schemas.Response(success=False, message="用户未通过认证，无法使用站点功能！")
    domain = StringUtils.get_url_domain(site_in.url)
-    site_info = await SitesHelper().async_get_indexer(domain)
+    site_info = SitesHelper().get_indexer(domain)
    if not site_info:
        return schemas.Response(success=False, message="该站点不支持，请检查站点域名是否正确")
-    if await Site.async_get_by_domain(db, domain):
+    if Site.get_by_domain(db, domain):
        return schemas.Response(success=False, message=f"{domain} 站点己存在")
    # 保存站点信息
    site_in.domain = domain
@@ -67,42 +61,42 @@ async def add_site(
    site_in.name = site_info.get("name")
    site_in.id = None
    site_in.public = 1 if site_info.get("public") else 0
-    site = Site(**site_in.model_dump())
+    site = Site(**site_in.dict())
    site.create(db)
    # 通知站点更新
-    await eventmanager.async_send_event(EventType.SiteUpdated, {
+    EventManager().send_event(EventType.SiteUpdated, {
        "domain": domain
    })
    return schemas.Response(success=True)


@router.put("/", summary="更新站点", response_model=schemas.Response)
-async def update_site(
+def update_site(
        *,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        site_in: schemas.Site,
-        _: User = Depends(get_current_active_superuser)
+        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    更新站点信息
    """
-    site = await Site.async_get(db, site_in.id)
+    site = Site.get(db, site_in.id)
    if not site:
        return schemas.Response(success=False, message="站点不存在")
    # 校正地址格式
    _scheme, _netloc = StringUtils.get_url_netloc(site_in.url)
    site_in.url = f"{_scheme}://{_netloc}/"
-    await site.async_update(db, site_in.model_dump())
+    site.update(db, site_in.dict())
    # 通知站点更新
-    await eventmanager.async_send_event(EventType.SiteUpdated, {
+    EventManager().send_event(EventType.SiteUpdated, {
        "domain": site_in.domain
    })
    return schemas.Response(success=True)


@router.get("/cookiecloud", summary="CookieCloud同步", response_model=schemas.Response)
-async def cookie_cloud_sync(background_tasks: BackgroundTasks,
-                            _: User = Depends(get_current_active_superuser_async)) -> Any:
+def cookie_cloud_sync(background_tasks: BackgroundTasks,
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    运行CookieCloud同步站点信息
    """
@@ -111,7 +105,7 @@ async def cookie_cloud_sync(background_tasks: BackgroundTasks,


@router.get("/reset", summary="重置站点", response_model=schemas.Response)
-def reset(db: AsyncSession = Depends(get_db),
+def reset(db: Session = Depends(get_db),
          _: User = Depends(get_current_active_superuser)) -> Any:
    """
    清空所有站点数据并重新同步CookieCloud站点信息
@@ -122,25 +116,25 @@ def reset(db: AsyncSession = Depends(get_db),
    # 启动定时服务
    Scheduler().start("cookiecloud", manual=True)
    # 插件站点删除
-    eventmanager.send_event(EventType.SiteDeleted,
-                            {
-                                "site_id": "*"
-                            })
+    EventManager().send_event(EventType.SiteDeleted,
+                              {
+                                  "site_id": "*"
+                              })
    return schemas.Response(success=True, message="站点已重置！")


@router.post("/priorities", summary="批量更新站点优先级", response_model=schemas.Response)
-async def update_sites_priority(
+def update_sites_priority(
        priorities: List[dict],
-        db: AsyncSession = Depends(get_async_db),
-        _: User = Depends(get_current_active_superuser_async)) -> Any:
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    批量更新站点优先级
    """
    for priority in priorities:
-        site = await Site.async_get(db, priority.get("id"))
+        site = Site.get(db, priority.get("id"))
        if site:
-            await site.async_update(db, {"pri": priority.get("pri")})
+            site.update(db, {"pri": priority.get("pri")})
    return schemas.Response(success=True)


@@ -149,9 +143,9 @@ def update_cookie(
        site_id: int,
        username: str,
        password: str,
-        code: Optional[str] = None,
+        code: str = None,
        db: Session = Depends(get_db),
-        _: User = Depends(get_current_active_superuser)) -> Any:
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    使用用户密码更新站点Cookie
    """
@@ -170,61 +164,6 @@ def update_cookie(
    return schemas.Response(success=state, message=message)


-@router.post("/userdata/{site_id}", summary="更新站点用户数据", response_model=schemas.Response)
-def refresh_userdata(
-        site_id: int,
-        db: Session = Depends(get_db),
-        _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    刷新站点用户数据
-    """
-    site = Site.get(db, site_id)
-    if not site:
-        raise HTTPException(
-            status_code=404,
-            detail=f"站点 {site_id} 不存在",
-        )
-    indexer = SitesHelper().get_indexer(site.domain)
-    if not indexer:
-        return schemas.Response(success=False, message="站点不支持索引或未通过用户认证！")
-    user_data = SiteChain().refresh_userdata(site=indexer) or {}
-    return schemas.Response(success=True, data=user_data)
-
-
-@router.get("/userdata/latest", summary="查询所有站点最新用户数据", response_model=List[schemas.SiteUserData])
-async def read_userdata_latest(
-        db: AsyncSession = Depends(get_async_db),
-        _: User = Depends(get_current_active_superuser_async)) -> Any:
-    """
-    查询所有站点最新用户数据
-    """
-    user_datas = await SiteUserData.async_get_latest(db)
-    if not user_datas:
-        return []
-    return [user_data.to_dict() for user_data in user_datas]
-
-
-@router.get("/userdata/{site_id}", summary="查询某站点用户数据", response_model=schemas.Response)
-async def read_userdata(
-        site_id: int,
-        workdate: Optional[str] = None,
-        db: AsyncSession = Depends(get_async_db),
-        _: User = Depends(get_current_active_superuser_async)) -> Any:
-    """
-    查询站点用户数据
-    """
-    site = await Site.async_get(db, site_id)
-    if not site:
-        raise HTTPException(
-            status_code=404,
-            detail=f"站点 {site_id} 不存在",
-        )
-    user_datas = await SiteUserData.async_get_by_domain(db, domain=site.domain, workdate=workdate)
-    if not user_datas:
-        return schemas.Response(success=False, data=[])
-    return schemas.Response(success=True, data=[data.to_dict() for data in user_datas])
-
-
@router.get("/test/{site_id}", summary="连接测试", response_model=schemas.Response)
 def test_site(site_id: int,
              db: Session = Depends(get_db),
@@ -243,19 +182,19 @@ def test_site(site_id: int,


@router.get("/icon/{site_id}", summary="站点图标", response_model=schemas.Response)
-async def site_icon(site_id: int,
-                    db: AsyncSession = Depends(get_async_db),
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def site_icon(site_id: int,
+              db: Session = Depends(get_db),
+              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    获取站点图标：base64或者url
    """
-    site = await Site.async_get(db, site_id)
+    site = Site.get(db, site_id)
    if not site:
        raise HTTPException(
            status_code=404,
            detail=f"站点 {site_id} 不存在",
        )
-    icon = await SiteIcon.async_get_by_domain(db, site.domain)
+    icon = SiteIcon.get_by_domain(db, site.domain)
    if not icon:
        return schemas.Response(success=False, message="站点图标不存在！")
    return schemas.Response(success=True, data={
@@ -263,69 +202,36 @@ async def site_icon(site_id: int,
    })


-@router.get("/category/{site_id}", summary="站点分类", response_model=List[schemas.SiteCategory])
-async def site_category(site_id: int,
-                        db: AsyncSession = Depends(get_async_db),
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取站点分类
-    """
-    site = await Site.async_get(db, site_id)
-    if not site:
-        raise HTTPException(
-            status_code=404,
-            detail=f"站点 {site_id} 不存在",
-        )
-    indexer = await SitesHelper().async_get_indexer(site.domain)
-    if not indexer:
-        raise HTTPException(
-            status_code=404,
-            detail=f"站点 {site.domain} 不支持",
-        )
-    category: Dict[str, List[dict]] = indexer.get('category') or []
-    if not category:
-        return []
-    result = []
-    for cats in category.values():
-        for cat in cats:
-            if cat not in result:
-                result.append(cat)
-    return result
-
-
@router.get("/resource/{site_id}", summary="站点资源", response_model=List[schemas.TorrentInfo])
-async def site_resource(site_id: int,
-                        keyword: Optional[str] = None,
-                        cat: Optional[str] = None,
-                        page: Optional[int] = 0,
-                        db: AsyncSession = Depends(get_async_db),
-                        _: User = Depends(get_current_active_superuser_async)) -> Any:
+def site_resource(site_id: int,
+                  db: Session = Depends(get_db),
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    浏览站点资源
    """
-    site = await Site.async_get(db, site_id)
+    site = Site.get(db, site_id)
    if not site:
        raise HTTPException(
            status_code=404,
            detail=f"站点 {site_id} 不存在",
        )
-    torrents = await TorrentsChain().async_browse(domain=site.domain, keyword=keyword, cat=cat, page=page)
+    torrents = TorrentsChain().browse(domain=site.domain)
    if not torrents:
        return []
    return [torrent.to_dict() for torrent in torrents]


@router.get("/domain/{site_url}", summary="站点详情", response_model=schemas.Site)
-async def read_site_by_domain(
+def read_site_by_domain(
        site_url: str,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    通过域名获取站点信息
    """
    domain = StringUtils.get_url_domain(site_url)
-    site = await Site.async_get_by_domain(db, domain)
+    site = Site.get_by_domain(db, domain)
    if not site:
        raise HTTPException(
            status_code=404,
@@ -334,36 +240,24 @@ async def read_site_by_domain(
    return site


-@router.get("/statistic/{site_url}", summary="特定站点统计信息", response_model=schemas.SiteStatistic)
-async def read_statistic_by_domain(
+@router.get("/statistic/{site_url}", summary="站点统计信息", response_model=schemas.SiteStatistic)
+def read_site_by_domain(
        site_url: str,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    通过域名获取站点统计信息
    """
    domain = StringUtils.get_url_domain(site_url)
-    sitestatistic = await SiteStatistic.async_get_by_domain(db, domain)
+    sitestatistic = SiteStatistic.get_by_domain(db, domain)
    if sitestatistic:
        return sitestatistic
    return schemas.SiteStatistic(domain=domain)


-@router.get("/statistic", summary="所有站点统计信息", response_model=List[schemas.SiteStatistic])
-async def read_statistics(
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)
-) -> Any:
-    """
-    获取所有站点统计信息
-    """
-    return await SiteStatistic.async_list(db)
-
-
@router.get("/rss", summary="所有订阅站点", response_model=List[schemas.Site])
-async def read_rss_sites(db: AsyncSession = Depends(get_async_db),
-                         _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
+def read_rss_sites(db: Session = Depends(get_db)) -> List[dict]:
    """
    获取站点列表
    """
@@ -371,7 +265,7 @@ async def read_rss_sites(db: AsyncSession = Depends(get_async_db),
    selected_sites = SystemConfigOper().get(SystemConfigKey.RssSites) or []

    # 所有站点
-    all_site = await Site.async_list_order_by_pri(db)
+    all_site = Site.list_order_by_pri(db)
    if not selected_sites:
        return all_site

@@ -380,67 +274,16 @@ async def read_rss_sites(db: AsyncSession = Depends(get_async_db),
    return rss_sites


-@router.get("/auth", summary="查询认证站点", response_model=dict)
-async def read_auth_sites(_: schemas.TokenPayload = Depends(verify_token)) -> dict:
-    """
-    获取可认证站点列表
-    """
-    return SitesHelper().get_authsites()
-
-
-@router.post("/auth", summary="用户站点认证", response_model=schemas.Response)
-def auth_site(
-        auth_info: schemas.SiteAuth,
-        _: User = Depends(get_current_active_superuser)
-) -> Any:
-    """
-    用户站点认证
-    """
-    if not auth_info or not auth_info.site or not auth_info.params:
-        return schemas.Response(success=False, message="请输入认证站点和认证参数")
-    status, msg = SitesHelper().check_user(auth_info.site, auth_info.params)
-    SystemConfigOper().set(SystemConfigKey.UserSiteAuthParams, auth_info.model_dump())
-    # 认证成功后，重新初始化插件
-    PluginManager().init_config()
-    Scheduler().init_plugin_jobs()
-    Command().init_commands()
-    register_plugin_api()
-    return schemas.Response(success=status, message=msg)
-
-
-@router.get("/mapping", summary="获取站点域名到名称的映射", response_model=schemas.Response)
-async def site_mapping(_: User = Depends(get_current_active_superuser_async)):
-    """
-    获取站点域名到名称的映射关系
-    """
-    try:
-        sites = await SiteOper().async_list()
-        mapping = {}
-        for site in sites:
-            mapping[site.domain] = site.name
-        return schemas.Response(success=True, data=mapping)
-    except Exception as e:
-        return schemas.Response(success=False, message=f"获取映射失败：{str(e)}")
-
-
-@router.get("/supporting", summary="获取支持的站点列表", response_model=dict)
-async def support_sites(_: User = Depends(get_current_active_superuser_async)):
-    """
-    获取支持的站点列表
-    """
-    return SitesHelper().get_indexsites()
-
-
@router.get("/{site_id}", summary="站点详情", response_model=schemas.Site)
-async def read_site(
+def read_site(
        site_id: int,
-        db: AsyncSession = Depends(get_async_db),
-        _: User = Depends(get_current_active_superuser_async)
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    通过ID获取站点信息
    """
-    site = await Site.async_get(db, site_id)
+    site = Site.get(db, site_id)
    if not site:
        raise HTTPException(
            status_code=404,
@@ -450,18 +293,18 @@ async def read_site(


@router.delete("/{site_id}", summary="删除站点", response_model=schemas.Response)
-async def delete_site(
+def delete_site(
        site_id: int,
-        db: AsyncSession = Depends(get_async_db),
-        _: User = Depends(get_current_active_superuser_async)
+        db: Session = Depends(get_db),
+        _: User = Depends(get_current_active_superuser)
 ) -> Any:
    """
    删除站点
    """
-    await Site.async_delete(db, site_id)
+    Site.delete(db, site_id)
    # 插件站点删除
-    await eventmanager.async_send_event(EventType.SiteDeleted,
-                                        {
-                                            "site_id": site_id
-                                        })
+    EventManager().send_event(EventType.SiteDeleted,
+                              {
+                                  "site_id": site_id
+                              })
    return schemas.Response(success=True)
--- a/app/api/endpoints/storage.py
+++ b/app/api/endpoints/storage.py
@@ -1,232 +0,0 @@
-from datetime import datetime
-from pathlib import Path
-from typing import Any, List, Optional
-
-from fastapi import APIRouter, Depends, HTTPException
-from starlette.responses import FileResponse, Response
-
-from app import schemas
-from app.chain.storage import StorageChain
-from app.chain.transfer import TransferChain
-from app.core.config import settings
-from app.core.metainfo import MetaInfoPath
-from app.core.security import verify_token
-from app.db.models import User
-from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async
-from app.helper.progress import ProgressHelper
-from app.schemas.types import ProgressKey
-from app.utils.string import StringUtils
-
-router = APIRouter()
-
-
-@router.get("/qrcode/{name}", summary="生成二维码内容", response_model=schemas.Response)
-def qrcode(name: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    生成二维码
-    """
-    qrcode_data, errmsg = StorageChain().generate_qrcode(name)
-    if qrcode_data:
-        return schemas.Response(success=True, data=qrcode_data, message=errmsg)
-    return schemas.Response(success=False, message=errmsg)
-
-
-@router.get("/check/{name}", summary="二维码登录确认", response_model=schemas.Response)
-def check(name: str, ck: Optional[str] = None, t: Optional[str] = None,
-          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    二维码登录确认
-    """
-    if ck or t:
-        data, errmsg = StorageChain().check_login(name, ck=ck, t=t)
-    else:
-        data, errmsg = StorageChain().check_login(name)
-    if data:
-        return schemas.Response(success=True, data=data)
-    return schemas.Response(success=False, message=errmsg)
-
-
-@router.post("/save/{name}", summary="保存存储配置", response_model=schemas.Response)
-def save(name: str,
-         conf: dict,
-         _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    保存存储配置
-    """
-    StorageChain().save_config(name, conf)
-    return schemas.Response(success=True)
-
-
-@router.get("/reset/{name}", summary="重置存储配置", response_model=schemas.Response)
-def reset(name: str,
-          _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    重置存储配置
-    """
-    StorageChain().reset_config(name)
-    return schemas.Response(success=True)
-
-
-@router.post("/list", summary="所有目录和文件", response_model=List[schemas.FileItem])
-def list_files(fileitem: schemas.FileItem,
-               sort: Optional[str] = 'updated_at',
-               _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    查询当前目录下所有目录和文件
-    :param fileitem: 文件项
-    :param sort: 排序方式，name:按名称排序，time:按修改时间排序
-    :param _: token
-    :return: 所有目录和文件
-    """
-    file_list = StorageChain().list_files(fileitem)
-    if file_list:
-        if sort == "name":
-            file_list.sort(key=lambda x: StringUtils.natural_sort_key(x.name or ""))
-        else:
-            file_list.sort(key=lambda x: x.modify_time or datetime.min, reverse=True)
-    return file_list
-
-
-@router.post("/mkdir", summary="创建目录", response_model=schemas.Response)
-def mkdir(fileitem: schemas.FileItem,
-          name: str,
-          _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    创建目录
-    :param fileitem: 文件项
-    :param name: 目录名称
-    :param _: token
-    """
-    if not name:
-        return schemas.Response(success=False)
-    result = StorageChain().create_folder(fileitem, name)
-    if result:
-        return schemas.Response(success=True)
-    return schemas.Response(success=False)
-
-
-@router.post("/delete", summary="删除文件或目录", response_model=schemas.Response)
-def delete(fileitem: schemas.FileItem,
-           _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    删除文件或目录
-    :param fileitem: 文件项
-    :param _: token
-    """
-    result = StorageChain().delete_file(fileitem)
-    if result:
-        return schemas.Response(success=True)
-    return schemas.Response(success=False)
-
-
-@router.post("/download", summary="下载文件")
-def download(fileitem: schemas.FileItem,
-             _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    下载文件或目录
-    :param fileitem: 文件项
-    :param _: token
-    """
-    # 临时目录
-    tmp_file = StorageChain().download_file(fileitem)
-    if tmp_file:
-        return FileResponse(path=tmp_file)
-    return schemas.Response(success=False)
-
-
-@router.post("/image", summary="预览图片")
-def image(fileitem: schemas.FileItem,
-          _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    下载文件或目录
-    :param fileitem: 文件项
-    :param _: token
-    """
-    # 临时目录
-    tmp_file = StorageChain().download_file(fileitem)
-    if not tmp_file:
-        raise HTTPException(status_code=500, detail="图片读取出错")
-    return Response(content=tmp_file.read_bytes(), media_type="image/jpeg")
-
-
-@router.post("/rename", summary="重命名文件或目录", response_model=schemas.Response)
-def rename(fileitem: schemas.FileItem,
-           new_name: str,
-           recursive: Optional[bool] = False,
-           _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    重命名文件或目录
-    :param fileitem: 文件项
-    :param new_name: 新名称
-    :param recursive: 是否递归修改
-    :param _: token
-    """
-    if not new_name:
-        return schemas.Response(success=False, message="新名称为空")
-
-    # 重命名目录内文件
-    if recursive:
-        transferchain = TransferChain()
-        media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIO_TRACK_EXT
-        # 递归修改目录内文件（智能识别命名）
-        sub_files: List[schemas.FileItem] = StorageChain().list_files(fileitem)
-        if sub_files:
-            # 开始进度
-            progress = ProgressHelper(ProgressKey.BatchRename)
-            progress.start()
-            total = len(sub_files)
-            handled = 0
-            for sub_file in sub_files:
-                handled += 1
-                progress.update(value=handled / total * 100,
-                                text=f"正在处理 {sub_file.name} ...")
-                if sub_file.type == "dir":
-                    continue
-                if not sub_file.extension:
-                    continue
-                if f".{sub_file.extension.lower()}" not in media_exts:
-                    continue
-                sub_path = Path(f"{fileitem.path}{sub_file.name}")
-                meta = MetaInfoPath(sub_path)
-                mediainfo = transferchain.recognize_media(meta)
-                if not mediainfo:
-                    progress.end()
-                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
-                new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
-                if not new_path:
-                    progress.end()
-                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
-                ret: schemas.Response = rename(fileitem=sub_file,
-                                               new_name=Path(new_path).name,
-                                               recursive=False)
-                if not ret.success:
-                    progress.end()
-                    return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
-            progress.end()
-    # 重命名自己
-    result = StorageChain().rename_file(fileitem, new_name)
-    if result:
-        return schemas.Response(success=True)
-    return schemas.Response(success=False)
-
-
-@router.get("/usage/{name}", summary="存储空间信息", response_model=schemas.StorageUsage)
-def usage(name: str, _: User = Depends(get_current_active_superuser)) -> Any:
-    """
-    查询存储空间
-    """
-    ret = StorageChain().storage_usage(name)
-    if ret:
-        return ret
-    return schemas.StorageUsage()
-
-
-@router.get("/transtype/{name}", summary="支持的整理方式获取", response_model=schemas.StorageTransType)
-async def transtype(name: str, _: User = Depends(get_current_active_superuser_async)) -> Any:
-    """
-    查询支持的整理方式
-    """
-    ret = StorageChain().support_transtype(name)
-    if ret:
-        return schemas.StorageTransType(transtype=ret)
-    return schemas.StorageTransType()
--- a/app/api/endpoints/subscribe.py
+++ b/app/api/endpoints/subscribe.py
@@ -1,26 +1,24 @@
-from typing import List, Any, Annotated, Optional
+import json
+from typing import List, Any

 import cn2an
 from fastapi import APIRouter, Request, BackgroundTasks, Depends, HTTPException, Header
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session

 from app import schemas
 from app.chain.subscribe import SubscribeChain
 from app.core.config import settings
 from app.core.context import MediaInfo
-from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token, verify_apitoken
-from app.db import get_async_db, get_db
+from app.db import get_db
 from app.db.models.subscribe import Subscribe
 from app.db.models.subscribehistory import SubscribeHistory
 from app.db.models.user import User
-from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_user_async
+from app.db.userauth import get_current_active_user
 from app.helper.subscribe import SubscribeHelper
 from app.scheduler import Scheduler
-from app.schemas.types import MediaType, EventType, SystemConfigKey
+from app.schemas.types import MediaType

 router = APIRouter()

@@ -35,29 +33,38 @@ def start_subscribe_add(title: str, year: str,


@router.get("/", summary="查询所有订阅", response_model=List[schemas.Subscribe])
-async def read_subscribes(
-        db: AsyncSession = Depends(get_async_db),
+def read_subscribes(
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询所有订阅
    """
-    return await Subscribe.async_list(db)
+    subscribes = Subscribe.list(db)
+    for subscribe in subscribes:
+        if subscribe.sites:
+            try:
+                subscribe.sites = json.loads(str(subscribe.sites))
+            except json.JSONDecodeError:
+                subscribe.sites = []
+        else:
+            subscribe.sites = []
+    return subscribes


@router.get("/list", summary="查询所有订阅（API_TOKEN）", response_model=List[schemas.Subscribe])
-async def list_subscribes(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def list_subscribes(_: str = Depends(verify_apitoken)) -> Any:
    """
    查询所有订阅 API_TOKEN认证（?token=xxx）
    """
-    return await read_subscribes()
+    return read_subscribes()


@router.post("/", summary="新增订阅", response_model=schemas.Response)
-async def create_subscribe(
+def create_subscribe(
        *,
        subscribe_in: schemas.Subscribe,
-        current_user: User = Depends(get_current_active_user_async),
-) -> schemas.Response:
+        current_user: User = Depends(get_current_active_user),
+) -> Any:
    """
    新增订阅
    """
@@ -76,37 +83,40 @@ async def create_subscribe(
        title = subscribe_in.name
    else:
        title = None
-    # 订阅用户
-    subscribe_in.username = current_user.name
-    # 转化为字典
-    subscribe_dict = subscribe_in.model_dump()
-    if subscribe_in.id:
-        subscribe_dict.pop("id", None)
-    sid, message = await SubscribeChain().async_add(mtype=mtype,
-                                                    title=title,
-                                                    exist_ok=True,
-                                                    **subscribe_dict)
+    sid, message = SubscribeChain().add(mtype=mtype,
+                                        title=title,
+                                        year=subscribe_in.year,
+                                        tmdbid=subscribe_in.tmdbid,
+                                        season=subscribe_in.season,
+                                        doubanid=subscribe_in.doubanid,
+                                        bangumiid=subscribe_in.bangumiid,
+                                        username=current_user.name,
+                                        best_version=subscribe_in.best_version,
+                                        save_path=subscribe_in.save_path,
+                                        search_imdbid=subscribe_in.search_imdbid,
+                                        exist_ok=True)
    return schemas.Response(
        success=bool(sid), message=message, data={"id": sid}
    )


@router.put("/", summary="更新订阅", response_model=schemas.Response)
-async def update_subscribe(
+def update_subscribe(
        *,
        subscribe_in: schemas.Subscribe,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    更新订阅信息
    """
-    subscribe = await Subscribe.async_get(db, subscribe_in.id)
+    subscribe = Subscribe.get(db, subscribe_in.id)
    if not subscribe:
        return schemas.Response(success=False, message="订阅不存在")
+    if subscribe_in.sites is not None:
+        subscribe_in.sites = json.dumps(subscribe_in.sites)
    # 避免更新缺失集数
-    old_subscribe_dict = subscribe.to_dict()
-    subscribe_dict = subscribe_in.model_dump()
+    subscribe_dict = subscribe_in.dict()
    if not subscribe_in.lack_episode:
        # 没有缺失集数时，缺失集数清空，避免更新为0
        subscribe_dict.pop("lack_episode")
@@ -119,81 +129,39 @@ async def update_subscribe(
    # 是否手动修改过总集数
    if subscribe_in.total_episode != subscribe.total_episode:
        subscribe_dict["manual_total_episode"] = 1
-    # 更新到数据库
-    await subscribe.async_update(db, subscribe_dict)
-    # 重新获取更新后的订阅数据
-    updated_subscribe = await Subscribe.async_get(db, subscribe_in.id)
-    # 发送订阅调整事件
-    await eventmanager.async_send_event(EventType.SubscribeModified, {
-        "subscribe_id": subscribe_in.id,
-        "old_subscribe_info": old_subscribe_dict,
-        "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
-    })
-    return schemas.Response(success=True)
-
-
-@router.put("/status/{subid}", summary="更新订阅状态", response_model=schemas.Response)
-async def update_subscribe_status(
-        subid: int,
-        state: str,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    更新订阅状态
-    """
-    subscribe = await Subscribe.async_get(db, subid)
-    if not subscribe:
-        return schemas.Response(success=False, message="订阅不存在")
-    valid_states = ["R", "P", "S"]
-    if state not in valid_states:
-        return schemas.Response(success=False, message="无效的订阅状态")
-    old_subscribe_dict = subscribe.to_dict()
-    await subscribe.async_update(db, {
-        "state": state
-    })
-    # 重新获取更新后的订阅数据
-    updated_subscribe = await Subscribe.async_get(db, subid)
-    # 发送订阅调整事件
-    await eventmanager.async_send_event(EventType.SubscribeModified, {
-        "subscribe_id": subid,
-        "old_subscribe_info": old_subscribe_dict,
-        "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
-    })
+    subscribe.update(db, subscribe_dict)
    return schemas.Response(success=True)


@router.get("/media/{mediaid}", summary="查询订阅", response_model=schemas.Subscribe)
-async def subscribe_mediaid(
+def subscribe_mediaid(
        mediaid: str,
-        season: Optional[int] = None,
-        title: Optional[str] = None,
-        db: AsyncSession = Depends(get_async_db),
+        season: int = None,
+        title: str = None,
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据 TMDBID/豆瓣ID/BangumiId 查询订阅 tmdb:/douban:
    """
+    result = None
    title_check = False
    if mediaid.startswith("tmdb:"):
        tmdbid = mediaid[5:]
        if not tmdbid or not str(tmdbid).isdigit():
            return Subscribe()
-        result = await Subscribe.async_exists(db, tmdbid=int(tmdbid), season=season)
+        result = Subscribe.exists(db, tmdbid=int(tmdbid), season=season)
    elif mediaid.startswith("douban:"):
        doubanid = mediaid[7:]
        if not doubanid:
            return Subscribe()
-        result = await Subscribe.async_get_by_doubanid(db, doubanid)
+        result = Subscribe.get_by_doubanid(db, doubanid)
        if not result and title:
            title_check = True
    elif mediaid.startswith("bangumi:"):
        bangumiid = mediaid[8:]
        if not bangumiid or not str(bangumiid).isdigit():
            return Subscribe()
-        result = await Subscribe.async_get_by_bangumiid(db, int(bangumiid))
-        if not result and title:
-            title_check = True
-    else:
-        result = await Subscribe.async_get_by_mediaid(db, mediaid)
+        result = Subscribe.get_by_bangumiid(db, int(bangumiid))
        if not result and title:
            title_check = True
    # 使用名称检查订阅
@@ -201,7 +169,12 @@ async def subscribe_mediaid(
        meta = MetaInfo(title)
        if season:
            meta.begin_season = season
-        result = await Subscribe.async_get_by_title(db, title=meta.name, season=meta.begin_season)
+        result = Subscribe.get_by_title(db, title=meta.name, season=meta.begin_season)
+    if result and result.sites:
+        try:
+            result.sites = json.loads(result.sites)
+        except json.JSONDecodeError:
+            result.sites = []

    return result if result else Subscribe()

@@ -217,30 +190,18 @@ def refresh_subscribes(


@router.get("/reset/{subid}", summary="重置订阅", response_model=schemas.Response)
-async def reset_subscribes(
+def reset_subscribes(
        subid: int,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    重置订阅
    """
-    subscribe = await Subscribe.async_get(db, subid)
+    subscribe = Subscribe.get(db, subid)
    if subscribe:
-        # 在更新之前获取旧数据
-        old_subscribe_dict = subscribe.to_dict()
-        # 更新订阅
-        await subscribe.async_update(db, {
-            "note": [],
-            "lack_episode": subscribe.total_episode,
-            "state": "R"
-        })
-        # 重新获取更新后的订阅数据
-        updated_subscribe = await Subscribe.async_get(db, subid)
-        # 发送订阅调整事件
-        await eventmanager.async_send_event(EventType.SubscribeModified, {
-            "subscribe_id": subid,
-            "old_subscribe_info": old_subscribe_dict,
-            "subscribe_info": updated_subscribe.to_dict() if updated_subscribe else {},
+        subscribe.update(db, {
+            "note": "",
+            "lack_episode": subscribe.total_episode
        })
        return schemas.Response(success=True)
    return schemas.Response(success=False, message="订阅不存在")
@@ -257,7 +218,7 @@ def check_subscribes(


@router.get("/search", summary="搜索所有订阅", response_model=schemas.Response)
-async def search_subscribes(
+def search_subscribes(
        background_tasks: BackgroundTasks,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
@@ -276,7 +237,7 @@ async def search_subscribes(


@router.get("/search/{subscribe_id}", summary="搜索订阅", response_model=schemas.Response)
-async def search_subscribe(
+def search_subscribe(
        subscribe_id: int,
        background_tasks: BackgroundTasks,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
@@ -296,49 +257,32 @@ async def search_subscribe(


@router.delete("/media/{mediaid}", summary="删除订阅", response_model=schemas.Response)
-async def delete_subscribe_by_mediaid(
+def delete_subscribe_by_mediaid(
        mediaid: str,
-        season: Optional[int] = None,
-        db: AsyncSession = Depends(get_async_db),
+        season: int = None,
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    根据TMDBID或豆瓣ID删除订阅 tmdb:/douban:
    """
-    delete_subscribes = []
    if mediaid.startswith("tmdb:"):
        tmdbid = mediaid[5:]
        if not tmdbid or not str(tmdbid).isdigit():
            return schemas.Response(success=False)
-        subscribes = await Subscribe.async_get_by_tmdbid(db, int(tmdbid), season)
-        delete_subscribes.extend(subscribes)
+        Subscribe().delete_by_tmdbid(db, int(tmdbid), season)
    elif mediaid.startswith("douban:"):
        doubanid = mediaid[7:]
        if not doubanid:
            return schemas.Response(success=False)
-        subscribe = await Subscribe.async_get_by_doubanid(db, doubanid)
-        if subscribe:
-            delete_subscribes.append(subscribe)
-    else:
-        subscribe = await Subscribe.async_get_by_mediaid(db, mediaid)
-        if subscribe:
-            delete_subscribes.append(subscribe)
-    for subscribe in delete_subscribes:
-        # 在删除之前获取订阅信息
-        subscribe_info = subscribe.to_dict()
-        subscribe_id = subscribe.id
-        await Subscribe.async_delete(db, subscribe_id)
-        # 发送事件
-        await eventmanager.async_send_event(EventType.SubscribeDeleted, {
-            "subscribe_id": subscribe_id,
-            "subscribe_info": subscribe_info
-        })
+        Subscribe().delete_by_doubanid(db, doubanid)
+
    return schemas.Response(success=True)


@router.post("/seerr", summary="OverSeerr/JellySeerr通知订阅", response_model=schemas.Response)
 async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
-                          authorization: Annotated[str | None, Header()] = None) -> Any:
+                          authorization: str = Header(None)) -> Any:
    """
    Jellyseerr/Overseerr网络勾子通知订阅
    """
@@ -390,54 +334,49 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,


@router.get("/history/{mtype}", summary="查询订阅历史", response_model=List[schemas.Subscribe])
-async def subscribe_history(
+def read_subscribe(
        mtype: str,
-        page: Optional[int] = 1,
-        count: Optional[int] = 30,
-        db: AsyncSession = Depends(get_async_db),
+        page: int = 1,
+        count: int = 30,
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询电影/电视剧订阅历史
    """
-    return await SubscribeHistory.async_list_by_type(db, mtype=mtype, page=page, count=count)
+    historys = SubscribeHistory.list_by_type(db, mtype=mtype, page=page, count=count)
+    for history in historys:
+        if history and history.sites:
+            try:
+                history.sites = json.loads(history.sites)
+            except json.JSONDecodeError:
+                history.sites = []
+    return historys


@router.delete("/history/{history_id}", summary="删除订阅历史", response_model=schemas.Response)
-async def delete_subscribe(
+def delete_subscribe(
        history_id: int,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    删除订阅历史
    """
-    await SubscribeHistory.async_delete(db, history_id)
+    SubscribeHistory.delete(db, history_id)
    return schemas.Response(success=True)


@router.get("/popular", summary="热门订阅（基于用户共享数据）", response_model=List[schemas.MediaInfo])
-async def popular_subscribes(
+def popular_subscribes(
        stype: str,
-        page: Optional[int] = 1,
-        count: Optional[int] = 30,
-        min_sub: Optional[int] = None,
-        genre_id: Optional[int] = None,
-        min_rating: Optional[float] = None,
-        max_rating: Optional[float] = None,
-        sort_type: Optional[str] = None,
+        page: int = 1,
+        count: int = 30,
+        min_sub: int = None,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    查询热门订阅
    """
-    subscribes = await SubscribeHelper().async_get_statistic(
-        stype=stype,
-        page=page,
-        count=count,
-        genre_id=genre_id,
-        min_rating=min_rating,
-        max_rating=max_rating,
-        sort_type=sort_type
-    )
+    subscribes = SubscribeHelper().get_statistic(stype=stype, page=page, count=count)
    if subscribes:
        ret_medias = []
        for sub in subscribes:
@@ -472,179 +411,40 @@ async def popular_subscribes(
    return []


-@router.get("/user/{username}", summary="用户订阅", response_model=List[schemas.Subscribe])
-async def user_subscribes(
-        username: str,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询用户订阅
-    """
-    return await Subscribe.async_list_by_username(db, username)
-
-
-@router.get("/files/{subscribe_id}", summary="订阅相关文件信息", response_model=schemas.SubscrbieInfo)
-def subscribe_files(
+@router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
+def read_subscribe(
        subscribe_id: int,
        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    订阅相关文件信息
-    """
-    subscribe = Subscribe.get(db, subscribe_id)
-    if subscribe:
-        return SubscribeChain().subscribe_files_info(subscribe)
-    return schemas.SubscrbieInfo()
-
-
-@router.post("/share", summary="分享订阅", response_model=schemas.Response)
-async def subscribe_share(
-        sub: schemas.SubscribeShare,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    分享订阅
-    """
-    state, errmsg = await SubscribeHelper().async_sub_share(subscribe_id=sub.subscribe_id,
-                                                            share_title=sub.share_title,
-                                                            share_comment=sub.share_comment,
-                                                            share_user=sub.share_user)
-    return schemas.Response(success=state, message=errmsg)
-
-
-@router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
-async def subscribe_share_delete(
-        share_id: int,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    删除分享
-    """
-    state, errmsg = await SubscribeHelper().async_share_delete(share_id=share_id)
-    return schemas.Response(success=state, message=errmsg)
-
-
-@router.post("/fork", summary="复用订阅", response_model=schemas.Response)
-async def subscribe_fork(
-        sub: schemas.SubscribeShare,
-        current_user: User = Depends(get_current_active_user_async)) -> Any:
-    """
-    复用订阅
-    """
-    sub_dict = sub.model_dump()
-    sub_dict.pop("id")
-    for key in list(sub_dict.keys()):
-        if not hasattr(schemas.Subscribe(), key):
-            sub_dict.pop(key)
-    result = await create_subscribe(subscribe_in=schemas.Subscribe(**sub_dict),
-                                    current_user=current_user)
-    if result.success:
-        await SubscribeHelper().async_sub_fork(share_id=sub.id)
-    return result
-
-
-@router.get("/follow", summary="查询已Follow的订阅分享人", response_model=List[str])
-async def followed_subscribers(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询已Follow的订阅分享人
-    """
-    return SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
-
-
-@router.post("/follow", summary="Follow订阅分享人", response_model=schemas.Response)
-async def follow_subscriber(
-        share_uid: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    Follow订阅分享人
-    """
-    subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
-    if share_uid and share_uid not in subscribers:
-        subscribers.append(share_uid)
-        await SystemConfigOper().async_set(SystemConfigKey.FollowSubscribers, subscribers)
-    return schemas.Response(success=True)
-
-
-@router.delete("/follow", summary="取消Follow订阅分享人", response_model=schemas.Response)
-async def unfollow_subscriber(
-        share_uid: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    取消Follow订阅分享人
-    """
-    subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
-    if share_uid and share_uid in subscribers:
-        subscribers.remove(share_uid)
-        await SystemConfigOper().async_set(SystemConfigKey.FollowSubscribers, subscribers)
-    return schemas.Response(success=True)
-
-
-@router.get("/shares", summary="查询分享的订阅", response_model=List[schemas.SubscribeShare])
-async def popular_subscribes(
-        name: Optional[str] = None,
-        page: Optional[int] = 1,
-        count: Optional[int] = 30,
-        genre_id: Optional[int] = None,
-        min_rating: Optional[float] = None,
-        max_rating: Optional[float] = None,
-        sort_type: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询分享的订阅
-    """
-    return await SubscribeHelper().async_get_shares(
-        name=name,
-        page=page,
-        count=count,
-        genre_id=genre_id,
-        min_rating=min_rating,
-        max_rating=max_rating,
-        sort_type=sort_type
-    )
-
-
-@router.get("/share/statistics", summary="查询订阅分享统计", response_model=List[schemas.SubscribeShareStatistics])
-async def subscribe_share_statistics(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询订阅分享统计
-    返回每个分享人分享的媒体数量以及总的复用人次
-    """
-    return await SubscribeHelper().async_get_share_statistics()
-
-
-@router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
-async def read_subscribe(
-        subscribe_id: int,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
    根据订阅编号查询订阅信息
    """
    if not subscribe_id:
        return Subscribe()
-    return await Subscribe.async_get(db, subscribe_id)
+    subscribe = Subscribe.get(db, subscribe_id)
+    if subscribe and subscribe.sites:
+        try:
+            subscribe.sites = json.loads(subscribe.sites)
+        except json.JSONDecodeError:
+            subscribe.sites = []
+    return subscribe


@router.delete("/{subscribe_id}", summary="删除订阅", response_model=schemas.Response)
-async def delete_subscribe(
+def delete_subscribe(
        subscribe_id: int,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
    """
    删除订阅信息
    """
-    subscribe = await Subscribe.async_get(db, subscribe_id)
+    subscribe = Subscribe.get(db, subscribe_id)
    if subscribe:
-        # 在删除之前获取订阅信息
-        subscribe_info = subscribe.to_dict()
-        await Subscribe.async_delete(db, subscribe_id)
-        # 发送事件
-        await eventmanager.async_send_event(EventType.SubscribeDeleted, {
-            "subscribe_id": subscribe_id,
-            "subscribe_info": subscribe_info
-        })
-        # 统计订阅
-        SubscribeHelper().sub_done_async({
-            "tmdbid": subscribe.tmdbid,
-            "doubanid": subscribe.doubanid
-        })
+        subscribe.delete(db, subscribe_id)
+    # 统计订阅
+    SubscribeHelper().sub_done_async({
+        "tmdbid": subscribe.tmdbid,
+        "doubanid": subscribe.doubanid
+    })
    return schemas.Response(success=True)
--- a/app/api/endpoints/system.py
+++ b/app/api/endpoints/system.py
@@ -1,163 +1,57 @@
-import asyncio
 import json
-import re
-from collections import deque
+import time
 from datetime import datetime
-from typing import Optional, Union, Annotated
+from typing import Union, Any

-import aiofiles
-import pillow_avif  # noqa 用于自动注册AVIF支持
-from anyio import Path as AsyncPath
-from app.helper.sites import SitesHelper  # noqa  # noqa
-from fastapi import APIRouter, Body, Depends, HTTPException, Header, Request, Response
+import tailer
+from dotenv import set_key
+from fastapi import APIRouter, HTTPException, Depends, Response
 from fastapi.responses import StreamingResponse

 from app import schemas
-from app.chain.mediaserver import MediaServerChain
 from app.chain.search import SearchChain
 from app.chain.system import SystemChain
-from app.core.config import global_vars, settings
-from app.core.event import eventmanager
-from app.core.metainfo import MetaInfo
+from app.core.config import settings, global_vars
 from app.core.module import ModuleManager
-from app.core.security import verify_apitoken, verify_resource_token, verify_token
+from app.core.security import verify_token
 from app.db.models import User
 from app.db.systemconfig_oper import SystemConfigOper
-from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async, \
-    get_current_active_user_async
-from app.helper.llm import LLMHelper
-from app.helper.mediaserver import MediaServerHelper
+from app.db.userauth import get_current_active_superuser
 from app.helper.message import MessageHelper
 from app.helper.progress import ProgressHelper
-from app.helper.rule import RuleHelper
-from app.helper.subscribe import SubscribeHelper
-from app.helper.system import SystemHelper
-from app.helper.image import ImageHelper
-from app.log import logger
+from app.helper.sites import SitesHelper
 from app.scheduler import Scheduler
-from app.schemas import ConfigChangeEventData
-from app.schemas.types import SystemConfigKey, EventType
-from app.utils.crypto import HashUtils
-from app.utils.http import RequestUtils, AsyncRequestUtils
-from app.utils.security import SecurityUtils
-from app.utils.url import UrlUtils
+from app.schemas.types import SystemConfigKey
+from app.utils.http import RequestUtils
+from app.utils.system import SystemUtils
 from version import APP_VERSION

 router = APIRouter()


-async def fetch_image(
-        url: str,
-        proxy: Optional[bool] = None,
-        use_cache: bool = False,
-        if_none_match: Optional[str] = None,
-        cookies: Optional[str | dict] = None,
-        allowed_domains: Optional[set[str]] = None) -> Optional[Response]:
-    """
-    处理图片缓存逻辑，支持HTTP缓存和磁盘缓存
-    """
-    if not url:
-        return None
-
-    if allowed_domains is None:
-        allowed_domains = set(settings.SECURITY_IMAGE_DOMAINS)
-
-    # 验证URL安全性
-    if not SecurityUtils.is_safe_url(url, allowed_domains):
-        logger.warn(f"Blocked unsafe image URL: {url}")
-        return None
-
-    content = await ImageHelper().async_fetch_image(
-        url=url,
-        proxy=proxy,
-        use_cache=use_cache,
-        cookies=cookies,
-    )
-    if content:
-        # 检查 If-None-Match
-        etag = HashUtils.md5(content)
-        headers = RequestUtils.generate_cache_headers(etag, max_age=86400 * 7)
-        if if_none_match == etag:
-            return Response(status_code=304, headers=headers)
-        # 返回缓存图片
-        return Response(
-            content=content,
-            media_type=UrlUtils.get_mime_type(url, "image/jpeg"),
-            headers=headers
-        )
-
-
@router.get("/img/{proxy}", summary="图片代理")
-async def proxy_img(
-        imgurl: str,
-        proxy: bool = False,
-        cache: bool = False,
-        use_cookies: bool = False,
-        if_none_match: Annotated[str | None, Header()] = None,
-        _: schemas.TokenPayload = Depends(verify_resource_token)
-) -> Response:
+def get_img(imgurl: str, proxy: bool = False) -> Any:
    """
-    图片代理，可选是否使用代理服务器，支持 HTTP 缓存
+    通过图片代理（使用代理服务器）
    """
-    # 媒体服务器添加图片代理支持
-    hosts = [config.config.get("host") for config in MediaServerHelper().get_configs().values() if
-             config and config.config and config.config.get("host")]
-    allowed_domains = set(settings.SECURITY_IMAGE_DOMAINS) | set(hosts)
-    cookies = (
-        MediaServerChain().get_image_cookies(server=None, image_url=imgurl)
-        if use_cookies
-        else None
-    )
-    return await fetch_image(url=imgurl, proxy=proxy, use_cache=cache, cookies=cookies,
-                             if_none_match=if_none_match, allowed_domains=allowed_domains)
+    if not imgurl:
+        return None
+    if proxy:
+        response = RequestUtils(ua=settings.USER_AGENT, proxies=settings.PROXY).get_res(url=imgurl)
+    else:
+        response = RequestUtils(ua=settings.USER_AGENT).get_res(url=imgurl)
+    if response:
+        return Response(content=response.content, media_type="image/jpeg")
+    return None


-@router.get("/cache/image", summary="图片缓存")
-async def cache_img(
-        url: str,
-        if_none_match: Annotated[str | None, Header()] = None,
-        _: schemas.TokenPayload = Depends(verify_resource_token)
-) -> Response:
+@router.get("/env", summary="查询系统环境变量", response_model=schemas.Response)
+def get_env_setting(_: User = Depends(get_current_active_superuser)):
    """
-    本地缓存图片文件，支持 HTTP 缓存，如果启用全局图片缓存，则使用磁盘缓存
+    查询系统环境变量，包括当前版本号
    """
-    # 如果没有启用全局图片缓存，则不使用磁盘缓存
-    return await fetch_image(url=url, use_cache=settings.GLOBAL_IMAGE_CACHE,
-                             if_none_match=if_none_match)
-
-
-@router.get("/global", summary="查询非敏感系统设置", response_model=schemas.Response)
-def get_global_setting(token: str):
-    """
-    查询非敏感系统设置（默认鉴权）
-    """
-    if token != "moviepilot":
-        raise HTTPException(status_code=403, detail="Forbidden")
-
-    # FIXME: 新增敏感配置项时要在此处添加排除项
-    info = settings.model_dump(
-        exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY", "API_TOKEN", "TMDB_API_KEY", "TVDB_API_KEY", "FANART_API_KEY",
-                 "COOKIECLOUD_KEY", "COOKIECLOUD_PASSWORD", "GITHUB_TOKEN", "REPO_GITHUB_TOKEN", "U115_APP_ID",
-                 "ALIPAN_APP_ID", "TVDB_V4_API_KEY", "TVDB_V4_API_PIN"}
-    )
-    # 追加用户唯一ID和订阅分享管理权限
-    share_admin = SubscribeHelper().is_admin_user()
-    info.update({
-        "USER_UNIQUE_ID": SubscribeHelper().get_user_uuid(),
-        "SUBSCRIBE_SHARE_MANAGE": share_admin,
-        "WORKFLOW_SHARE_MANAGE": share_admin
-    })
-    return schemas.Response(success=True,
-                            data=info)
-
-
-@router.get("/env", summary="查询系统配置", response_model=schemas.Response)
-async def get_env_setting(_: User = Depends(get_current_active_user_async)):
-    """
-    查询系统环境变量，包括当前版本号（仅管理员）
-    """
-    info = settings.model_dump(
-        exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY"}
+    info = settings.dict(
+        exclude={"SECRET_KEY", "SUPERUSER_PASSWORD"}
    )
    info.update({
        "VERSION": APP_VERSION,
@@ -169,69 +63,56 @@ async def get_env_setting(_: User = Depends(get_current_active_user_async)):
                            data=info)


-@router.post("/env", summary="更新系统配置", response_model=schemas.Response)
-async def set_env_setting(env: dict,
-                          _: User = Depends(get_current_active_superuser_async)):
+@router.post("/env", summary="更新系统环境变量", response_model=schemas.Response)
+def set_env_setting(env: dict,
+                    _: User = Depends(get_current_active_superuser)):
    """
-    更新系统环境变量（仅管理员）
+    更新系统环境变量
    """
-    result = settings.update_settings(env=env)
-    # 统计成功和失败的结果
-    success_updates = {k: v for k, v in result.items() if v[0]}
-    failed_updates = {k: v for k, v in result.items() if v[0] is False}
-
-    if failed_updates:
-        return schemas.Response(
-            success=False,
-            message=f"{', '.join([v[1] for v in failed_updates.values()])}",
-            data={
-                "success_updates": success_updates,
-                "failed_updates": failed_updates
-            }
-        )
-
-    if success_updates:
-        # 发送配置变更事件
-        await eventmanager.async_send_event(etype=EventType.ConfigChanged, data=ConfigChangeEventData(
-            key=success_updates.keys(),
-            change_type="update"
-        ))
-
-    return schemas.Response(
-        success=True,
-        message="所有配置项更新成功",
-        data={
-            "success_updates": success_updates
-        }
-    )
+    for k, v in env.items():
+        if k == "undefined":
+            continue
+        if hasattr(settings, k):
+            if v == "None":
+                v = None
+            setattr(settings, k, v)
+            if v is None:
+                v = ''
+            else:
+                v = str(v)
+            set_key(settings.CONFIG_PATH / "app.env", k, v)
+    return schemas.Response(success=True)


@router.get("/progress/{process_type}", summary="实时进度")
-async def get_progress(request: Request, process_type: str, _: schemas.TokenPayload = Depends(verify_resource_token)):
+def get_progress(process_type: str, token: str):
    """
    实时获取处理进度，返回格式为SSE
    """
-    progress = ProgressHelper(process_type)
+    if not token or not verify_token(token):
+        raise HTTPException(
+            status_code=403,
+            detail="认证失败！",
+        )

-    async def event_generator():
-        try:
-            while not global_vars.is_system_stopped:
-                if await request.is_disconnected():
-                    break
-                detail = progress.get()
-                yield f"data: {json.dumps(detail)}\n\n"
-                await asyncio.sleep(0.5)
-        except asyncio.CancelledError:
-            return
+    progress = ProgressHelper()
+
+    def event_generator():
+        while True:
+            if global_vars.is_system_stopped():
+                break
+            detail = progress.get(process_type)
+            yield 'data: %s\n\n' % json.dumps(detail)
+            time.sleep(0.2)

    return StreamingResponse(event_generator(), media_type="text/event-stream")


@router.get("/setting/{key}", summary="查询系统设置", response_model=schemas.Response)
-async def get_setting(key: str,
-                      _: User = Depends(get_current_active_user_async)):
+def get_setting(key: str,
+                _: User = Depends(get_current_active_superuser)):
    """
-    查询系统设置（仅管理员）
+    查询系统设置
    """
    if hasattr(settings, key):
        value = getattr(settings, key)
@@ -243,185 +124,97 @@ async def get_setting(key: str,


@router.post("/setting/{key}", summary="更新系统设置", response_model=schemas.Response)
-async def set_setting(
-        key: str,
-        value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
-        _: User = Depends(get_current_active_superuser_async),
-):
+def set_setting(key: str, value: Union[list, dict, bool, int, str] = None,
+                _: User = Depends(get_current_active_superuser)):
    """
-    更新系统设置（仅管理员）
+    更新系统设置
    """
    if hasattr(settings, key):
-        success, message = settings.update_setting(key=key, value=value)
-        if success:
-            # 发送配置变更事件
-            await eventmanager.async_send_event(etype=EventType.ConfigChanged, data=ConfigChangeEventData(
-                key=key,
-                value=value,
-                change_type="update"
-            ))
-        elif success is None:
-            success = True
-        return schemas.Response(success=success, message=message)
-    elif key in {item.value for item in SystemConfigKey}:
-        if isinstance(value, list):
-            value = list(filter(None, value))
-            value = value if value else None
-        success = await SystemConfigOper().async_set(key, value)
-        if success:
-            # 发送配置变更事件
-            await eventmanager.async_send_event(etype=EventType.ConfigChanged, data=ConfigChangeEventData(
-                key=key,
-                value=value,
-                change_type="update"
-            ))
-        return schemas.Response(success=True)
+        if value == "None":
+            value = None
+        setattr(settings, key, value)
+        if value is None:
+            value = ''
+        else:
+            value = str(value)
+        set_key(settings.CONFIG_PATH / "app.env", key, value)
    else:
-        return schemas.Response(success=False, message=f"配置项 '{key}' 不存在")
-
-
-@router.get("/llm-models", summary="获取LLM模型列表", response_model=schemas.Response)
-async def get_llm_models(provider: str, api_key: str, base_url: Optional[str] = None, _: User = Depends(get_current_active_user_async)):
-    """
-    获取LLM模型列表
-    """
-    try:
-        models = LLMHelper().get_models(provider, api_key, base_url)
-        return schemas.Response(success=True, data=models)
-    except Exception as e:
-        return schemas.Response(success=False, message=str(e))
+        SystemConfigOper().set(key, value)
+    return schemas.Response(success=True)


@router.get("/message", summary="实时消息")
-async def get_message(request: Request, role: Optional[str] = "system",
-                      _: schemas.TokenPayload = Depends(verify_resource_token)):
+def get_message(token: str, role: str = "system"):
    """
    实时获取系统消息，返回格式为SSE
    """
+    if not token or not verify_token(token):
+        raise HTTPException(
+            status_code=403,
+            detail="认证失败！",
+        )
+
    message = MessageHelper()

-    async def event_generator():
-        try:
-            while not global_vars.is_system_stopped:
-                if await request.is_disconnected():
-                    break
-                detail = message.get(role)
-                yield f"data: {detail or ''}\n\n"
-                await asyncio.sleep(3)
-        except asyncio.CancelledError:
-            return
+    def event_generator():
+        while True:
+            if global_vars.is_system_stopped():
+                break
+            detail = message.get(role)
+            yield 'data: %s\n\n' % (detail or '')
+            time.sleep(3)

    return StreamingResponse(event_generator(), media_type="text/event-stream")


@router.get("/logging", summary="实时日志")
-async def get_logging(request: Request, length: Optional[int] = 50, logfile: Optional[str] = "moviepilot.log",
-                      _: schemas.TokenPayload = Depends(verify_resource_token)):
+def get_logging(token: str, length: int = 50, logfile: str = "moviepilot.log"):
    """
    实时获取系统日志
    length = -1 时, 返回text/plain
    否则 返回格式SSE
    """
-    base_path = AsyncPath(settings.LOG_PATH)
-    log_path = base_path / logfile
+    if not token or not verify_token(token):
+        raise HTTPException(
+            status_code=403,
+            detail="认证失败！",
+        )

-    if not await SecurityUtils.async_is_safe_path(base_path=base_path, user_path=log_path, allowed_suffixes={".log"}):
-        raise HTTPException(status_code=404, detail="Not Found")
+    log_path = settings.LOG_PATH / logfile

-    if not await log_path.exists() or not await log_path.is_file():
-        raise HTTPException(status_code=404, detail="Not Found")
-
-    async def log_generator():
-        try:
-            # 使用固定大小的双向队列来限制内存使用
-            lines_queue = deque(maxlen=max(length, 50))
-            # 获取文件大小
-            file_stat = await log_path.stat()
-            file_size = file_stat.st_size
-
-            # 读取历史日志
-            async with aiofiles.open(log_path, mode="r", encoding="utf-8", errors="ignore") as f:
-                # 优化大文件读取策略
-                if file_size > 100 * 1024:
-                    # 只读取最后100KB的内容
-                    bytes_to_read = min(file_size, 100 * 1024)
-                    position = file_size - bytes_to_read
-                    await f.seek(position)
-                    content = await f.read()
-                    # 找到第一个完整的行
-                    first_newline = content.find('\n')
-                    if first_newline != -1:
-                        content = content[first_newline + 1:]
-                else:
-                    # 小文件直接读取全部内容
-                    content = await f.read()
-
-                # 按行分割并添加到队列，只保留非空行
-                lines = [line.strip() for line in content.splitlines() if line.strip()]
-                # 只取最后N行
-                for line in lines[-max(length, 50):]:
-                    lines_queue.append(line)
-
-            # 输出历史日志
-            for line in lines_queue:
-                yield f"data: {line}\n\n"
-
-            # 实时监听新日志
-            async with aiofiles.open(log_path, mode="r", encoding="utf-8", errors="ignore") as f:
-                # 移动文件指针到文件末尾，继续监听新增内容
-                await f.seek(0, 2)
-                # 记录初始文件大小
-                initial_stat = await log_path.stat()
-                initial_size = initial_stat.st_size
-                # 实时监听新日志，使用更短的轮询间隔
-                while not global_vars.is_system_stopped:
-                    if await request.is_disconnected():
-                        break
-                    # 检查文件是否有新内容
-                    current_stat = await log_path.stat()
-                    current_size = current_stat.st_size
-                    if current_size > initial_size:
-                        # 文件有新内容，读取新行
-                        line = await f.readline()
-                        if line:
-                            line = line.strip()
-                            if line:
-                                yield f"data: {line}\n\n"
-                        initial_size = current_size
-                    else:
-                        # 没有新内容，短暂等待
-                        await asyncio.sleep(0.5)
-        except asyncio.CancelledError:
-            return
-        except Exception as err:
-            logger.error(f"日志读取异常: {err}")
-            yield f"data: 日志读取异常: {err}\n\n"
+    def log_generator():
+        # 读取文件末尾50行，不使用tailer模块
+        with open(log_path, 'r', encoding='utf-8') as f:
+            for line in f.readlines()[-max(length, 50):]:
+                yield 'data: %s\n\n' % line
+        while True:
+            if global_vars.is_system_stopped():
+                break
+            for t in tailer.follow(open(log_path, 'r', encoding='utf-8')):
+                yield 'data: %s\n\n' % (t or '')
+            time.sleep(1)

    # 根据length参数返回不同的响应
    if length == -1:
        # 返回全部日志作为文本响应
-        if not await log_path.exists():
+        if not log_path.exists():
            return Response(content="日志文件不存在！", media_type="text/plain")
-        try:
-            # 使用 aiofiles 异步读取文件
-            async with aiofiles.open(log_path, mode="r", encoding="utf-8", errors="ignore") as file:
-                text = await file.read()
-            # 倒序输出
-            text = "\n".join(text.split("\n")[::-1])
-            return Response(content=text, media_type="text/plain")
-        except Exception as e:
-            return Response(content=f"读取日志文件失败: {e}", media_type="text/plain")
+        with open(log_path, 'r', encoding='utf-8') as file:
+            text = file.read()
+        # 倒序输出
+        text = '\n'.join(text.split('\n')[::-1])
+        return Response(content=text, media_type="text/plain")
    else:
        # 返回SSE流响应
        return StreamingResponse(log_generator(), media_type="text/event-stream")


@router.get("/versions", summary="查询Github所有Release版本", response_model=schemas.Response)
-async def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
+def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
    """
    查询Github所有Release版本
    """
-    version_res = await AsyncRequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS).get_res(
+    version_res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS).get_res(
        f"https://api.github.com/repos/jxxghp/MoviePilot/releases")
    if version_res:
        ver_json = version_res.json()
@@ -430,10 +223,10 @@ async def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
    return schemas.Response(success=False)


-@router.get("/ruletest", summary="过滤规则测试", response_model=schemas.Response)
+@router.get("/ruletest", summary="优先级规则测试", response_model=schemas.Response)
 def ruletest(title: str,
-             rulegroup_name: str,
-             subtitle: Optional[str] = None,
+             subtitle: str = None,
+             ruletype: str = None,
             _: schemas.TokenPayload = Depends(verify_token)):
    """
    过滤规则测试，规则类型 1-订阅，2-洗版，3-搜索
@@ -442,101 +235,50 @@ def ruletest(title: str,
        title=title,
        description=subtitle,
    )
-    # 查询规则组详情
-    rulegroup = RuleHelper().get_rule_group(rulegroup_name)
-    if not rulegroup:
-        return schemas.Response(success=False, message=f"过滤规则组 {rulegroup_name} 不存在！")
-
-    # 根据标题查询媒体信息
-    media_info = SearchChain().recognize_media(MetaInfo(title=title, subtitle=subtitle))
-    if not media_info:
-        return schemas.Response(success=False, message="未识别到媒体信息！")
+    if ruletype == "2":
+        rule_string = SystemConfigOper().get(SystemConfigKey.BestVersionFilterRules)
+    elif ruletype == "3":
+        rule_string = SystemConfigOper().get(SystemConfigKey.SearchFilterRules)
+    else:
+        rule_string = SystemConfigOper().get(SystemConfigKey.SubscribeFilterRules)
+    if not rule_string:
+        return schemas.Response(success=False, message="优先级规则未设置！")

    # 过滤
-    result = SearchChain().filter_torrents(rule_groups=[rulegroup.name],
-                                           torrent_list=[torrent], mediainfo=media_info)
+    result = SearchChain().filter_torrents(rule_string=rule_string,
+                                           torrent_list=[torrent])
    if not result:
-        return schemas.Response(success=False, message="不符合过滤规则！")
+        return schemas.Response(success=False, message="不符合优先级规则！")
    return schemas.Response(success=True, data={
        "priority": 100 - result[0].pri_order + 1
    })


@router.get("/nettest", summary="测试网络连通性")
-async def nettest(
-        url: str,
-        proxy: bool,
-        include: Optional[str] = None,
-        _: schemas.TokenPayload = Depends(verify_token),
-):
+def nettest(url: str,
+            proxy: bool,
+            _: schemas.TokenPayload = Depends(verify_token)):
    """
    测试网络连通性
    """
    # 记录开始的毫秒数
    start_time = datetime.now()
-    headers = None
-    # 当前使用的加速代理
-    proxy_name = ""
-    if "github" in url:
-        # 这是github的连通性测试
-        headers = settings.GITHUB_HEADERS
-    if "{GITHUB_PROXY}" in url:
-        url = url.replace(
-            "{GITHUB_PROXY}", UrlUtils.standardize_base_url(settings.GITHUB_PROXY or "")
-        )
-        if settings.GITHUB_PROXY:
-            proxy_name = "Github加速代理"
-    if "{PIP_PROXY}" in url:
-        url = url.replace(
-            "{PIP_PROXY}",
-            UrlUtils.standardize_base_url(
-                settings.PIP_PROXY or "https://pypi.org/simple/"
-            ),
-        )
-        if settings.PIP_PROXY:
-            proxy_name = "PIP加速代理"
    url = url.replace("{TMDBAPIKEY}", settings.TMDB_API_KEY)
-    result = await AsyncRequestUtils(
-        proxies=settings.PROXY if proxy else None,
-        headers=headers,
-        timeout=10,
-        ua=settings.NORMAL_USER_AGENT,
-    ).get_res(url)
+    result = RequestUtils(proxies=settings.PROXY if proxy else None,
+                          ua=settings.USER_AGENT).get_res(url)
    # 计时结束的毫秒数
    end_time = datetime.now()
-    time = round((end_time - start_time).total_seconds() * 1000)
    # 计算相关秒数
-    if result is None:
-        return schemas.Response(
-            success=False, message=f"{proxy_name}无法连接", 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}")
-            if proxy_name:
-                message = f"{proxy_name}已失效，请检查配置"
-            else:
-                message = f"无效响应，不匹配 {include}"
-            return schemas.Response(
-                success=False,
-                message=message,
-                data={"time": time},
-            )
-        return schemas.Response(success=True, data={"time": time})
+    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)
+        })
    else:
-        if proxy_name:
-            # 加速代理失败
-            message = f"{proxy_name}已失效，错误码：{result.status_code}"
-        else:
-            message = f"错误码：{result.status_code}"
-            if "github" in url:
-                # 非加速代理访问github
-                if result.status_code == 401:
-                    message = "Github Token已失效，请检查配置"
-                elif result.status_code in {403, 429}:
-                    message = "触发限流，请配置Github Token"
-        return schemas.Response(success=False, message=message, data={"time": time})
+        return schemas.Response(success=False, message="网络连接失败！")


@router.get("/modulelist", summary="查询已加载的模块ID列表", response_model=schemas.Response)
@@ -565,37 +307,34 @@ def moduletest(moduleid: str, _: schemas.TokenPayload = Depends(verify_token)):
@router.get("/restart", summary="重启系统", response_model=schemas.Response)
 def restart_system(_: User = Depends(get_current_active_superuser)):
    """
-    重启系统（仅管理员）
+    重启系统
    """
-    if not SystemHelper.can_restart():
+    if not SystemUtils.can_restart():
        return schemas.Response(success=False, message="当前运行环境不支持重启操作！")
    # 标识停止事件
    global_vars.stop_system()
    # 执行重启
-    ret, msg = SystemHelper.restart()
+    ret, msg = SystemUtils.restart()
    return schemas.Response(success=ret, message=msg)


+@router.get("/reload", summary="重新加载模块", response_model=schemas.Response)
+def reload_module(_: User = Depends(get_current_active_superuser)):
+    """
+    重新加载模块
+    """
+    ModuleManager().reload()
+    Scheduler().init()
+    return schemas.Response(success=True)
+
+
@router.get("/runscheduler", summary="运行服务", response_model=schemas.Response)
-def run_scheduler(jobid: str,
-                  _: User = Depends(get_current_active_superuser)):
+def execute_command(jobid: str,
+                    _: User = Depends(get_current_active_superuser)):
    """
-    执行命令（仅管理员）
+    执行命令
    """
    if not jobid:
        return schemas.Response(success=False, message="命令不能为空！")
    Scheduler().start(jobid)
    return schemas.Response(success=True)
-
-
-@router.get("/runscheduler2", summary="运行服务（API_TOKEN）", response_model=schemas.Response)
-def run_scheduler2(jobid: str,
-                   _: Annotated[str, Depends(verify_apitoken)]):
-    """
-    执行命令（API_TOKEN认证）
-    """
-    if not jobid:
-        return schemas.Response(success=False, message="命令不能为空！")
-
-    Scheduler().start(jobid)
-    return schemas.Response(success=True)
--- a/app/api/endpoints/tmdb.py
+++ b/app/api/endpoints/tmdb.py
@@ -1,4 +1,4 @@
-from typing import List, Any, Optional
+from typing import List, Any

 from fastapi import APIRouter, Depends

@@ -11,28 +11,28 @@ router = APIRouter()


@router.get("/seasons/{tmdbid}", summary="TMDB所有季", response_model=List[schemas.TmdbSeason])
-async def tmdb_seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID查询themoviedb所有季信息
    """
-    seasons_info = await TmdbChain().async_tmdb_seasons(tmdbid=tmdbid)
+    seasons_info = TmdbChain().tmdb_seasons(tmdbid=tmdbid)
    if seasons_info:
        return seasons_info
    return []


@router.get("/similar/{tmdbid}/{type_name}", summary="类似电影/电视剧", response_model=List[schemas.MediaInfo])
-async def tmdb_similar(tmdbid: int,
-                       type_name: str,
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_similar(tmdbid: int,
+                 type_name: str,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID查询类似电影/电视剧，type_name: 电影/电视剧
    """
    mediatype = MediaType(type_name)
    if mediatype == MediaType.MOVIE:
-        medias = await TmdbChain().async_movie_similar(tmdbid=tmdbid)
+        medias = TmdbChain().movie_similar(tmdbid=tmdbid)
    elif mediatype == MediaType.TV:
-        medias = await TmdbChain().async_tv_similar(tmdbid=tmdbid)
+        medias = TmdbChain().tv_similar(tmdbid=tmdbid)
    else:
        return []
    if medias:
@@ -41,17 +41,17 @@ async def tmdb_similar(tmdbid: int,


@router.get("/recommend/{tmdbid}/{type_name}", summary="推荐电影/电视剧", response_model=List[schemas.MediaInfo])
-async def tmdb_recommend(tmdbid: int,
-                         type_name: str,
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_recommend(tmdbid: int,
+                   type_name: str,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID查询推荐电影/电视剧，type_name: 电影/电视剧
    """
    mediatype = MediaType(type_name)
    if mediatype == MediaType.MOVIE:
-        medias = await TmdbChain().async_movie_recommend(tmdbid=tmdbid)
+        medias = TmdbChain().movie_recommend(tmdbid=tmdbid)
    elif mediatype == MediaType.TV:
-        medias = await TmdbChain().async_tv_recommend(tmdbid=tmdbid)
+        medias = TmdbChain().tv_recommend(tmdbid=tmdbid)
    else:
        return []
    if medias:
@@ -59,64 +59,100 @@ async def tmdb_recommend(tmdbid: int,
    return []


-@router.get("/collection/{collection_id}", summary="系列合集详情", response_model=List[schemas.MediaInfo])
-async def tmdb_collection(collection_id: int,
-                          page: Optional[int] = 1,
-                          count: Optional[int] = 20,
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    根据合集ID查询合集详情
-    """
-    medias = await TmdbChain().async_tmdb_collection(collection_id=collection_id)
-    if medias:
-        return [media.to_dict() for media in medias][(page - 1) * count:page * count]
-    return []
-
-
@router.get("/credits/{tmdbid}/{type_name}", summary="演员阵容", response_model=List[schemas.MediaPerson])
-async def tmdb_credits(tmdbid: int,
-                       type_name: str,
-                       page: Optional[int] = 1,
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_credits(tmdbid: int,
+                 type_name: str,
+                 page: int = 1,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID查询演员阵容，type_name: 电影/电视剧
    """
    mediatype = MediaType(type_name)
    if mediatype == MediaType.MOVIE:
-        persons = await TmdbChain().async_movie_credits(tmdbid=tmdbid, page=page)
+        persons = TmdbChain().movie_credits(tmdbid=tmdbid, page=page)
    elif mediatype == MediaType.TV:
-        persons = await TmdbChain().async_tv_credits(tmdbid=tmdbid, page=page)
+        persons = TmdbChain().tv_credits(tmdbid=tmdbid, page=page)
    else:
        return []
    return persons or []


@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
-async def tmdb_person(person_id: int,
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_person(person_id: int,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据人物ID查询人物详情
    """
-    return await TmdbChain().async_person_detail(person_id=person_id)
+    return TmdbChain().person_detail(person_id=person_id)


@router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
-async def tmdb_person_credits(person_id: int,
-                              page: Optional[int] = 1,
-                              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_person_credits(person_id: int,
+                        page: int = 1,
+                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据人物ID查询人物参演作品
    """
-    medias = await TmdbChain().async_person_credits(person_id=person_id, page=page)
+    medias = TmdbChain().person_credits(person_id=person_id, page=page)
    if medias:
        return [media.to_dict() for media in medias]
    return []


+@router.get("/movies", summary="TMDB电影", response_model=List[schemas.MediaInfo])
+def tmdb_movies(sort_by: str = "popularity.desc",
+                with_genres: str = "",
+                with_original_language: str = "",
+                page: int = 1,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB电影信息
+    """
+    movies = TmdbChain().tmdb_discover(mtype=MediaType.MOVIE,
+                                       sort_by=sort_by,
+                                       with_genres=with_genres,
+                                       with_original_language=with_original_language,
+                                       page=page)
+    if not movies:
+        return []
+    return [movie.to_dict() for movie in movies]
+
+
+@router.get("/tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
+def tmdb_tvs(sort_by: str = "popularity.desc",
+             with_genres: str = "",
+             with_original_language: str = "",
+             page: int = 1,
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB剧集信息
+    """
+    tvs = TmdbChain().tmdb_discover(mtype=MediaType.TV,
+                                    sort_by=sort_by,
+                                    with_genres=with_genres,
+                                    with_original_language=with_original_language,
+                                    page=page)
+    if not tvs:
+        return []
+    return [tv.to_dict() for tv in tvs]
+
+
+@router.get("/trending", summary="TMDB流行趋势", response_model=List[schemas.MediaInfo])
+def tmdb_trending(page: int = 1,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB剧集信息
+    """
+    infos = TmdbChain().tmdb_trending(page=page)
+    if not infos:
+        return []
+    return [info.to_dict() for info in infos]
+
+
@router.get("/{tmdbid}/{season}", summary="TMDB季所有集", response_model=List[schemas.TmdbEpisode])
-async def tmdb_season_episodes(tmdbid: int, season: int, episode_group: Optional[str] = None,
-                               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_season_episodes(tmdbid: int, season: int,
+                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID查询某季的所有信信息
    """
-    return await TmdbChain().async_tmdb_episodes(tmdbid=tmdbid, season=season, episode_group=episode_group)
+    return TmdbChain().tmdb_episodes(tmdbid=tmdbid, season=season)
--- a/app/api/endpoints/torrent.py
+++ b/app/api/endpoints/torrent.py
@@ -1,197 +0,0 @@
-from typing import Optional
-
-from fastapi import APIRouter, Depends
-
-from app import schemas
-from app.chain.media import MediaChain
-from app.chain.torrents import TorrentsChain
-from app.core.config import settings
-from app.core.context import MediaInfo
-from app.core.metainfo import MetaInfo
-from app.db.models import User
-from app.db.user_oper import get_current_active_superuser, get_current_active_superuser_async
-from app.utils.crypto import HashUtils
-
-router = APIRouter()
-
-
-@router.get("/cache", summary="获取种子缓存", response_model=schemas.Response)
-async def torrents_cache(_: User = Depends(get_current_active_superuser_async)):
-    """
-    获取当前种子缓存数据
-    """
-    torrents_chain = TorrentsChain()
-
-    # 获取spider和rss两种缓存
-    if settings.SUBSCRIBE_MODE == "rss":
-        cache_info = await torrents_chain.async_get_torrents("rss")
-    else:
-        cache_info = await torrents_chain.async_get_torrents("spider")
-
-    # 统计信息
-    torrent_count = sum(len(torrents) for torrents in cache_info.values())
-
-    # 转换为前端需要的格式
-    torrent_data = []
-    for domain, contexts in cache_info.items():
-        for context in contexts:
-            torrent_hash = HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}")
-            torrent_data.append({
-                "hash": torrent_hash,
-                "domain": domain,
-                "title": context.torrent_info.title,
-                "description": context.torrent_info.description,
-                "size": context.torrent_info.size,
-                "pubdate": context.torrent_info.pubdate,
-                "site_name": context.torrent_info.site_name,
-                "media_name": context.media_info.title if context.media_info else "",
-                "media_year": context.media_info.year if context.media_info else "",
-                "media_type": context.media_info.type if context.media_info else "",
-                "season_episode": context.meta_info.season_episode if context.meta_info else "",
-                "resource_term": context.meta_info.resource_term if context.meta_info else "",
-                "enclosure": context.torrent_info.enclosure,
-                "page_url": context.torrent_info.page_url,
-                "poster_path": context.media_info.get_poster_image() if context.media_info else "",
-                "backdrop_path": context.media_info.get_backdrop_image() if context.media_info else ""
-            })
-
-    return schemas.Response(success=True, data={
-        "count": torrent_count,
-        "sites": len(cache_info),
-        "data": torrent_data
-    })
-
-
-@router.delete("/cache/{domain}/{torrent_hash}", summary="删除指定种子缓存", response_model=schemas.Response)
-async def delete_cache(domain: str, torrent_hash: str, _: User = Depends(get_current_active_superuser_async)):
-    """
-    删除指定的种子缓存
-    :param domain: 站点域名
-    :param torrent_hash: 种子hash（使用title+description的md5）
-    :param _: 当前用户，必须是超级用户
-    """
-
-    torrents_chain = TorrentsChain()
-
-    try:
-        # 获取当前缓存
-        cache_data = await torrents_chain.async_get_torrents()
-
-        if domain not in cache_data:
-            return schemas.Response(success=False, message=f"站点 {domain} 缓存不存在")
-
-        # 查找并删除指定种子
-        original_count = len(cache_data[domain])
-        cache_data[domain] = [
-            context for context in cache_data[domain]
-            if HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}") != torrent_hash
-        ]
-
-        if len(cache_data[domain]) == original_count:
-            return schemas.Response(success=False, message="未找到指定的种子")
-
-        # 保存更新后的缓存
-        await torrents_chain.async_save_cache(cache_data, torrents_chain.cache_file)
-
-        return schemas.Response(success=True, message="种子删除成功")
-    except Exception as e:
-        return schemas.Response(success=False, message=f"删除失败：{str(e)}")
-
-
-@router.delete("/cache", summary="清理种子缓存", response_model=schemas.Response)
-async def clear_cache(_: User = Depends(get_current_active_superuser_async)):
-    """
-    清理所有种子缓存
-    """
-    torrents_chain = TorrentsChain()
-
-    try:
-        await torrents_chain.async_clear_torrents()
-        return schemas.Response(success=True, message="种子缓存清理完成")
-    except Exception as e:
-        return schemas.Response(success=False, message=f"清理失败：{str(e)}")
-
-
-@router.post("/cache/refresh", summary="刷新种子缓存", response_model=schemas.Response)
-def refresh_cache(_: User = Depends(get_current_active_superuser)):
-    """
-    刷新种子缓存
-    """
-    from app.chain.torrents import TorrentsChain
-
-    torrents_chain = TorrentsChain()
-
-    try:
-        result = torrents_chain.refresh()
-
-        # 统计刷新结果
-        total_count = sum(len(torrents) for torrents in result.values())
-        sites_count = len(result)
-
-        return schemas.Response(success=True, message=f"缓存刷新完成，共刷新 {sites_count} 个站点，{total_count} 个种子")
-    except Exception as e:
-        return schemas.Response(success=False, message=f"刷新失败：{str(e)}")
-
-
-@router.post("/cache/reidentify/{domain}/{torrent_hash}", summary="重新识别种子", response_model=schemas.Response)
-async def reidentify_cache(domain: str, torrent_hash: str,
-                           tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
-                           _: User = Depends(get_current_active_superuser_async)):
-    """
-    重新识别指定的种子
-    :param domain: 站点域名
-    :param torrent_hash: 种子hash（使用title+description的md5）
-    :param tmdbid: 手动指定的TMDB ID
-    :param doubanid: 手动指定的豆瓣ID
-    :param _: 当前用户，必须是超级用户
-    """
-
-    torrents_chain = TorrentsChain()
-    media_chain = MediaChain()
-
-    try:
-        # 获取当前缓存
-        cache_data = await torrents_chain.async_get_torrents()
-
-        if domain not in cache_data:
-            return schemas.Response(success=False, message=f"站点 {domain} 缓存不存在")
-
-        # 查找指定种子
-        target_context = None
-        for context in cache_data[domain]:
-            if HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}") == torrent_hash:
-                target_context = context
-                break
-
-        if not target_context:
-            return schemas.Response(success=False, message="未找到指定的种子")
-
-        # 重新识别
-        meta = MetaInfo(title=target_context.torrent_info.title, subtitle=target_context.torrent_info.description)
-        if tmdbid or doubanid:
-            # 手动指定媒体信息
-            mediainfo = await media_chain.async_recognize_media(meta=meta, tmdbid=tmdbid, doubanid=doubanid)
-        else:
-            # 自动重新识别
-            mediainfo = await media_chain.async_recognize_by_meta(meta)
-
-        if not mediainfo:
-            # 创建空的媒体信息
-            mediainfo = MediaInfo()
-        else:
-            # 清理多余数据
-            mediainfo.clear()
-
-        # 更新上下文中的媒体信息
-        target_context.media_info = mediainfo
-
-        # 保存更新后的缓存
-        await torrents_chain.async_save_cache(cache_data, TorrentsChain().cache_file)
-
-        return schemas.Response(success=True, message="重新识别完成", data={
-            "media_name": mediainfo.title if mediainfo else "",
-            "media_year": mediainfo.year if mediainfo else "",
-            "media_type": mediainfo.type.value if mediainfo and mediainfo.type else ""
-        })
-    except Exception as e:
-        return schemas.Response(success=False, message=f"重新识别失败：{str(e)}")
--- a/app/api/endpoints/transfer.py
+++ b/app/api/endpoints/transfer.py
@@ -1,22 +1,17 @@
 from pathlib import Path
-from typing import Any, List, Annotated, Optional
+from typing import Any

 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session

 from app import schemas
 from app.chain.media import MediaChain
-from app.chain.storage import StorageChain
 from app.chain.transfer import TransferChain
-from app.core.config import settings, global_vars
 from app.core.metainfo import MetaInfoPath
 from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
-from app.db.models import User
 from app.db.models.transferhistory import TransferHistory
-from app.db.user_oper import get_current_active_superuser
-from app.helper.directory import DirectoryHelper
-from app.schemas import MediaType, FileItem, ManualTransferItem
+from app.schemas import MediaType

 router = APIRouter()

@@ -38,19 +33,11 @@ def query_name(path: str, filetype: str,
    if not new_path:
        return schemas.Response(success=False, message="未识别到新名称")
    if filetype == "dir":
-        media_path = DirectoryHelper.get_media_root_path(
-            rename_format=settings.RENAME_FORMAT(mediainfo.type),
-            rename_path=Path(new_path),
-        )
-        if media_path:
-            new_name = media_path.name
+        parents = Path(new_path).parents
+        if len(parents) > 2:
+            new_name = parents[1].name
        else:
-            # fallback
-            parents = Path(new_path).parents
-            if len(parents) > 2:
-                new_name = parents[1].name
-            else:
-                new_name = parents[0].name
+            new_name = parents[0].name
    else:
        new_name = Path(new_path).name
    return schemas.Response(success=True, data={
@@ -58,116 +45,103 @@ def query_name(path: str, filetype: str,
    })


-@router.get("/queue", summary="查询整理队列", response_model=List[schemas.TransferJob])
-async def query_queue(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询整理队列
-    :param _: Token校验
-    """
-    return TransferChain().get_queue_tasks()
-
-
-@router.delete("/queue", summary="从整理队列中删除任务", response_model=schemas.Response)
-async def remove_queue(fileitem: schemas.FileItem, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询整理队列
-    :param fileitem: 文件项
-    :param _: Token校验
-    """
-    TransferChain().remove_from_queue(fileitem)
-    # 取消整理
-    global_vars.stop_transfer(fileitem.path)
-    return schemas.Response(success=True)
-
-
@router.post("/manual", summary="手动转移", response_model=schemas.Response)
-def manual_transfer(transer_item: ManualTransferItem,
-                    background: Optional[bool] = False,
+def manual_transfer(storage: str = "local",
+                    path: str = None,
+                    drive_id: str = None,
+                    fileid: str = None,
+                    filetype: str = None,
+                    logid: int = None,
+                    target: str = None,
+                    tmdbid: int = None,
+                    doubanid: str = None,
+                    type_name: str = None,
+                    season: int = None,
+                    transfer_type: str = None,
+                    episode_format: str = None,
+                    episode_detail: str = None,
+                    episode_part: str = None,
+                    episode_offset: int = 0,
+                    min_filesize: int = 0,
+                    scrape: bool = None,
                    db: Session = Depends(get_db),
-                    _: User = Depends(get_current_active_superuser)) -> Any:
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    手动转移，文件或历史记录，支持自定义剧集识别格式
-    :param transer_item: 手工整理项
-    :param background: 后台运行
+    :param storage: 存储类型：local/aliyun/u115
+    :param path: 转移路径或文件
+    :param drive_id: 云盘ID（网盘等）
+    :param fileid: 文件ID（网盘等）
+    :param filetype: 文件类型，dir/file
+    :param logid: 转移历史记录ID
+    :param target: 目标路径
+    :param type_name: 媒体类型、电影/电视剧
+    :param tmdbid: tmdbid
+    :param doubanid: 豆瓣ID
+    :param season: 剧集季号
+    :param transfer_type: 转移类型，move/copy 等
+    :param episode_format: 剧集识别格式
+    :param episode_detail: 剧集识别详细信息
+    :param episode_part: 剧集识别分集信息
+    :param episode_offset: 剧集识别偏移量
+    :param min_filesize: 最小文件大小(MB)
+    :param scrape: 是否刮削元数据
    :param db: 数据库
    :param _: Token校验
    """
    force = False
-    target_path = Path(transer_item.target_path) if transer_item.target_path else None
-    if transer_item.logid:
+    target = Path(target) if target else None
+    transfer = TransferChain()
+    if logid:
        # 查询历史记录
-        history: TransferHistory = TransferHistory.get(db, transer_item.logid)
+        history: TransferHistory = TransferHistory.get(db, logid)
        if not history:
-            return schemas.Response(success=False, message=f"整理记录不存在，ID：{transer_item.logid}")
+            return schemas.Response(success=False, message=f"历史记录不存在，ID：{logid}")
        # 强制转移
        force = True
        if history.status and ("move" in history.mode):
            # 重新整理成功的转移，则使用成功的 dest 做 in_path
-            src_fileitem = FileItem(**history.dest_fileitem)
+            in_path = Path(history.dest)
        else:
            # 源路径
-            src_fileitem = FileItem(**history.src_fileitem)
+            in_path = Path(history.src)
            # 目的路径
-            if history.dest_fileitem:
+            if history.dest and str(history.dest) != "None":
                # 删除旧的已整理文件
-                dest_fileitem = FileItem(**history.dest_fileitem)
-                state = StorageChain().delete_media_file(dest_fileitem)
-                if not state:
-                    return schemas.Response(success=False, message=f"{dest_fileitem.path} 删除失败")
-
-        # 从历史数据获取信息
-        if transer_item.from_history:
-            transer_item.type_name = history.type if history.type else transer_item.type_name
-            transer_item.tmdbid = int(history.tmdbid) if history.tmdbid else transer_item.tmdbid
-            transer_item.doubanid = str(history.doubanid) if history.doubanid else transer_item.doubanid
-            transer_item.season = int(str(history.seasons).replace("S", "")) if history.seasons else transer_item.season
-            if history.episodes:
-                if "-" in str(history.episodes):
-                    # E01-E03多集合并
-                    episode_start, episode_end = str(history.episodes).split("-")
-                    episode_list: list[int] = []
-                    for i in range(int(episode_start.replace("E", "")), int(episode_end.replace("E", "")) + 1):
-                        episode_list.append(i)
-                    transer_item.episode_detail = ",".join(str(e) for e in episode_list)
-                else:
-                    # E01单集
-                    transer_item.episode_detail = str(history.episodes).replace("E", "")
-
-    elif transer_item.fileitem:
-        src_fileitem = transer_item.fileitem
+                transfer.delete_files(Path(history.dest))
+    elif path:
+        in_path = Path(path)
    else:
-        return schemas.Response(success=False, message=f"缺少参数")
+        return schemas.Response(success=False, message=f"缺少参数：path/logid")

    # 类型
-    mtype = MediaType(transer_item.type_name) if transer_item.type_name else None
+    mtype = MediaType(type_name) if type_name else None
    # 自定义格式
    epformat = None
-    if transer_item.episode_offset or transer_item.episode_part \
-            or transer_item.episode_detail or transer_item.episode_format:
+    if episode_offset or episode_part or episode_detail or episode_format:
        epformat = schemas.EpisodeFormat(
-            format=transer_item.episode_format,
-            detail=transer_item.episode_detail,
-            part=transer_item.episode_part,
-            offset=transer_item.episode_offset,
+            format=episode_format,
+            detail=episode_detail,
+            part=episode_part,
+            offset=episode_offset,
        )
    # 开始转移
-    state, errormsg = TransferChain().manual_transfer(
-        fileitem=src_fileitem,
-        target_storage=transer_item.target_storage,
-        target_path=target_path,
-        tmdbid=transer_item.tmdbid,
-        doubanid=transer_item.doubanid,
+    state, errormsg = transfer.manual_transfer(
+        storage=storage,
+        in_path=in_path,
+        drive_id=drive_id,
+        fileid=fileid,
+        filetype=filetype,
+        target=target,
+        tmdbid=tmdbid,
+        doubanid=doubanid,
        mtype=mtype,
-        season=transer_item.season,
-        episode_group=transer_item.episode_group,
-        transfer_type=transer_item.transfer_type,
+        season=season,
+        transfer_type=transfer_type,
        epformat=epformat,
-        min_filesize=transer_item.min_filesize,
-        scrape=transer_item.scrape,
-        library_type_folder=transer_item.library_type_folder,
-        library_category_folder=transer_item.library_category_folder,
-        force=force,
-        background=background
+        min_filesize=min_filesize,
+        scrape=scrape,
+        force=force
    )
    # 失败
    if not state:
@@ -179,7 +153,7 @@ def manual_transfer(transer_item: ManualTransferItem,


@router.get("/now", summary="立即执行下载器文件整理", response_model=schemas.Response)
-def now(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def now(_: str = Depends(verify_apitoken)) -> Any:
    """
    立即执行下载器文件整理 API_TOKEN认证（?token=xxx）
    """
--- a/app/api/endpoints/u115.py
+++ b/app/api/endpoints/u115.py
@@ -0,0 +1,213 @@
+from pathlib import Path
+from typing import Any, List
+
+from fastapi import APIRouter, Depends, HTTPException
+from starlette.responses import Response
+
+from app import schemas
+from app.chain.transfer import TransferChain
+from app.core.config import settings
+from app.core.metainfo import MetaInfoPath
+from app.core.security import verify_token, verify_uri_token
+from app.helper.progress import ProgressHelper
+from app.helper.u115 import U115Helper
+from app.schemas.types import ProgressKey
+from app.utils.http import RequestUtils
+
+router = APIRouter()
+
+
+@router.get("/qrcode", summary="生成二维码内容", response_model=schemas.Response)
+def qrcode(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    生成二维码
+    """
+    qrcode_data = U115Helper().generate_qrcode()
+    if qrcode_data:
+        return schemas.Response(success=True, data={
+            'codeContent': qrcode_data
+        })
+    return schemas.Response(success=False)
+
+
+@router.get("/check", summary="二维码登录确认", response_model=schemas.Response)
+def check(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    二维码登录确认
+    """
+    data, errmsg = U115Helper().check_login()
+    if data:
+        return schemas.Response(success=True, data=data)
+    return schemas.Response(success=False, message=errmsg)
+
+
+@router.get("/storage", summary="查询存储空间信息", response_model=schemas.Response)
+def storage(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询存储空间信息
+    """
+    storage_info = U115Helper().storage()
+    if storage_info:
+        return schemas.Response(success=True, data={
+            "total": storage_info[0],
+            "used": storage_info[1]
+        })
+    return schemas.Response(success=False)
+
+
+@router.post("/list", summary="所有目录和文件（115网盘）", response_model=List[schemas.FileItem])
+def list_115(fileitem: schemas.FileItem,
+             sort: str = 'updated_at',
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询当前目录下所有目录和文件
+    :param fileitem: 文件项
+    :param sort: 排序方式，name:按名称排序，time:按修改时间排序
+    :param _: token
+    :return: 所有目录和文件
+    """
+    if not fileitem.fileid:
+        return []
+    if not fileitem.path:
+        path = "/"
+    else:
+        path = fileitem.path
+    if fileitem.fileid == "root":
+        fileid = "0"
+    else:
+        fileid = fileitem.fileid
+    if fileitem.type == "file":
+        name = Path(path).name
+        suffix = Path(name).suffix[1:]
+        return [schemas.FileItem(
+            fileid=fileid,
+            type="file",
+            path=path.rstrip('/'),
+            name=name,
+            extension=suffix,
+            pickcode=fileitem.pickcode
+        )]
+    file_list = U115Helper().list(parent_file_id=fileid, path=path)
+    if sort == "name":
+        file_list.sort(key=lambda x: x.name)
+    else:
+        file_list.sort(key=lambda x: x.modify_time, reverse=True)
+    return file_list
+
+
+@router.post("/mkdir", summary="创建目录（115网盘）", response_model=schemas.Response)
+def mkdir_115(fileitem: schemas.FileItem,
+              name: str,
+              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    创建目录
+    """
+    if not fileitem.fileid or not name:
+        return schemas.Response(success=False)
+    result = U115Helper().create_folder(parent_file_id=fileitem.fileid, name=name, path=fileitem.path)
+    if result:
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.post("/delete", summary="删除文件或目录（115网盘）", response_model=schemas.Response)
+def delete_115(fileitem: schemas.FileItem,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    删除文件或目录
+    """
+    if not fileitem.fileid:
+        return schemas.Response(success=False)
+    result = U115Helper().delete(fileitem.fileid)
+    if result:
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.get("/download", summary="下载文件（115网盘）")
+def download_115(pickcode: str,
+                 _: schemas.TokenPayload = Depends(verify_uri_token)) -> Any:
+    """
+    下载文件或目录
+    """
+    if not pickcode:
+        return schemas.Response(success=False)
+    ticket = U115Helper().download(pickcode)
+    if ticket:
+        # 请求数据，并以文件流的方式返回
+        res = RequestUtils(headers=ticket.headers).get_res(ticket.url)
+        if res:
+            return Response(content=res.content, media_type="application/octet-stream")
+    return schemas.Response(success=False)
+
+
+@router.post("/rename", summary="重命名文件或目录（115网盘）", response_model=schemas.Response)
+def rename_115(fileitem: schemas.FileItem,
+               new_name: str,
+               recursive: bool = False,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    重命名文件或目录
+    """
+    if not fileitem.fileid or not new_name:
+        return schemas.Response(success=False)
+    result = U115Helper().rename(fileitem.fileid, new_name)
+    if result:
+        if recursive:
+            transferchain = TransferChain()
+            media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIO_TRACK_EXT
+            # 递归修改目录内文件（智能识别命名）
+            sub_files: List[schemas.FileItem] = list_115(fileitem)
+            if sub_files:
+                # 开始进度
+                progress = ProgressHelper()
+                progress.start(ProgressKey.BatchRename)
+                total = len(sub_files)
+                handled = 0
+                for sub_file in sub_files:
+                    handled += 1
+                    progress.update(value=handled / total * 100,
+                                    text=f"正在处理 {sub_file.name} ...",
+                                    key=ProgressKey.BatchRename)
+                    if sub_file.type == "dir":
+                        continue
+                    if not sub_file.extension:
+                        continue
+                    if f".{sub_file.extension.lower()}" not in media_exts:
+                        continue
+                    sub_path = Path(f"{fileitem.path}{sub_file.name}")
+                    meta = MetaInfoPath(sub_path)
+                    mediainfo = transferchain.recognize_media(meta)
+                    if not mediainfo:
+                        progress.end(ProgressKey.BatchRename)
+                        return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
+                    new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
+                    if not new_path:
+                        progress.end(ProgressKey.BatchRename)
+                        return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
+                    ret: schemas.Response = rename_115(fileitem=sub_file,
+                                                       new_name=Path(new_path).name,
+                                                       recursive=False)
+                    if not ret.success:
+                        progress.end(ProgressKey.BatchRename)
+                        return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
+                progress.end(ProgressKey.BatchRename)
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.get("/image", summary="读取图片（115网盘）")
+def image_115(pickcode: str, _: schemas.TokenPayload = Depends(verify_uri_token)) -> Any:
+    """
+    读取图片
+    """
+    if not pickcode:
+        return schemas.Response(success=False)
+    ticket = U115Helper().download(pickcode)
+    if ticket:
+        # 请求数据，获取内容编码为图片base64返回
+        res = RequestUtils(headers=ticket.headers).get_res(ticket.url)
+        if res:
+            content_type = res.headers.get("Content-Type")
+            return Response(content=res.content, media_type=content_type)
+    raise HTTPException(status_code=500, detail="下载图片出错")
--- a/app/api/endpoints/user.py
+++ b/app/api/endpoints/user.py
@@ -1,16 +1,15 @@
 import base64
 import re
-from typing import Annotated, Any, List, Union
+from typing import Any, List, Union

-from fastapi import APIRouter, Body, Depends, HTTPException, UploadFile, File
-from sqlalchemy.ext.asyncio import AsyncSession
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from sqlalchemy.orm import Session

 from app import schemas
 from app.core.security import get_password_hash
-from app.db import get_async_db
+from app.db import get_db
 from app.db.models.user import User
-from app.db.user_oper import get_current_active_superuser_async, \
-    get_current_active_user_async, get_current_active_user
+from app.db.userauth import get_current_active_superuser, get_current_active_user
 from app.db.userconfig_oper import UserConfigOper
 from app.utils.otp import OtpUtils

@@ -18,48 +17,50 @@ router = APIRouter()


@router.get("/", summary="所有用户", response_model=List[schemas.User])
-async def list_users(
-        db: AsyncSession = Depends(get_async_db),
-        current_user: User = Depends(get_current_active_superuser_async),
+def read_users(
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_active_superuser),
 ) -> Any:
    """
    查询用户列表
    """
-    return await current_user.async_list(db)
+    users = current_user.list(db)
+    return users


@router.post("/", summary="新增用户", response_model=schemas.Response)
-async def create_user(
+def create_user(
        *,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        user_in: schemas.UserCreate,
-        current_user: User = Depends(get_current_active_superuser_async),
+        current_user: User = Depends(get_current_active_superuser),
 ) -> Any:
    """
    新增用户
    """
-    user = await current_user.async_get_by_name(db, name=user_in.name)
+    user = current_user.get_by_name(db, name=user_in.name)
    if user:
        return schemas.Response(success=False, message="用户已存在")
-    user_info = user_in.model_dump()
+    user_info = user_in.dict()
    if user_info.get("password"):
        user_info["hashed_password"] = get_password_hash(user_info["password"])
        user_info.pop("password")
-    user = await User(**user_info).async_create(db)
-    return schemas.Response(success=True if user else False)
+    user = User(**user_info)
+    user.create(db)
+    return schemas.Response(success=True)


@router.put("/", summary="更新用户", response_model=schemas.Response)
-async def update_user(
+def update_user(
        *,
-        db: AsyncSession = Depends(get_async_db),
-        user_in: schemas.UserUpdate,
-        current_user: User = Depends(get_current_active_superuser_async),
+        db: Session = Depends(get_db),
+        user_in: schemas.UserCreate,
+        _: User = Depends(get_current_active_superuser),
 ) -> Any:
    """
    更新用户
    """
-    user_info = user_in.model_dump()
+    user_info = user_in.dict()
    if user_info.get("password"):
        # 正则表达式匹配密码包含字母、数字、特殊字符中的至少两项
        pattern = r'^(?![a-zA-Z]+$)(?!\d+$)(?![^\da-zA-Z\s]+$).{6,50}$'
@@ -68,24 +69,16 @@ async def update_user(
                                    message="密码需要同时包含字母、数字、特殊字符中的至少两项，且长度大于6位")
        user_info["hashed_password"] = get_password_hash(user_info["password"])
        user_info.pop("password")
-    user = await current_user.async_get_by_id(db, user_id=user_info["id"])
-    user_name = user_info.get("name")
-    if not user_name:
-        return schemas.Response(success=False, message="用户名不能为空")
-    # 新用户名去重
-    users = await current_user.async_list(db)
-    for u in users:
-        if u.name == user_name and u.id != user_info["id"]:
-            return schemas.Response(success=False, message="用户名已被使用")
+    user = User.get_by_name(db, name=user_info["name"])
    if not user:
        return schemas.Response(success=False, message="用户不存在")
-    await user.async_update(db, user_info)
+    user.update(db, user_info)
    return schemas.Response(success=True)


@router.get("/current", summary="当前登录用户信息", response_model=schemas.User)
-async def read_current_user(
-        current_user: User = Depends(get_current_active_user_async)
+def read_current_user(
+        current_user: User = Depends(get_current_active_user)
 ) -> Any:
    """
    当前登录用户信息
@@ -94,18 +87,18 @@ async def read_current_user(


@router.post("/avatar/{user_id}", summary="上传用户头像", response_model=schemas.Response)
-async def upload_avatar(user_id: int, db: AsyncSession = Depends(get_async_db), file: UploadFile = File(...),
-                        _: User = Depends(get_current_active_user_async)):
+def upload_avatar(user_id: int, db: Session = Depends(get_db), file: UploadFile = File(...),
+                  _: User = Depends(get_current_active_user)):
    """
    上传用户头像
    """
    # 将文件转换为Base64
    file_base64 = base64.b64encode(file.file.read())
    # 更新到用户表
-    user = await User.async_get(db, user_id)
+    user = User.get(db, user_id)
    if not user:
        return schemas.Response(success=False, message="用户不存在")
-    await user.async_update(db, {
+    user.update(db, {
        "avatar": f"data:image/ico;base64,{file_base64}"
    })
    return schemas.Response(success=True, message=file.filename)
@@ -120,33 +113,33 @@ def otp_generate(


@router.post('/otp/judge', summary='判断otp验证是否通过', response_model=schemas.Response)
-async def otp_judge(
+def otp_judge(
        data: dict,
-        db: AsyncSession = Depends(get_async_db),
-        current_user: User = Depends(get_current_active_user_async)
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_active_user)
 ) -> Any:
    uri = data.get("uri")
    otp_password = data.get("otpPassword")
    if not OtpUtils.is_legal(uri, otp_password):
        return schemas.Response(success=False, message="验证码错误")
-    await current_user.async_update_otp_by_name(db, current_user.name, True, OtpUtils.get_secret(uri))
+    current_user.update_otp_by_name(db, current_user.name, True, OtpUtils.get_secret(uri))
    return schemas.Response(success=True)


@router.post('/otp/disable', summary='关闭当前用户的otp验证', response_model=schemas.Response)
-async def otp_disable(
-        db: AsyncSession = Depends(get_async_db),
-        current_user: User = Depends(get_current_active_user_async)
+def otp_disable(
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_active_user)
 ) -> Any:
-    await current_user.async_update_otp_by_name(db, current_user.name, False, "")
+    current_user.update_otp_by_name(db, current_user.name, False, "")
    return schemas.Response(success=True)


@router.get('/otp/{userid}', summary='判断当前用户是否开启otp验证', response_model=schemas.Response)
-async def otp_enable(userid: str, db: AsyncSession = Depends(get_async_db)) -> Any:
-    user: User = await User.async_get_by_name(db, userid)
+def otp_enable(userid: str, db: Session = Depends(get_db)) -> Any:
+    user: User = User.get_by_name(db, userid)
    if not user:
-        return schemas.Response(success=False)
+        return schemas.Response(success=False, message="用户不存在")
    return schemas.Response(success=user.is_otp)


@@ -163,11 +156,8 @@ def get_config(key: str,


@router.post("/config/{key}", summary="更新用户配置", response_model=schemas.Response)
-def set_config(
-        key: str,
-        value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
-        current_user: User = Depends(get_current_active_user),
-):
+def set_config(key: str, value: Union[list, dict, bool, int, str] = None,
+               current_user: User = Depends(get_current_active_user)):
    """
    更新用户配置
    """
@@ -175,50 +165,33 @@ def set_config(
    return schemas.Response(success=True)


-@router.delete("/id/{user_id}", summary="删除用户", response_model=schemas.Response)
-async def delete_user_by_id(
+@router.delete("/{user_name}", summary="删除用户", response_model=schemas.Response)
+def delete_user(
        *,
-        db: AsyncSession = Depends(get_async_db),
-        user_id: int,
-        current_user: User = Depends(get_current_active_superuser_async),
-) -> Any:
-    """
-    通过唯一ID删除用户
-    """
-    user = await current_user.async_get_by_id(db, user_id=user_id)
-    if not user:
-        return schemas.Response(success=False, message="用户不存在")
-    await current_user.async_delete(db, user_id)
-    return schemas.Response(success=True)
-
-
-@router.delete("/name/{user_name}", summary="删除用户", response_model=schemas.Response)
-async def delete_user_by_name(
-        *,
-        db: AsyncSession = Depends(get_async_db),
+        db: Session = Depends(get_db),
        user_name: str,
-        current_user: User = Depends(get_current_active_superuser_async),
+        current_user: User = Depends(get_current_active_superuser),
 ) -> Any:
    """
-    通过用户名删除用户
+    删除用户
    """
-    user = await current_user.async_get_by_name(db, name=user_name)
+    user = current_user.get_by_name(db, name=user_name)
    if not user:
        return schemas.Response(success=False, message="用户不存在")
-    await current_user.async_delete(db, user.id)
+    user.delete_by_name(db, user_name)
    return schemas.Response(success=True)


-@router.get("/{username}", summary="用户详情", response_model=schemas.User)
-async def read_user_by_name(
-        username: str,
-        current_user: User = Depends(get_current_active_user_async),
-        db: AsyncSession = Depends(get_async_db),
+@router.get("/{user_id}", summary="用户详情", response_model=schemas.User)
+def read_user_by_id(
+        user_id: int,
+        current_user: User = Depends(get_current_active_user),
+        db: Session = Depends(get_db),
 ) -> Any:
    """
    查询用户详情
    """
-    user = await current_user.async_get_by_name(db, name=username)
+    user = current_user.get(db, rid=user_id)
    if not user:
        raise HTTPException(
            status_code=404,
@@ -226,7 +199,7 @@ async def read_user_by_name(
        )
    if user == current_user:
        return user
-    if not current_user.is_superuser:
+    if not user.is_superuser:
        raise HTTPException(
            status_code=400,
            detail="用户权限不足"
--- a/app/api/endpoints/webhook.py
+++ b/app/api/endpoints/webhook.py
@@ -1,4 +1,4 @@
-from typing import Any, Annotated
+from typing import Any

 from fastapi import APIRouter, BackgroundTasks, Request, Depends

@@ -19,10 +19,10 @@ def start_webhook_chain(body: Any, form: Any, args: Any):
@router.post("/", summary="Webhook消息响应", response_model=schemas.Response)
 async def webhook_message(background_tasks: BackgroundTasks,
                          request: Request,
-                          _: Annotated[str, Depends(verify_apitoken)]
+                          _: str = Depends(verify_apitoken)
                          ) -> Any:
    """
-    Webhook响应，配置请求中需要添加参数：token=API_TOKEN&source=媒体服务器名
+    Webhook响应
    """
    body = await request.body()
    form = await request.form()
@@ -32,10 +32,10 @@ async def webhook_message(background_tasks: BackgroundTasks,


@router.get("/", summary="Webhook消息响应", response_model=schemas.Response)
-async def webhook_message(background_tasks: BackgroundTasks,
-                          request: Request, _: Annotated[str, Depends(verify_apitoken)]) -> Any:
+def webhook_message(background_tasks: BackgroundTasks,
+                    request: Request, _: str = Depends(verify_apitoken)) -> Any:
    """
-    Webhook响应，配置请求中需要添加参数：token=API_TOKEN&source=媒体服务器名
+    Webhook响应
    """
    args = request.query_params
    background_tasks.add_task(start_webhook_chain, None, None, args)
--- a/app/api/endpoints/workflow.py
+++ b/app/api/endpoints/workflow.py
@@ -1,310 +0,0 @@
-import json
-from datetime import datetime
-from typing import List, Any, Optional
-
-from fastapi import APIRouter, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import Session
-
-from app import schemas
-from app.chain.workflow import WorkflowChain
-from app.core.config import global_vars
-from app.core.plugin import PluginManager
-from app.core.security import verify_token
-from app.workflow import WorkFlowManager
-from app.db import get_async_db, get_db
-from app.db.models import Workflow
-from app.db.systemconfig_oper import SystemConfigOper
-from app.db.workflow_oper import WorkflowOper
-from app.helper.workflow import WorkflowHelper
-from app.scheduler import Scheduler
-from app.schemas.types import EventType, EVENT_TYPE_NAMES
-
-router = APIRouter()
-
-
-@router.get("/", summary="所有工作流", response_model=List[schemas.Workflow])
-async def list_workflows(db: AsyncSession = Depends(get_async_db),
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取工作流列表
-    """
-    return await WorkflowOper(db).async_list()
-
-
-@router.post("/", summary="创建工作流", response_model=schemas.Response)
-async def create_workflow(workflow: schemas.Workflow,
-                          db: AsyncSession = Depends(get_async_db),
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    创建工作流
-    """
-    if workflow.name and await WorkflowOper(db).async_get_by_name(workflow.name):
-        return schemas.Response(success=False, message="已存在相同名称的工作流")
-    if not workflow.add_time:
-        workflow.add_time = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
-    if not workflow.state:
-        workflow.state = "P"
-    if not workflow.trigger_type:
-        workflow.trigger_type = "timer"
-    workflow_obj = Workflow(**workflow.model_dump())
-    await workflow_obj.async_create(db)
-    return schemas.Response(success=True, message="创建工作流成功")
-
-
-@router.get("/plugin/actions", summary="查询插件动作", response_model=List[dict])
-def list_plugin_actions(plugin_id: str = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取所有动作
-    """
-    return PluginManager().get_plugin_actions(plugin_id)
-
-
-@router.get("/actions", summary="所有动作", response_model=List[dict])
-async def list_actions(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取所有动作
-    """
-    return WorkFlowManager().list_actions()
-
-
-@router.get("/event_types", summary="获取所有事件类型", response_model=List[dict])
-async def get_event_types(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取所有事件类型
-    """
-    return [{
-        "title": EVENT_TYPE_NAMES.get(event_type, event_type.name),
-        "value": event_type.value
-    } for event_type in EventType]
-
-
-@router.post("/share", summary="分享工作流", response_model=schemas.Response)
-async def workflow_share(
-        workflow: schemas.WorkflowShare,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    分享工作流
-    """
-    if not workflow.id or not workflow.share_title or not workflow.share_user:
-        return schemas.Response(success=False, message="请填写工作流ID、分享标题和分享人")
-
-    state, errmsg = await WorkflowHelper().async_workflow_share(workflow_id=workflow.id,
-                                                                share_title=workflow.share_title or "",
-                                                                share_comment=workflow.share_comment or "",
-                                                                share_user=workflow.share_user or "")
-    return schemas.Response(success=state, message=errmsg)
-
-
-@router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
-async def workflow_share_delete(
-        share_id: int,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    删除分享
-    """
-    state, errmsg = await WorkflowHelper().async_share_delete(share_id=share_id)
-    return schemas.Response(success=state, message=errmsg)
-
-
-@router.post("/fork", summary="复用工作流", response_model=schemas.Response)
-async def workflow_fork(
-        workflow: schemas.WorkflowShare,
-        db: AsyncSession = Depends(get_async_db),
-        _: schemas.User = Depends(verify_token)) -> Any:
-    """
-    复用工作流
-    """
-    if not workflow.name:
-        return schemas.Response(success=False, message="工作流名称不能为空")
-
-    # 解析JSON数据，添加错误处理
-    try:
-        actions = json.loads(workflow.actions or "[]")
-    except json.JSONDecodeError:
-        return schemas.Response(success=False, message="actions字段JSON格式错误")
-
-    try:
-        flows = json.loads(workflow.flows or "[]")
-    except json.JSONDecodeError:
-        return schemas.Response(success=False, message="flows字段JSON格式错误")
-
-    try:
-        context = json.loads(workflow.context or "{}")
-    except json.JSONDecodeError:
-        return schemas.Response(success=False, message="context字段JSON格式错误")
-
-    # 创建工作流
-    workflow_dict = {
-        "name": workflow.name,
-        "description": workflow.description,
-        "timer": workflow.timer,
-        "trigger_type": workflow.trigger_type or "timer",
-        "event_type": workflow.event_type,
-        "event_conditions": json.loads(workflow.event_conditions or "{}") if workflow.event_conditions else {},
-        "actions": actions,
-        "flows": flows,
-        "context": context,
-        "state": "P"  # 默认暂停状态
-    }
-
-    # 检查名称是否重复
-    workflow_oper = WorkflowOper(db)
-    if await workflow_oper.async_get_by_name(workflow_dict["name"]):
-        return schemas.Response(success=False, message="已存在相同名称的工作流")
-
-    # 创建新工作流
-    workflow = await Workflow(**workflow_dict).async_create(db)
-
-    # 更新复用次数
-    if workflow:
-        await WorkflowHelper().async_workflow_fork(share_id=workflow.id)
-
-    return schemas.Response(success=True, message="复用成功")
-
-
-@router.get("/shares", summary="查询分享的工作流", response_model=List[schemas.WorkflowShare])
-async def workflow_shares(
-        name: Optional[str] = None,
-        page: Optional[int] = 1,
-        count: Optional[int] = 30,
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询分享的工作流
-    """
-    return await WorkflowHelper().async_get_shares(name=name, page=page, count=count)
-
-
-@router.post("/{workflow_id}/run", summary="执行工作流", response_model=schemas.Response)
-def run_workflow(workflow_id: int,
-                 from_begin: Optional[bool] = True,
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    执行工作流
-    """
-    state, errmsg = WorkflowChain().process(workflow_id, from_begin=from_begin)
-    if not state:
-        return schemas.Response(success=False, message=errmsg)
-    return schemas.Response(success=True)
-
-
-@router.post("/{workflow_id}/start", summary="启用工作流", response_model=schemas.Response)
-def start_workflow(workflow_id: int,
-                   db: Session = Depends(get_db),
-                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    启用工作流
-    """
-    workflow = WorkflowOper(db).get(workflow_id)
-    if not workflow:
-        return schemas.Response(success=False, message="工作流不存在")
-    if not workflow.trigger_type or workflow.trigger_type == "timer":
-        # 添加定时任务
-        Scheduler().update_workflow_job(workflow)
-    else:
-        # 事件触发：添加到事件触发器
-        WorkFlowManager().load_workflow_events(workflow_id)
-    # 更新状态
-    workflow.update_state(db, workflow_id, "W")
-    return schemas.Response(success=True)
-
-
-@router.post("/{workflow_id}/pause", summary="停用工作流", response_model=schemas.Response)
-def pause_workflow(workflow_id: int,
-                   db: Session = Depends(get_db),
-                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    停用工作流
-    """
-    workflow = WorkflowOper(db).get(workflow_id)
-    if not workflow:
-        return schemas.Response(success=False, message="工作流不存在")
-    # 根据触发类型进行不同处理
-    if workflow.trigger_type == "timer":
-        # 定时触发：移除定时任务
-        Scheduler().remove_workflow_job(workflow)
-    elif workflow.trigger_type == "event":
-        # 事件触发：从事件触发器中移除
-        WorkFlowManager().remove_workflow_event(workflow_id, workflow.event_type)
-    # 停止工作流
-    global_vars.stop_workflow(workflow_id)
-    # 更新状态
-    workflow.update_state(db, workflow_id, "P")
-    return schemas.Response(success=True)
-
-
-@router.post("/{workflow_id}/reset", summary="重置工作流", response_model=schemas.Response)
-async def reset_workflow(workflow_id: int,
-                         db: AsyncSession = Depends(get_async_db),
-                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    重置工作流
-    """
-    workflow = await WorkflowOper(db).async_get(workflow_id)
-    if not workflow:
-        return schemas.Response(success=False, message="工作流不存在")
-    # 停止工作流
-    global_vars.stop_workflow(workflow_id)
-    # 重置工作流
-    await Workflow.async_reset(db, workflow_id, reset_count=True)
-    # 删除缓存
-    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
-    return schemas.Response(success=True)
-
-
-@router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
-async def get_workflow(workflow_id: int,
-                       db: AsyncSession = Depends(get_async_db),
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    获取工作流详情
-    """
-    return await WorkflowOper(db).async_get(workflow_id)
-
-
-@router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
-def update_workflow(workflow: schemas.Workflow,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    更新工作流
-    """
-    if not workflow.id:
-        return schemas.Response(success=False, message="工作流ID不能为空")
-    workflow_oper = WorkflowOper(db)
-    wf = workflow_oper.get(workflow.id)
-    if not wf:
-        return schemas.Response(success=False, message="工作流不存在")
-    if not wf.trigger_type:
-        workflow.trigger_type = "timer"
-    wf.update(db, workflow.model_dump())
-    # 更新后的工作流对象
-    updated_workflow = workflow_oper.get(workflow.id)
-    # 更新定时任务
-    Scheduler().update_workflow_job(updated_workflow)
-    # 更新事件注册
-    WorkFlowManager().update_workflow_event(updated_workflow)
-    return schemas.Response(success=True, message="更新成功")
-
-
-@router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
-def delete_workflow(workflow_id: int,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    删除工作流
-    """
-    workflow = WorkflowOper(db).get(workflow_id)
-    if not workflow:
-        return schemas.Response(success=False, message="工作流不存在")
-    if not workflow.trigger_type or workflow.trigger_type == "timer":
-        # 定时触发：删除定时任务
-        Scheduler().remove_workflow_job(workflow)
-    else:
-        # 事件触发：从事件触发器中移除
-        WorkFlowManager().remove_workflow_event(workflow_id, workflow.event_type)
-    # 删除工作流
-    Workflow.delete(db, workflow_id)
-    # 删除缓存
-    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
-    return schemas.Response(success=True, message="删除成功")
--- a/app/api/servarr.py
+++ b/app/api/servarr.py
@@ -1,16 +1,14 @@
-from typing import Any, List, Annotated
+from typing import Any, List

 from fastapi import APIRouter, HTTPException, Depends
-from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session

 from app import schemas
 from app.chain.media import MediaChain
 from app.chain.subscribe import SubscribeChain
-from app.chain.tvdb import TvdbChain
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_apikey
-from app.db import get_db, get_async_db
+from app.db import get_db
 from app.db.models.subscribe import Subscribe
 from app.schemas import RadarrMovie, SonarrSeries
 from app.schemas.types import MediaType
@@ -20,7 +18,7 @@ arr_router = APIRouter(tags=['servarr'])


@arr_router.get("/system/status", summary="系统状态")
-async def arr_system_status(_: Annotated[str, Depends(verify_apikey)]) -> Any:
+def arr_system_status(_: str = Depends(verify_apikey)) -> Any:
    """
    模拟Radarr、Sonarr系统状态
    """
@@ -74,7 +72,7 @@ async def arr_system_status(_: Annotated[str, Depends(verify_apikey)]) -> Any:


@arr_router.get("/qualityProfile", summary="质量配置")
-async def arr_qualityProfile(_: Annotated[str, Depends(verify_apikey)]) -> Any:
+def arr_qualityProfile(_: str = Depends(verify_apikey)) -> Any:
    """
    模拟Radarr、Sonarr质量配置
    """
@@ -115,7 +113,7 @@ async def arr_qualityProfile(_: Annotated[str, Depends(verify_apikey)]) -> Any:


@arr_router.get("/rootfolder", summary="根目录")
-async def arr_rootfolder(_: Annotated[str, Depends(verify_apikey)]) -> Any:
+def arr_rootfolder(_: str = Depends(verify_apikey)) -> Any:
    """
    模拟Radarr、Sonarr根目录
    """
@@ -131,7 +129,7 @@ async def arr_rootfolder(_: Annotated[str, Depends(verify_apikey)]) -> Any:


@arr_router.get("/tag", summary="标签")
-async def arr_tag(_: Annotated[str, Depends(verify_apikey)]) -> Any:
+def arr_tag(_: str = Depends(verify_apikey)) -> Any:
    """
    模拟Radarr、Sonarr标签
    """
@@ -144,7 +142,7 @@ async def arr_tag(_: Annotated[str, Depends(verify_apikey)]) -> Any:


@arr_router.get("/languageprofile", summary="语言")
-async def arr_languageprofile(_: Annotated[str, Depends(verify_apikey)]) -> Any:
+def arr_languageprofile(_: str = Depends(verify_apikey)) -> Any:
    """
    模拟Radarr、Sonarr语言
    """
@@ -170,7 +168,7 @@ async def arr_languageprofile(_: Annotated[str, Depends(verify_apikey)]) -> Any:


@arr_router.get("/movie", summary="所有订阅电影", response_model=List[schemas.RadarrMovie])
-async def arr_movies(_: Annotated[str, Depends(verify_apikey)], db: AsyncSession = Depends(get_async_db)) -> Any:
+def arr_movies(_: str = Depends(verify_apikey), db: Session = Depends(get_db)) -> Any:
    """
    查询Rardar电影
    """
@@ -241,7 +239,7 @@ async def arr_movies(_: Annotated[str, Depends(verify_apikey)], db: AsyncSession
    """
    # 查询所有电影订阅
    result = []
-    subscribes = await Subscribe.async_list(db)
+    subscribes = Subscribe.list(db)
    for subscribe in subscribes:
        if subscribe.type != MediaType.MOVIE.value:
            continue
@@ -261,7 +259,7 @@ async def arr_movies(_: Annotated[str, Depends(verify_apikey)], db: AsyncSession


@arr_router.get("/movie/lookup", summary="查询电影", response_model=List[schemas.RadarrMovie])
-def arr_movie_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
+def arr_movie_lookup(term: str, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
    """
    查询Rardar电影 term: `tmdb:${id}`
    存在和不存在均不能返回错误
@@ -307,12 +305,11 @@ def arr_movie_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: S


@arr_router.get("/movie/{mid}", summary="电影订阅详情", response_model=schemas.RadarrMovie)
-async def arr_movie(mid: int, _: Annotated[str, Depends(verify_apikey)],
-                    db: AsyncSession = Depends(get_async_db)) -> Any:
+def arr_movie(mid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
    """
    查询Rardar电影订阅
    """
-    subscribe = await Subscribe.async_get(db, mid)
+    subscribe = Subscribe.get(db, mid)
    if subscribe:
        return RadarrMovie(
            id=subscribe.id,
@@ -334,25 +331,25 @@ async def arr_movie(mid: int, _: Annotated[str, Depends(verify_apikey)],


@arr_router.post("/movie", summary="新增电影订阅")
-async def arr_add_movie(_: Annotated[str, Depends(verify_apikey)],
-                        movie: RadarrMovie,
-                        db: AsyncSession = Depends(get_async_db)
-                        ) -> Any:
+def arr_add_movie(movie: RadarrMovie,
+                  db: Session = Depends(get_db),
+                  _: str = Depends(verify_apikey)
+                  ) -> Any:
    """
    新增Rardar电影订阅
    """
    # 检查订阅是否已存在
-    subscribe = await Subscribe.async_get_by_tmdbid(db, movie.tmdbId)
+    subscribe = Subscribe.get_by_tmdbid(db, movie.tmdbId)
    if subscribe:
        return {
            "id": subscribe.id
        }
    # 添加订阅
-    sid, message = await SubscribeChain().async_add(title=movie.title,
-                                                    year=movie.year,
-                                                    mtype=MediaType.MOVIE,
-                                                    tmdbid=movie.tmdbId,
-                                                    username="Seerr")
+    sid, message = SubscribeChain().add(title=movie.title,
+                                        year=movie.year,
+                                        mtype=MediaType.MOVIE,
+                                        tmdbid=movie.tmdbId,
+                                        username="Seerr")
    if sid:
        return {
            "id": sid
@@ -365,14 +362,13 @@ async def arr_add_movie(_: Annotated[str, Depends(verify_apikey)],


@arr_router.delete("/movie/{mid}", summary="删除电影订阅", response_model=schemas.Response)
-async def arr_remove_movie(mid: int, _: Annotated[str, Depends(verify_apikey)],
-                           db: AsyncSession = Depends(get_async_db)) -> Any:
+def arr_remove_movie(mid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
    """
    删除Rardar电影订阅
    """
-    subscribe = await Subscribe.async_get(db, mid)
+    subscribe = Subscribe.get(db, mid)
    if subscribe:
-        await subscribe.async_delete(db, mid)
+        subscribe.delete(db, mid)
        return schemas.Response(success=True)
    else:
        raise HTTPException(
@@ -382,7 +378,7 @@ async def arr_remove_movie(mid: int, _: Annotated[str, Depends(verify_apikey)],


@arr_router.get("/series", summary="所有剧集", response_model=List[schemas.SonarrSeries])
-async def arr_series(_: Annotated[str, Depends(verify_apikey)], db: AsyncSession = Depends(get_async_db)) -> Any:
+def arr_series(_: str = Depends(verify_apikey), db: Session = Depends(get_db)) -> Any:
    """
    查询Sonarr剧集
    """
@@ -490,7 +486,7 @@ async def arr_series(_: Annotated[str, Depends(verify_apikey)], db: AsyncSession
    """
    # 查询所有电视剧订阅
    result = []
-    subscribes = await Subscribe.async_list(db)
+    subscribes = Subscribe.list(db)
    for subscribe in subscribes:
        if subscribe.type != MediaType.TV.value:
            continue
@@ -518,102 +514,100 @@ async def arr_series(_: Annotated[str, Depends(verify_apikey)], db: AsyncSession


@arr_router.get("/series/lookup", summary="查询剧集")
-def arr_series_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
+def arr_series_lookup(term: str, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
    """
    查询Sonarr剧集 term: `tvdb:${id}` title
    """
-    # 季信息
-    seas: List[int] = []
-    # tvdbid 列表
-    tvdbids: List[int] = []
    # 获取TVDBID
    if not term.startswith("tvdb:"):
-        title = term.replace("+", " ")
-        tvdbids = TvdbChain().get_tvdbid_by_name(title=title)
-    else:
-        tvdbid = int(term.replace("tvdb:", ""))
-        tvdbids.append(tvdbid)
-
-    sonarr_series_list = []
-    for tvdbid in tvdbids:
-        # 查询TVDB信息
-        tvdbinfo = MediaChain().tvdb_info(tvdbid=tvdbid)
-        if not tvdbinfo:
-            continue
-
-        # 季信息(只取默认季类型，排除特别季)
-        sea_num = len([season for season in tvdbinfo.get('seasons') if
-                       season['type']['id'] == tvdbinfo.get('defaultSeasonType') and season['number'] > 0])
-        if sea_num:
-            seas = list(range(1, int(sea_num) + 1))
-
-        # 根据TVDB查询媒体信息
-        mediainfo = MediaChain().recognize_media(meta=MetaInfo(tvdbinfo.get('name')),
+        mediainfo = MediaChain().recognize_media(meta=MetaInfo(term),
                                                 mtype=MediaType.TV)
        if not mediainfo:
-            continue
-        # 查询是否存在
-        exists = MediaChain().media_exists(mediainfo)
-        if exists:
-            hasfile = True
-        else:
-            hasfile = False
+            return [SonarrSeries()]
+        tvdbid = mediainfo.tvdb_id
+        if not tvdbid:
+            return [SonarrSeries()]
+    else:
+        mediainfo = None
+        tvdbid = int(term.replace("tvdb:", ""))

-        # 查询订阅信息
-        seasons: List[dict] = []
-        subscribes = Subscribe.get_by_tmdbid(db, mediainfo.tmdb_id)
-        if subscribes:
-            # 已监控
-            monitored = True
-            # 已监控季
-            sub_seas = [sub.season for sub in subscribes]
-            for sea in seas:
-                if sea in sub_seas:
-                    seasons.append({
-                        "seasonNumber": sea,
-                        "monitored": True,
-                    })
-                else:
-                    seasons.append({
-                        "seasonNumber": sea,
-                        "monitored": False,
-                    })
-            subid = subscribes[-1].id
-        else:
-            subid = None
-            monitored = False
-            for sea in seas:
+    # 查询TVDB信息
+    tvdbinfo = MediaChain().tvdb_info(tvdbid=tvdbid)
+    if not tvdbinfo:
+        return [SonarrSeries()]
+
+    # 季信息
+    seas: List[int] = []
+    sea_num = tvdbinfo.get('season')
+    if sea_num:
+        seas = list(range(1, int(sea_num) + 1))
+
+    # 根据TVDB查询媒体信息
+    if not mediainfo:
+        mediainfo = MediaChain().recognize_media(meta=MetaInfo(tvdbinfo.get('seriesName')),
+                                                 mtype=MediaType.TV)
+
+    # 查询是否存在
+    exists = MediaChain().media_exists(mediainfo)
+    if exists:
+        hasfile = True
+    else:
+        hasfile = False
+
+    # 查询订阅信息
+    seasons: List[dict] = []
+    subscribes = Subscribe.get_by_tmdbid(db, mediainfo.tmdb_id)
+    if subscribes:
+        # 已监控
+        monitored = True
+        # 已监控季
+        sub_seas = [sub.season for sub in subscribes]
+        for sea in seas:
+            if sea in sub_seas:
+                seasons.append({
+                    "seasonNumber": sea,
+                    "monitored": True,
+                })
+            else:
                seasons.append({
                    "seasonNumber": sea,
                    "monitored": False,
                })
-        sonarr_series = SonarrSeries(
-            id=subid,
-            title=mediainfo.title,
-            seasonCount=len(seasons),
-            seasons=seasons,
-            remotePoster=mediainfo.get_poster_image(),
-            year=mediainfo.year,
-            tmdbId=mediainfo.tmdb_id,
-            tvdbId=tvdbid,
-            imdbId=mediainfo.imdb_id,
-            profileId=1,
-            languageProfileId=1,
-            monitored=monitored,
-            hasFile=hasfile,
-        )
-        sonarr_series_list.append(sonarr_series)
+        subid = subscribes[-1].id
+    else:
+        subid = None
+        monitored = False
+        for sea in seas:
+            seasons.append({
+                "seasonNumber": sea,
+                "monitored": False,
+            })

-    return sonarr_series_list if sonarr_series_list else [SonarrSeries()]
+    return [SonarrSeries(
+        id=subid,
+        title=mediainfo.title,
+        seasonCount=len(seasons),
+        seasons=seasons,
+        remotePoster=mediainfo.get_poster_image(),
+        year=mediainfo.year,
+        tmdbId=mediainfo.tmdb_id,
+        tvdbId=mediainfo.tvdb_id,
+        imdbId=mediainfo.imdb_id,
+        profileId=1,
+        languageProfileId=1,
+        qualityProfileId=1,
+        isAvailable=True,
+        monitored=monitored,
+        hasFile=hasfile
+    )]


@arr_router.get("/series/{tid}", summary="剧集详情")
-async def arr_serie(tid: int, _: Annotated[str, Depends(verify_apikey)],
-                    db: AsyncSession = Depends(get_async_db)) -> Any:
+def arr_serie(tid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
    """
    查询Sonarr剧集
    """
-    subscribe = await Subscribe.async_get(db, tid)
+    subscribe = Subscribe.get(db, tid)
    if subscribe:
        return SonarrSeries(
            id=subscribe.id,
@@ -643,17 +637,17 @@ async def arr_serie(tid: int, _: Annotated[str, Depends(verify_apikey)],


@arr_router.post("/series", summary="新增剧集订阅")
-async def arr_add_series(tv: schemas.SonarrSeries,
-                         _: Annotated[str, Depends(verify_apikey)],
-                         db: AsyncSession = Depends(get_async_db)) -> Any:
+def arr_add_series(tv: schemas.SonarrSeries,
+                   db: Session = Depends(get_db),
+                   _: str = Depends(verify_apikey)) -> Any:
    """
    新增Sonarr剧集订阅
    """
    # 检查订阅是否存在
    left_seasons = []
    for season in tv.seasons:
-        subscribe = await Subscribe.async_get_by_tmdbid(db, tmdbid=tv.tmdbId,
-                                                        season=season.get("seasonNumber"))
+        subscribe = Subscribe.get_by_tmdbid(db, tmdbid=tv.tmdbId,
+                                            season=season.get("seasonNumber"))
        if subscribe:
            continue
        left_seasons.append(season)
@@ -668,12 +662,12 @@ async def arr_add_series(tv: schemas.SonarrSeries,
    for season in left_seasons:
        if not season.get("monitored"):
            continue
-        sid, message = await SubscribeChain().async_add(title=tv.title,
-                                                        year=tv.year,
-                                                        season=season.get("seasonNumber"),
-                                                        tmdbid=tv.tmdbId,
-                                                        mtype=MediaType.TV,
-                                                        username="Seerr")
+        sid, message = SubscribeChain().add(title=tv.title,
+                                            year=tv.year,
+                                            season=season.get("seasonNumber"),
+                                            tmdbid=tv.tmdbId,
+                                            mtype=MediaType.TV,
+                                            username="Seerr")

    if sid:
        return {
@@ -686,23 +680,14 @@ async def arr_add_series(tv: schemas.SonarrSeries,
        )


-@arr_router.put("/series", summary="更新剧集订阅")
-async def arr_update_series(tv: schemas.SonarrSeries, _: Annotated[str, Depends(verify_apikey)]) -> Any:
-    """
-    更新Sonarr剧集订阅
-    """
-    return await arr_add_series(tv)
-
-
@arr_router.delete("/series/{tid}", summary="删除剧集订阅")
-async def arr_remove_series(tid: int, _: Annotated[str, Depends(verify_apikey)],
-                            db: AsyncSession = Depends(get_async_db)) -> Any:
+def arr_remove_series(tid: int, db: Session = Depends(get_db), _: str = Depends(verify_apikey)) -> Any:
    """
    删除Sonarr剧集订阅
    """
-    subscribe = await Subscribe.async_get(db, tid)
+    subscribe = Subscribe.get(db, tid)
    if subscribe:
-        await subscribe.async_delete(db, tid)
+        subscribe.delete(db, tid)
        return schemas.Response(success=True)
    else:
        raise HTTPException(
--- a/app/api/servcookie.py
+++ b/app/api/servcookie.py
@@ -1,9 +1,9 @@
 import gzip
 import json
-from typing import Annotated, Callable, Any, Dict, Optional
+from hashlib import md5
+from typing import Annotated, Callable
+from typing import Any, Dict, Optional

-import aiofiles
-from anyio import Path as AsyncPath
 from fastapi import APIRouter, Depends, HTTPException, Path, Request, Response
 from fastapi.responses import PlainTextResponse
 from fastapi.routing import APIRoute
@@ -11,7 +11,7 @@ from fastapi.routing import APIRoute
 from app import schemas
 from app.core.config import settings
 from app.log import logger
-from app.utils.crypto import CryptoJsUtils, HashUtils
+from app.utils.common import decrypt


 class GzipRequest(Request):
@@ -21,7 +21,7 @@ class GzipRequest(Request):
            body = await super().body()
            if "gzip" in self.headers.getlist("Content-Encoding"):
                body = gzip.decompress(body)
-            self._body = body  # noqa
+            self._body = body
        return self._body


@@ -47,17 +47,17 @@ async def verify_server_enabled():


 cookie_router = APIRouter(route_class=GzipRoute,
-                          tags=["servcookie"],
+                          tags=['servcookie'],
                          dependencies=[Depends(verify_server_enabled)])


@cookie_router.get("/", response_class=PlainTextResponse)
-async def get_root():
+def get_root():
    return "Hello MoviePilot! COOKIECLOUD API ROOT = /cookiecloud"


@cookie_router.post("/", response_class=PlainTextResponse)
-async def post_root():
+def post_root():
    return "Hello MoviePilot! COOKIECLOUD API ROOT = /cookiecloud"


@@ -66,31 +66,31 @@ async def update_cookie(req: schemas.CookieData):
    """
    上传Cookie数据
    """
-    file_path = AsyncPath(settings.COOKIE_PATH) / f"{req.uuid}.json"
+    file_path = settings.COOKIE_PATH / f"{req.uuid}.json"
    content = json.dumps({"encrypted": req.encrypted})
-    async with aiofiles.open(file_path, encoding="utf-8", mode="w") as file:
-        await file.write(content)
-    async with aiofiles.open(file_path, encoding="utf-8", mode="r") as file:
-        read_content = await file.read()
+    with open(file_path, encoding="utf-8", mode="w") as file:
+        file.write(content)
+    with open(file_path, encoding="utf-8", mode="r") as file:
+        read_content = file.read()
    if read_content == content:
        return {"action": "done"}
    else:
        return {"action": "error"}


-async def load_encrypt_data(uuid: str) -> Dict[str, Any]:
+def load_encrypt_data(uuid: str) -> Dict[str, Any]:
    """
    加载本地加密原始数据
    """
-    file_path = AsyncPath(settings.COOKIE_PATH) / f"{uuid}.json"
+    file_path = settings.COOKIE_PATH / f"{uuid}.json"

    # 检查文件是否存在
    if not file_path.exists():
        raise HTTPException(status_code=404, detail="Item not found")

    # 读取文件
-    async with aiofiles.open(file_path, encoding="utf-8", mode="r") as file:
-        read_content = await file.read()
+    with open(file_path, encoding="utf-8", mode="r") as file:
+        read_content = file.read()
    data = json.loads(read_content.encode("utf-8"))
    return data

@@ -100,14 +100,15 @@ def get_decrypted_cookie_data(uuid: str, password: str,
    """
    加载本地加密数据并解密为Cookie
    """
-    combined_string = f"{uuid}-{password}"
-    aes_key = HashUtils.md5(combined_string)[:16].encode("utf-8")
+    key_md5 = md5()
+    key_md5.update((uuid + '-' + password).encode('utf-8'))
+    aes_key = (key_md5.hexdigest()[:16]).encode('utf-8')

    if encrypted:
        try:
-            decrypted_data = CryptoJsUtils.decrypt(encrypted, aes_key).decode("utf-8")
+            decrypted_data = decrypt(encrypted, aes_key).decode('utf-8')
            decrypted_data = json.loads(decrypted_data)
-            if "cookie_data" in decrypted_data:
+            if 'cookie_data' in decrypted_data:
                return decrypted_data
        except Exception as e:
            logger.error(f"解密Cookie数据失败：{str(e)}")
@@ -122,7 +123,7 @@ async def get_cookie(
    """
    GET 下载加密数据
    """
-    return await load_encrypt_data(uuid)
+    return load_encrypt_data(uuid)


@cookie_router.post("/get/{uuid}")
@@ -132,5 +133,5 @@ async def post_cookie(
    """
    POST 下载加密数据
    """
-    data = await load_encrypt_data(uuid)
+    data = load_encrypt_data(uuid)
    return get_decrypted_cookie_data(uuid, request.password, data["encrypted"])
--- a/app/chain/init.py
+++ b/app/chain/init.py
--- a/app/chain/bangumi.py
+++ b/app/chain/bangumi.py
@@ -3,11 +3,12 @@ from typing import Optional, List
 from app import schemas
 from app.chain import ChainBase
 from app.core.context import MediaInfo
+from app.utils.singleton import Singleton


-class BangumiChain(ChainBase):
+class BangumiChain(ChainBase, metaclass=Singleton):
    """
-    Bangumi处理链
+    Bangumi处理链，单例运行
    """

    def calendar(self) -> Optional[List[MediaInfo]]:
@@ -16,12 +17,6 @@ class BangumiChain(ChainBase):
        """
        return self.run_module("bangumi_calendar")

-    def discover(self, **kwargs) -> Optional[List[MediaInfo]]:
-        """
-        发现Bangumi番剧
-        """
-        return self.run_module("bangumi_discover", **kwargs)
-
    def bangumi_info(self, bangumiid: int) -> Optional[dict]:
        """
        获取Bangumi信息
@@ -57,51 +52,3 @@ class BangumiChain(ChainBase):
        :param person_id:  人物ID
        """
        return self.run_module("bangumi_person_credits", person_id=person_id)
-
-    async def async_calendar(self) -> Optional[List[MediaInfo]]:
-        """
-        获取Bangumi每日放送（异步版本）
-        """
-        return await self.async_run_module("async_bangumi_calendar")
-
-    async def async_discover(self, **kwargs) -> Optional[List[MediaInfo]]:
-        """
-        发现Bangumi番剧（异步版本）
-        """
-        return await self.async_run_module("async_bangumi_discover", **kwargs)
-
-    async def async_bangumi_info(self, bangumiid: int) -> Optional[dict]:
-        """
-        获取Bangumi信息（异步版本）
-        :param bangumiid: BangumiID
-        :return: Bangumi信息
-        """
-        return await self.async_run_module("async_bangumi_info", bangumiid=bangumiid)
-
-    async def async_bangumi_credits(self, bangumiid: int) -> List[schemas.MediaPerson]:
-        """
-        根据BangumiID查询电影演职员表（异步版本）
-        :param bangumiid:  BangumiID
-        """
-        return await self.async_run_module("async_bangumi_credits", bangumiid=bangumiid)
-
-    async def async_bangumi_recommend(self, bangumiid: int) -> Optional[List[MediaInfo]]:
-        """
-        根据BangumiID查询推荐电影（异步版本）
-        :param bangumiid:  BangumiID
-        """
-        return await self.async_run_module("async_bangumi_recommend", bangumiid=bangumiid)
-
-    async def async_person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
-        """
-        根据人物ID查询Bangumi人物详情（异步版本）
-        :param person_id:  人物ID
-        """
-        return await self.async_run_module("async_bangumi_person_detail", person_id=person_id)
-
-    async def async_person_credits(self, person_id: int) -> Optional[List[MediaInfo]]:
-        """
-        根据人物ID查询人物参演作品（异步版本）
-        :param person_id:  人物ID
-        """
-        return await self.async_run_module("async_bangumi_person_credits", person_id=person_id)
--- a/app/chain/dashboard.py
+++ b/app/chain/dashboard.py
@@ -2,20 +2,21 @@ from typing import Optional, List

 from app import schemas
 from app.chain import ChainBase
+from app.utils.singleton import Singleton


-class DashboardChain(ChainBase):
+class DashboardChain(ChainBase, metaclass=Singleton):
    """
    各类仪表板统计处理链
    """
-    def media_statistic(self, server: Optional[str] = None) -> Optional[List[schemas.Statistic]]:
+    def media_statistic(self) -> Optional[List[schemas.Statistic]]:
        """
        媒体数量统计
        """
-        return self.run_module("media_statistic", server=server)
+        return self.run_module("media_statistic")

-    def downloader_info(self, downloader: Optional[str] = None) -> Optional[List[schemas.DownloaderInfo]]:
+    def downloader_info(self) -> Optional[List[schemas.DownloaderInfo]]:
        """
        下载器信息
        """
-        return self.run_module("downloader_info", downloader=downloader)
+        return self.run_module("downloader_info")
--- a/app/chain/douban.py
+++ b/app/chain/douban.py
@@ -4,11 +4,12 @@ from app import schemas
 from app.chain import ChainBase
 from app.core.context import MediaInfo
 from app.schemas import MediaType
+from app.utils.singleton import Singleton


-class DoubanChain(ChainBase):
+class DoubanChain(ChainBase, metaclass=Singleton):
    """
-    豆瓣处理链
+    豆瓣处理链，单例运行
    """

    def person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
@@ -18,7 +19,7 @@ class DoubanChain(ChainBase):
        """
        return self.run_module("douban_person_detail", person_id=person_id)

-    def person_credits(self, person_id: int, page: Optional[int] = 1) -> List[MediaInfo]:
+    def person_credits(self, person_id: int, page: int = 1) -> List[MediaInfo]:
        """
        根据人物ID查询人物参演作品
        :param person_id:  人物ID
@@ -26,7 +27,7 @@ class DoubanChain(ChainBase):
        """
        return self.run_module("douban_person_credits", person_id=person_id, page=page)

-    def movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+    def movie_top250(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        获取豆瓣电影TOP250
        :param page:  页码
@@ -34,26 +35,26 @@ class DoubanChain(ChainBase):
        """
        return self.run_module("movie_top250", page=page, count=count)

-    def movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+    def movie_showing(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        获取正在上映的电影
        """
        return self.run_module("movie_showing", page=page, count=count)

-    def tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+    def tv_weekly_chinese(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        获取本周中国剧集榜
        """
        return self.run_module("tv_weekly_chinese", page=page, count=count)

-    def tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+    def tv_weekly_global(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        获取本周全球剧集榜
        """
        return self.run_module("tv_weekly_global", page=page, count=count)

    def douban_discover(self, mtype: MediaType, sort: str, tags: str,
-                        page: Optional[int] = 0, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+                        page: int = 0, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        发现豆瓣电影、剧集
        :param mtype:  媒体类型
@@ -66,19 +67,19 @@ class DoubanChain(ChainBase):
        return self.run_module("douban_discover", mtype=mtype, sort=sort, tags=tags,
                               page=page, count=count)

-    def tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+    def tv_animation(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        获取动画剧集
        """
        return self.run_module("tv_animation", page=page, count=count)

-    def movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+    def movie_hot(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        获取热门电影
        """
        return self.run_module("movie_hot", page=page, count=count)

-    def tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+    def tv_hot(self, page: int = 1, count: int = 30) -> Optional[List[MediaInfo]]:
        """
        获取热门剧集
        """
@@ -111,111 +112,3 @@ class DoubanChain(ChainBase):
        :param doubanid:  豆瓣ID
        """
        return self.run_module("douban_tv_recommend", doubanid=doubanid)
-
-    async def async_person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
-        """
-        根据人物ID查询豆瓣人物详情（异步版本）
-        :param person_id:  人物ID
-        """
-        return await self.async_run_module("async_douban_person_detail", person_id=person_id)
-
-    async def async_person_credits(self, person_id: int, page: Optional[int] = 1) -> List[MediaInfo]:
-        """
-        根据人物ID查询人物参演作品（异步版本）
-        :param person_id:  人物ID
-        :param page:  页码
-        """
-        return await self.async_run_module("async_douban_person_credits", person_id=person_id, page=page)
-
-    async def async_movie_top250(self, page: Optional[int] = 1,
-                                 count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        获取豆瓣电影TOP250（异步版本）
-        :param page:  页码
-        :param count:  每页数量
-        """
-        return await self.async_run_module("async_movie_top250", page=page, count=count)
-
-    async def async_movie_showing(self, page: Optional[int] = 1,
-                                  count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        获取正在上映的电影（异步版本）
-        """
-        return await self.async_run_module("async_movie_showing", page=page, count=count)
-
-    async def async_tv_weekly_chinese(self, page: Optional[int] = 1,
-                                      count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        获取本周中国剧集榜（异步版本）
-        """
-        return await self.async_run_module("async_tv_weekly_chinese", page=page, count=count)
-
-    async def async_tv_weekly_global(self, page: Optional[int] = 1,
-                                     count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        获取本周全球剧集榜（异步版本）
-        """
-        return await self.async_run_module("async_tv_weekly_global", page=page, count=count)
-
-    async def async_douban_discover(self, mtype: MediaType, sort: str, tags: str,
-                                    page: Optional[int] = 0, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        发现豆瓣电影、剧集（异步版本）
-        :param mtype:  媒体类型
-        :param sort:  排序方式
-        :param tags:  标签
-        :param page:  页码
-        :param count:  数量
-        :return: 媒体信息列表
-        """
-        return await self.async_run_module("async_douban_discover", mtype=mtype, sort=sort, tags=tags,
-                                           page=page, count=count)
-
-    async def async_tv_animation(self, page: Optional[int] = 1,
-                                 count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        获取动画剧集（异步版本）
-        """
-        return await self.async_run_module("async_tv_animation", page=page, count=count)
-
-    async def async_movie_hot(self, page: Optional[int] = 1,
-                              count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        获取热门电影（异步版本）
-        """
-        return await self.async_run_module("async_movie_hot", page=page, count=count)
-
-    async def async_tv_hot(self, page: Optional[int] = 1,
-                           count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
-        """
-        获取热门剧集（异步版本）
-        """
-        return await self.async_run_module("async_tv_hot", page=page, count=count)
-
-    async def async_movie_credits(self, doubanid: str) -> Optional[List[schemas.MediaPerson]]:
-        """
-        根据TMDBID查询电影演职人员（异步版本）
-        :param doubanid:  豆瓣ID
-        """
-        return await self.async_run_module("async_douban_movie_credits", doubanid=doubanid)
-
-    async def async_tv_credits(self, doubanid: str) -> Optional[List[schemas.MediaPerson]]:
-        """
-        根据TMDBID查询电视剧演职人员（异步版本）
-        :param doubanid:  豆瓣ID
-        """
-        return await self.async_run_module("async_douban_tv_credits", doubanid=doubanid)
-
-    async def async_movie_recommend(self, doubanid: str) -> List[MediaInfo]:
-        """
-        根据豆瓣ID查询推荐电影（异步版本）
-        :param doubanid:  豆瓣ID
-        """
-        return await self.async_run_module("async_douban_movie_recommend", doubanid=doubanid)
-
-    async def async_tv_recommend(self, doubanid: str) -> List[MediaInfo]:
-        """
-        根据豆瓣ID查询推荐电视剧（异步版本）
-        :param doubanid:  豆瓣ID
-        """
-        return await self.async_run_module("async_douban_tv_recommend", doubanid=doubanid)
--- a/app/chain/download.py
+++ b/app/chain/download.py
@@ -8,8 +8,7 @@ from typing import List, Optional, Tuple, Set, Dict, Union

 from app import schemas
 from app.chain import ChainBase
-from app.core.cache import FileCache
-from app.core.config import settings, global_vars
+from app.core.config import settings
 from app.core.context import MediaInfo, TorrentInfo, Context
 from app.core.event import eventmanager, Event
 from app.core.meta import MetaBase
@@ -17,12 +16,11 @@ from app.core.metainfo import MetaInfo
 from app.db.downloadhistory_oper import DownloadHistoryOper
 from app.db.mediaserver_oper import MediaServerOper
 from app.helper.directory import DirectoryHelper
+from app.helper.message import MessageHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
-from app.schemas import ExistMediaInfo, FileURI, NotExistMediaInfo, DownloadingTorrent, Notification, ResourceSelectionEventData, \
-    ResourceDownloadEventData
-from app.schemas.types import MediaType, TorrentStatus, EventType, MessageChannel, NotificationType, ContentType, \
-    ChainEventType
+from app.schemas import ExistMediaInfo, NotExistMediaInfo, DownloadingTorrent, Notification
+from app.schemas.types import MediaType, TorrentStatus, EventType, MessageChannel, NotificationType
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils

@@ -32,17 +30,80 @@ class DownloadChain(ChainBase):
    下载处理链
    """

+    def __init__(self):
+        super().__init__()
+        self.torrent = TorrentHelper()
+        self.downloadhis = DownloadHistoryOper()
+        self.mediaserver = MediaServerOper()
+        self.directoryhelper = DirectoryHelper()
+        self.messagehelper = MessageHelper()
+
+    def post_download_message(self, meta: MetaBase, mediainfo: MediaInfo, torrent: TorrentInfo,
+                              channel: MessageChannel = None, userid: str = None, username: str = None,
+                              download_episodes: str = None):
+        """
+        发送添加下载的消息
+        :param meta: 元数据
+        :param mediainfo: 媒体信息
+        :param torrent: 种子信息
+        :param channel: 通知渠道
+        :param userid: 用户ID，指定时精确发送对应用户
+        :param username: 通知显示的下载用户信息
+        :param download_episodes: 下载的集数
+        """
+        msg_text = ""
+        if username:
+            msg_text = f"用户：{username}"
+        if torrent.site_name:
+            msg_text = f"{msg_text}\n站点：{torrent.site_name}"
+        if meta.resource_term:
+            msg_text = f"{msg_text}\n质量：{meta.resource_term}"
+        if torrent.size:
+            if str(torrent.size).replace(".", "").isdigit():
+                size = StringUtils.str_filesize(torrent.size)
+            else:
+                size = torrent.size
+            msg_text = f"{msg_text}\n大小：{size}"
+        if torrent.title:
+            msg_text = f"{msg_text}\n种子：{torrent.title}"
+        if torrent.pubdate:
+            msg_text = f"{msg_text}\n发布时间：{torrent.pubdate}"
+        if torrent.freedate:
+            msg_text = f"{msg_text}\n免费时间：{StringUtils.diff_time_str(torrent.freedate)}"
+        if torrent.seeders:
+            msg_text = f"{msg_text}\n做种数：{torrent.seeders}"
+        if torrent.uploadvolumefactor and torrent.downloadvolumefactor:
+            msg_text = f"{msg_text}\n促销：{torrent.volume_factor}"
+        if torrent.hit_and_run:
+            msg_text = f"{msg_text}\nHit&Run：是"
+        if torrent.labels:
+            msg_text = f"{msg_text}\n标签：{' '.join(torrent.labels)}"
+        if torrent.description:
+            html_re = re.compile(r'<[^>]+>', re.S)
+            description = html_re.sub('', torrent.description)
+            torrent.description = re.sub(r'<[^>]+>', '', description)
+            msg_text = f"{msg_text}\n描述：{torrent.description}"
+
+        self.post_message(Notification(
+            channel=channel,
+            mtype=NotificationType.Download,
+            userid=userid,
+            title=f"{mediainfo.title_year} "
+                  f"{'%s %s' % (meta.season, download_episodes) if download_episodes else meta.season_episode} 开始下载",
+            text=msg_text,
+            image=mediainfo.get_message_image(),
+            link=settings.MP_DOMAIN('/#/downloading')))
+
    def download_torrent(self, torrent: TorrentInfo,
                         channel: MessageChannel = None,
-                         source: Optional[str] = None,
                         userid: Union[str, int] = None
-                         ) -> Tuple[Optional[Union[str, bytes]], str, list]:
+                         ) -> Tuple[Optional[Union[Path, str]], str, list]:
        """
        下载种子文件，如果是磁力链，会返回磁力链接本身
-        :return: 种子内容，种子目录名，种子文件清单
+        :return: 种子路径，种子目录名，种子文件清单
        """

-        def __get_redict_url(url: str, ua: Optional[str] = None, cookie: Optional[str] = None) -> Optional[str]:
+        def __get_redict_url(url: str, ua: str = None, cookie: str = None) -> Optional[str]:
            """
            获取下载链接， url格式：[base64]url
            """
@@ -61,8 +122,6 @@ class DownloadChain(ChainBase):
                # 是否使用cookie
                if not req_params.get('cookie'):
                    cookie = None
-                # 代理
-                proxy = req_params.get('proxy')
                # 请求头
                if req_params.get('header'):
                    headers = req_params.get('header')
@@ -73,16 +132,14 @@ class DownloadChain(ChainBase):
                    res = RequestUtils(
                        ua=ua,
                        cookies=cookie,
-                        headers=headers,
-                        proxies=settings.PROXY if proxy else None
+                        headers=headers
                    ).get_res(url, params=req_params.get('params'))
                else:
                    # POST请求
                    res = RequestUtils(
                        ua=ua,
                        cookies=cookie,
-                        headers=headers,
-                        proxies=settings.PROXY if proxy else None
+                        headers=headers
                    ).post_res(url, params=req_params.get('params'))
                if not res:
                    return None
@@ -118,21 +175,20 @@ class DownloadChain(ChainBase):
            logger.error(f"{torrent.title} 无法获取下载地址：{torrent.enclosure}！")
            return None, "", []
        # 下载种子文件
-        _, content, download_folder, files, error_msg = TorrentHelper().download_torrent(
+        torrent_file, content, download_folder, files, error_msg = self.torrent.download_torrent(
            url=torrent_url,
            cookie=site_cookie,
-            ua=torrent.site_ua or settings.USER_AGENT,
+            ua=torrent.site_ua,
            proxy=torrent.site_proxy)

        if isinstance(content, str):
            # 磁力链
            return content, "", []

-        if not content:
+        if not torrent_file:
            logger.error(f"下载种子文件失败：{torrent.title} - {torrent_url}")
            self.post_message(Notification(
                channel=channel,
-                source=source if channel else None,
                mtype=NotificationType.Manual,
                title=f"{torrent.title} 种子下载失败！",
                text=f"错误信息：{error_msg}\n站点：{torrent.site_name}",
@@ -140,160 +196,102 @@ class DownloadChain(ChainBase):
            return None, "", []

        # 返回 种子文件路径，种子目录名，种子文件清单
-        return content, download_folder, files
+        return torrent_file, download_folder, files

-    def download_single(self, context: Context,
-                        torrent_file: Path = None,
-                        torrent_content: Optional[Union[str, bytes]] = None,
+    def download_single(self, context: Context, torrent_file: Path = None,
                        episodes: Set[int] = None,
                        channel: MessageChannel = None,
-                        source: Optional[str] = None,
-                        downloader: Optional[str] = None,
-                        save_path: Optional[str] = None,
+                        save_path: str = None,
                        userid: Union[str, int] = None,
-                        username: Optional[str] = None,
-                        label: Optional[str] = None) -> Optional[str]:
+                        username: str = None) -> Optional[str]:
        """
        下载及发送通知
        :param context: 资源上下文
        :param torrent_file: 种子文件路径
-        :param torrent_content: 种子内容（磁力链或种子文件内容）
        :param episodes: 需要下载的集数
        :param channel: 通知渠道
-        :param source: 来源（消息通知、Subscribe、Manual等）
-        :param downloader: 下载器
-        :param save_path: 保存路径, 支持<storage>:<path>, 如rclone:/MP, smb:/server/share/Movies等
+        :param save_path: 保存路径
        :param userid: 用户ID
        :param username: 调用下载的用户名/插件名
-        :param label: 自定义标签
        """
        _torrent = context.torrent_info
        _media = context.media_info
        _meta = context.meta_info
-        _site_downloader = _torrent.site_downloader
-
-        # 发送资源下载事件，允许外部拦截下载
-        event_data = ResourceDownloadEventData(
-            context=context,
-            episodes=episodes or context.meta_info.episode_list,
-            channel=channel,
-            origin=source,
-            downloader=downloader,
-            options={
-                "save_path": save_path,
-                "userid": userid,
-                "username": username,
-                "media_category": _media.category
-            }
-        )
-        # 触发资源下载事件
-        event = eventmanager.send_event(ChainEventType.ResourceDownload, event_data)
-        if event and event.event_data:
-            event_data: ResourceDownloadEventData = event.event_data
-            # 如果事件被取消，跳过资源下载
-            if event_data.cancel:
-                logger.debug(
-                    f"Resource download canceled by event: {event_data.source},"
-                    f"Reason: {event_data.reason}")
-                return None
-            # 如果事件修改了下载路径，使用新路径
-            if event_data.options and event_data.options.get("save_path"):
-                save_path = event_data.options.get("save_path")

        # 补充完整的media数据
        if not _media.genre_ids:
            new_media = self.recognize_media(mtype=_media.type, tmdbid=_media.tmdb_id,
-                                             doubanid=_media.douban_id, bangumiid=_media.bangumi_id,
-                                             episode_group=_media.episode_group)
+                                             doubanid=_media.douban_id, bangumiid=_media.bangumi_id)
            if new_media:
                _media = new_media

        # 实际下载的集数
        download_episodes = StringUtils.format_ep(list(episodes)) if episodes else None
        _folder_name = ""
-        if not torrent_file and not torrent_content:
+        if not torrent_file:
            # 下载种子文件，得到的可能是文件也可能是磁力链
-            torrent_content, _folder_name, _file_list = self.download_torrent(_torrent,
-                                                                              channel=channel,
-                                                                              source=source,
-                                                                              userid=userid)
-        elif torrent_file:
-            if torrent_file.exists():
-                torrent_content = torrent_file.read_bytes()
-            else:
-                # 缓存处理器
-                cache_backend = FileCache()
-                # 读取缓存的种子文件
-                torrent_content = cache_backend.get(torrent_file.as_posix(), region="torrents")
+            content, _folder_name, _file_list = self.download_torrent(_torrent,
+                                                                      channel=channel,
+                                                                      userid=userid)
+            if not content:
+                return None
+        else:
+            content = torrent_file
+            # 获取种子文件的文件夹名和文件清单
+            _folder_name, _file_list = self.torrent.get_torrent_info(torrent_file)

-        if not torrent_content:
-            return None
-
-        # 获取种子文件的文件夹名和文件清单
-        _folder_name, _file_list = TorrentHelper().get_fileinfo_from_torrent_content(torrent_content)
-
-        storage = 'local'
        # 下载目录
        if save_path:
-            download_dir = Path(save_path)
+            # 有自定义下载目录时，尝试匹配目录配置
+            dir_info = self.directoryhelper.get_download_dir(_media, to_path=Path(save_path))
        else:
            # 根据媒体信息查询下载目录配置
-            dir_info = DirectoryHelper().get_dir(_media, include_unsorted=True)
-            storage = dir_info.storage if dir_info else storage
-            # 拼装子目录
-            if dir_info:
-                # 一级目录
-                if not dir_info.media_type and dir_info.download_type_folder:
-                    # 一级自动分类
-                    download_dir = Path(dir_info.download_path) / _media.type.value
-                else:
-                    # 一级不分类
-                    download_dir = Path(dir_info.download_path)
-
-                # 二级目录
-                if not dir_info.media_category and dir_info.download_category_folder and _media and _media.category:
-                    # 二级自动分类
-                    download_dir = download_dir / _media.category
+            dir_info = self.directoryhelper.get_download_dir(_media)
+        # 拼装子目录
+        if dir_info:
+            # 一级目录
+            if not dir_info.media_type and dir_info.auto_category:
+                # 一级自动分类
+                download_dir = Path(dir_info.path) / _media.type.value
            else:
-                # 未找到下载目录，且没有自定义下载目录
-                logger.error(f"未找到下载目录：{_media.type.value} {_media.title_year}")
-                self.messagehelper.put(f"{_media.type.value} {_media.title_year} 未找到下载目录！",
-                                       title="下载失败", role="system")
-                return None
-            fileURI = FileURI(storage=storage, path=download_dir.as_posix())
-            download_dir = Path(fileURI.uri)
+                # 一级不分类
+                download_dir = Path(dir_info.path)
+
+            # 二级目录
+            if not dir_info.category and dir_info.auto_category and _media and _media.category:
+                # 二级自动分类
+                download_dir = download_dir / _media.category
+        elif save_path:
+            # 自定义下载目录
+            download_dir = Path(save_path)
+        else:
+            # 未找到下载目录，且没有自定义下载目录
+            logger.error(f"未找到下载目录：{_media.type.value} {_media.title_year}")
+            self.messagehelper.put(f"{_media.type.value} {_media.title_year} 未找到下载目录！",
+                                   title="下载失败", role="system")
+            return None

        # 添加下载
-        result: Optional[tuple] = self.download(content=torrent_content,
+        result: Optional[tuple] = self.download(content=content,
                                                cookie=_torrent.site_cookie,
                                                episodes=episodes,
                                                download_dir=download_dir,
-                                                category=_media.category,
-                                                label=label,
-                                                downloader=downloader or _site_downloader)
+                                                category=_media.category)
        if result:
-            _downloader, _hash, _layout, error_msg = result
+            _hash, error_msg = result
        else:
-            _downloader, _hash, _layout, error_msg = None, None, None, "未找到下载器"
+            _hash, error_msg = None, "未知错误"

        if _hash:
-            # `不创建子文件夹` 或 `不存在子文件夹`
-            if _layout == "NoSubfolder" or not _folder_name:
-                # 下载路径记录至文件
-                download_path = download_dir / _file_list[0] if _file_list else download_dir
-            # 原始布局
-            elif _folder_name:
+            # 下载文件路径
+            if _folder_name:
                download_path = download_dir / _folder_name
-            # 创建子文件夹
            else:
-                download_path = download_dir / Path(_file_list[0]).stem if _file_list else download_dir
-            # 文件保存路径
-            _save_path = download_dir if _layout == "NoSubfolder" or not _folder_name else download_path
+                download_path = download_dir / _file_list[0] if _file_list else download_dir

            # 登记下载记录
-            downloadhis = DownloadHistoryOper()
-            downloadhis.add(
-                path=download_path.as_posix(),
+            self.downloadhis.add(
+                path=str(download_path),
                type=_media.type.value,
                title=_media.title,
                year=_media.year,
@@ -304,7 +302,6 @@ class DownloadChain(ChainBase):
                seasons=_meta.season,
                episodes=download_episodes or _meta.episode,
                image=_media.get_backdrop_image(),
-                downloader=_downloader,
                download_hash=_hash,
                torrent_name=_torrent.title,
                torrent_description=_torrent.description,
@@ -312,10 +309,7 @@ class DownloadChain(ChainBase):
                userid=userid,
                username=username,
                channel=channel.value if channel else None,
-                date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
-                media_category=_media.category,
-                episode_group=_media.episode_group,
-                note={"source": source}
+                date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            )

            # 登记下载文件
@@ -329,47 +323,29 @@ class DownloadChain(ChainBase):
                        continue
                # 只处理视频格式
                if not Path(file).suffix \
-                        or Path(file).suffix.lower() not in settings.RMT_MEDIAEXT:
+                        or Path(file).suffix not in settings.RMT_MEDIAEXT:
                    continue
                files_to_add.append({
                    "download_hash": _hash,
-                    "downloader": _downloader,
-                    "fullpath": (_save_path / file).as_posix(),
-                    "savepath": _save_path.as_posix(),
+                    "downloader": settings.DEFAULT_DOWNLOADER,
+                    "fullpath": str(download_dir / _folder_name / file),
+                    "savepath": str(download_dir / _folder_name),
                    "filepath": file,
                    "torrentname": _meta.org_string,
                })
            if files_to_add:
-                downloadhis.add_files(files_to_add)
+                self.downloadhis.add_files(files_to_add)

-            # 下载成功发送消息
-            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,
-                mediainfo=_media,
-                torrentinfo=_torrent,
-                download_episodes=download_episodes,
-                username=username,
-            )
+            # 发送消息（群发，不带channel和userid）
+            self.post_download_message(meta=_meta, mediainfo=_media, torrent=_torrent,
+                                       username=username, download_episodes=download_episodes)
            # 下载成功后处理
-            self.download_added(context=context, download_dir=download_dir, torrent_content=torrent_content)
+            self.download_added(context=context, download_dir=download_dir, torrent_path=torrent_file)
            # 广播事件
            self.eventmanager.send_event(EventType.DownloadAdded, {
                "hash": _hash,
                "context": context,
-                "username": username,
-                "downloader": _downloader,
-                "episodes": episodes or _meta.episode_list,
-                "source": source
+                "username": username
            })
        else:
            # 下载失败
@@ -378,7 +354,6 @@ class DownloadChain(ChainBase):
            # 只发送给对应渠道和用户
            self.post_message(Notification(
                channel=channel,
-                source=source if channel else None,
                mtype=NotificationType.Manual,
                title="添加下载任务失败：%s %s"
                      % (_media.title_year, _meta.season_episode),
@@ -392,23 +367,19 @@ class DownloadChain(ChainBase):
    def batch_download(self,
                       contexts: List[Context],
                       no_exists: Dict[Union[int, str], Dict[int, NotExistMediaInfo]] = None,
-                       save_path: Optional[str] = None,
+                       save_path: str = None,
                       channel: MessageChannel = None,
-                       source: Optional[str] = None,
-                       userid: Optional[str] = None,
-                       username: Optional[str] = None,
-                       downloader: Optional[str] = None
+                       userid: str = None,
+                       username: str = None
                       ) -> Tuple[List[Context], Dict[Union[int, str], Dict[int, NotExistMediaInfo]]]:
        """
        根据缺失数据，自动种子列表中组合择优下载
        :param contexts:  资源上下文列表
        :param no_exists:  缺失的剧集信息
-        :param save_path:  保存路径, 支持<storage>:<path>, 如rclone:/MP, smb:/server/share/Movies等
+        :param save_path:  保存路径
        :param channel:  通知渠道
-        :param source:  来源（消息通知、订阅、手工下载等）
        :param userid:  用户ID
        :param username: 调用下载的用户名/插件名
-        :param downloader: 下载器
        :return: 已经下载的资源列表、剩余未下载到的剧集 no_exists[tmdb_id/douban_id] = {season: NotExistMediaInfo}
        """
        # 已下载的项目
@@ -469,41 +440,22 @@ class DownloadChain(ChainBase):
                return 9999
            return no_exist[season].total_episode

-        # 发送资源选择事件，允许外部修改上下文数据
-        logger.debug(f"Initial contexts: {len(contexts)} items, Downloader: {downloader}")
-        event_data = ResourceSelectionEventData(
-            contexts=contexts,
-            downloader=downloader,
-            origin=source
-        )
-        event = eventmanager.send_event(ChainEventType.ResourceSelection, event_data)
-        # 如果事件修改了上下文数据，使用更新后的数据
-        if event and event.event_data:
-            event_data: ResourceSelectionEventData = event.event_data
-            if event_data.updated and event_data.updated_contexts is not None:
-                logger.debug(f"Contexts updated by event: "
-                             f"{len(event_data.updated_contexts)} items (source: {event_data.source})")
-                contexts = event_data.updated_contexts
-
        # 分组排序
        contexts = TorrentHelper().sort_group_torrents(contexts)

        # 如果是电影，直接下载
        for context in contexts:
-            if global_vars.is_system_stopped:
-                break
            if context.media_info.type == MediaType.MOVIE:
                logger.info(f"开始下载电影 {context.torrent_info.title} ...")
                if self.download_single(context, save_path=save_path, channel=channel,
-                                        source=source, userid=userid, username=username,
-                                        downloader=downloader):
+                                        userid=userid, username=username):
                    # 下载成功
                    logger.info(f"{context.torrent_info.title} 添加下载成功")
                    downloaded_list.append(context)

        # 电视剧整季匹配
+        logger.info(f"开始匹配电视剧整季：{no_exists}")
        if no_exists:
-            logger.info(f"开始匹配电视剧整季：{no_exists}")
            # 先把整季缺失的拿出来，看是否刚好有所有季都满足的种子 {tmdbid: [seasons]}
            need_seasons: Dict[int, list] = {}
            for need_mid, need_tv in no_exists.items():
@@ -520,8 +472,6 @@ class DownloadChain(ChainBase):
            for need_mid, need_season in need_seasons.items():
                # 循环种子
                for context in contexts:
-                    if global_vars.is_system_stopped:
-                        break
                    # 媒体信息
                    media = context.media_info
                    # 识别元数据
@@ -556,7 +506,7 @@ class DownloadChain(ChainBase):
                                if isinstance(content, str):
                                    logger.warn(f"{meta.org_string} 下载地址是磁力链，无法确定种子文件集数")
                                    continue
-                                torrent_episodes = TorrentHelper().get_torrent_episodes(torrent_files)
+                                torrent_episodes = self.torrent.get_torrent_episodes(torrent_files)
                                logger.info(f"{meta.org_string} 解析种子文件集数为 {torrent_episodes}")
                                if not torrent_episodes:
                                    continue
@@ -575,21 +525,18 @@ class DownloadChain(ChainBase):
                                    logger.info(f"开始下载 {torrent.title} ...")
                                    download_id = self.download_single(
                                        context=context,
-                                        torrent_content=content,
+                                        torrent_file=content if isinstance(content, Path) else None,
                                        save_path=save_path,
                                        channel=channel,
-                                        source=source,
                                        userid=userid,
-                                        username=username,
-                                        downloader=downloader
+                                        username=username
                                    )
                            else:
                                # 下载
                                logger.info(f"开始下载 {torrent.title} ...")
-                                download_id = self.download_single(context, save_path=save_path,
-                                                                   channel=channel, source=source,
-                                                                   userid=userid, username=username,
-                                                                   downloader=downloader)
+                                download_id = self.download_single(context,
+                                                                   save_path=save_path, channel=channel,
+                                                                   userid=userid, username=username)

                            if download_id:
                                # 下载成功
@@ -604,8 +551,8 @@ class DownloadChain(ChainBase):
                                    # 全部下载完成
                                    break
        # 电视剧季内的集匹配
+        logger.info(f"开始电视剧完整集匹配：{no_exists}")
        if no_exists:
-            logger.info(f"开始电视剧完整集匹配：{no_exists}")
            # TMDBID列表
            need_tv_list = list(no_exists)
            for need_mid in need_tv_list:
@@ -629,8 +576,6 @@ class DownloadChain(ChainBase):
                        need_episodes = list(range(start_episode, total_episode + 1))
                    # 循环种子
                    for context in contexts:
-                        if global_vars.is_system_stopped:
-                            break
                        # 媒体信息
                        media = context.media_info
                        # 识别元数据
@@ -657,10 +602,9 @@ class DownloadChain(ChainBase):
                            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)
+                                download_id = self.download_single(context,
+                                                                   save_path=save_path, channel=channel,
+                                                                   userid=userid, username=username)
                                if download_id:
                                    # 下载成功
                                    logger.info(f"{meta.title} 添加下载成功")
@@ -673,8 +617,8 @@ class DownloadChain(ChainBase):
                                    logger.info(f"季 {need_season} 剩余需要集：{need_episodes}")

        # 仍然缺失的剧集，从整季中选择需要的集数文件下载，仅支持QB和TR
+        logger.info(f"开始电视剧多集拆包匹配：{no_exists}")
        if no_exists:
-            logger.info(f"开始电视剧多集拆包匹配：{no_exists}")
            # TMDBID列表
            no_exists_list = list(no_exists)
            for need_mid in no_exists_list:
@@ -697,8 +641,6 @@ class DownloadChain(ChainBase):
                        continue
                    # 循环种子
                    for context in contexts:
-                        if global_vars.is_system_stopped:
-                            break
                        # 媒体信息
                        media = context.media_info
                        # 识别元数据
@@ -730,7 +672,7 @@ class DownloadChain(ChainBase):
                                logger.warn(f"{meta.org_string} 下载地址是磁力链，无法解析种子文件集数")
                                continue
                            # 种子全部集
-                            torrent_episodes = TorrentHelper().get_torrent_episodes(torrent_files)
+                            torrent_episodes = self.torrent.get_torrent_episodes(torrent_files)
                            logger.info(f"{torrent.site_name} - {meta.org_string} 解析种子文件集数：{torrent_episodes}")
                            # 选中的集
                            selected_episodes = set(torrent_episodes).intersection(set(need_episodes))
@@ -742,14 +684,12 @@ class DownloadChain(ChainBase):
                            logger.info(f"开始下载 {torrent.title} ...")
                            download_id = self.download_single(
                                context=context,
-                                torrent_content=content,
+                                torrent_file=content if isinstance(content, Path) else None,
                                episodes=selected_episodes,
                                save_path=save_path,
                                channel=channel,
-                                source=source,
                                userid=userid,
-                                username=username,
-                                downloader=downloader
+                                username=username
                            )
                            if not download_id:
                                continue
@@ -819,12 +759,11 @@ class DownloadChain(ChainBase):
        if not totals:
            totals = {}

-        mediaserver = MediaServerOper()
        if mediainfo.type == MediaType.MOVIE:
            # 电影
-            itemid = mediaserver.get_item_id(mtype=mediainfo.type.value,
-                                             title=mediainfo.title,
-                                             tmdbid=mediainfo.tmdb_id)
+            itemid = self.mediaserver.get_item_id(mtype=mediainfo.type.value,
+                                                  title=mediainfo.title,
+                                                  tmdbid=mediainfo.tmdb_id)
            exists_movies: Optional[ExistMediaInfo] = self.media_exists(mediainfo=mediainfo, itemid=itemid)
            if exists_movies:
                logger.info(f"媒体库中已存在电影：{mediainfo.title_year}")
@@ -835,8 +774,7 @@ class DownloadChain(ChainBase):
                # 补充媒体信息
                mediainfo: MediaInfo = self.recognize_media(mtype=mediainfo.type,
                                                            tmdbid=mediainfo.tmdb_id,
-                                                            doubanid=mediainfo.douban_id,
-                                                            episode_group=mediainfo.episode_group)
+                                                            doubanid=mediainfo.douban_id)
                if not mediainfo:
                    logger.error(f"媒体信息识别失败！")
                    return False, {}
@@ -844,10 +782,10 @@ class DownloadChain(ChainBase):
                    logger.error(f"媒体信息中没有季集信息：{mediainfo.title_year}")
                    return False, {}
            # 电视剧
-            itemid = mediaserver.get_item_id(mtype=mediainfo.type.value,
-                                             title=mediainfo.title,
-                                             tmdbid=mediainfo.tmdb_id,
-                                             season=mediainfo.season)
+            itemid = self.mediaserver.get_item_id(mtype=mediainfo.type.value,
+                                                  title=mediainfo.title,
+                                                  tmdbid=mediainfo.tmdb_id,
+                                                  season=mediainfo.season)
            # 媒体库已存在的剧集
            exists_tvs: Optional[ExistMediaInfo] = self.media_exists(mediainfo=mediainfo, itemid=itemid)
            if not exists_tvs:
@@ -903,7 +841,7 @@ class DownloadChain(ChainBase):
            # 全部存在
            return True, no_exists

-    def remote_downloading(self, channel: MessageChannel, userid: Union[str, int] = None, source: Optional[str] = None):
+    def remote_downloading(self, channel: MessageChannel, userid: Union[str, int] = None):
        """
        查询正在下载的任务，并发送消息
        """
@@ -911,7 +849,6 @@ class DownloadChain(ChainBase):
        if not torrents:
            self.post_message(Notification(
                channel=channel,
-                source=source,
                mtype=NotificationType.Download,
                title="没有正在下载的任务！",
                userid=userid,
@@ -929,7 +866,6 @@ class DownloadChain(ChainBase):
            index += 1
        self.post_message(Notification(
            channel=channel,
-            source=source,
            mtype=NotificationType.Download,
            title=title,
            text="\n".join(messages),
@@ -937,16 +873,16 @@ class DownloadChain(ChainBase):
            link=settings.MP_DOMAIN('#/downloading')
        ))

-    def downloading(self, name: Optional[str] = None) -> List[DownloadingTorrent]:
+    def downloading(self) -> List[DownloadingTorrent]:
        """
        查询正在下载的任务
        """
-        torrents = self.list_torrents(downloader=name, status=TorrentStatus.DOWNLOADING)
+        torrents = self.list_torrents(status=TorrentStatus.DOWNLOADING)
        if not torrents:
            return []
        ret_torrents = []
        for torrent in torrents:
-            history = DownloadHistoryOper().get_by_hash(torrent.hash)
+            history = self.downloadhis.get_by_hash(torrent.hash)
            if history:
                # 媒体信息
                torrent.media = {
@@ -963,21 +899,21 @@ class DownloadChain(ChainBase):
            ret_torrents.append(torrent)
        return ret_torrents

-    def set_downloading(self, hash_str, oper: str, name: Optional[str] = None) -> bool:
+    def set_downloading(self, hash_str, oper: str) -> bool:
        """
        控制下载任务 start/stop
        """
        if oper == "start":
-            return self.start_torrents(hashs=[hash_str], downloader=name)
+            return self.start_torrents(hashs=[hash_str])
        elif oper == "stop":
-            return self.stop_torrents(hashs=[hash_str], downloader=name)
+            return self.stop_torrents(hashs=[hash_str])
        return False

-    def remove_downloading(self, hash_str: str, name: Optional[str] = None) -> bool:
+    def remove_downloading(self, hash_str: str) -> bool:
        """
        删除下载任务
        """
-        return self.remove_torrents(hashs=[hash_str], downloader=name)
+        return self.remove_torrents(hashs=[hash_str])

    @eventmanager.register(EventType.DownloadFileDeleted)
    def download_file_deleted(self, event: Event):
@@ -997,7 +933,7 @@ class DownloadChain(ChainBase):
            # 发出下载任务删除事件，如需处理辅种，可监听该事件
            self.eventmanager.send_event(EventType.DownloadDeleted, {
                "hash": hash_str,
-                    "torrents": [torrent.model_dump() for torrent in torrents]
+                "torrents": [torrent.dict() for torrent in torrents]
            })
        else:
            logger.info(f"没有在下载器中查询到 {hash_str} 对应的下载任务")
--- a/app/chain/media.py
+++ b/app/chain/media.py
--- a/app/chain/mediaserver.py
+++ b/app/chain/mediaserver.py
@@ -1,12 +1,12 @@
+import json
 import threading
-from typing import List, Union, Optional, Generator, Any
+from typing import List, Union, Optional

+from app import schemas
 from app.chain import ChainBase
-from app.core.config import global_vars
+from app.core.config import settings
 from app.db.mediaserver_oper import MediaServerOper
-from app.helper.service import ServiceConfigHelper
 from app.log import logger
-from app.schemas import MediaServerLibrary, MediaServerItem, MediaServerSeasonInfo, MediaServerPlayItem

 lock = threading.Lock()

@@ -16,172 +16,101 @@ class MediaServerChain(ChainBase):
    媒体服务器处理链
    """

-    def librarys(self, server: str, username: Optional[str] = None,
-                 hidden: bool = False) -> List[MediaServerLibrary]:
+    def __init__(self):
+        super().__init__()
+        self.dboper = MediaServerOper()
+
+    def librarys(self, server: str = None, username: str = None) -> List[schemas.MediaServerLibrary]:
        """
        获取媒体服务器所有媒体库
        """
-        return self.run_module("mediaserver_librarys", server=server, username=username, hidden=hidden)
+        return self.run_module("mediaserver_librarys", server=server, username=username)

-    def items(self, server: str, library_id: Union[str, int],
-              start_index: Optional[int] = 0, limit: Optional[int] = -1) -> Generator[Any, None, None]:
+    def items(self, server: str, library_id: Union[str, int]) -> List[schemas.MediaServerItem]:
        """
-        获取媒体服务器项目列表，支持分页和不分页逻辑，默认不分页获取所有数据
-
-        :param server: 媒体服务器名称
-        :param library_id: 媒体库ID，用于标识要获取的媒体库
-        :param start_index: 起始索引，用于分页获取数据。默认为 0，即从第一个项目开始获取
-        :param limit: 每次请求的最大项目数，用于分页。如果为 None 或 -1，则表示一次性获取所有数据，默认为 -1
-
-        :return: 返回一个生成器对象，用于逐步获取媒体服务器中的项目
-
-        说明：
-        - 特别注意的是，这里使用yield from返回迭代器，避免同时使用return与yield导致Python生成器解析异常
-        - 如果 `limit` 为 None 或 -1 时，表示一次性获取所有数据，分页处理将不再生效
-        - 在这种情况下，内存消耗可能会较大，特别是在数据量非常大的场景下
-        - 如果未来评估结果显示，不分页场景下的内存消耗远大于分页处理时的网络请求开销，可以考虑在此方法中实现自分页的处理
-        - 即通过 `while` 循环在上层进行分页控制，逐步获取所有数据，避免内存爆炸，当前该逻辑由具体实例来实现不分页的处理
-        - Plex 实际上已默认支持内部分页处理，Jellyfin 与 Emby 获取数据时存在内部过滤场景，如排除合集等，分页数据可能是错误的
-        if limit is not None and limit != -1:
-            yield from self.run_module("mediaserver_items", server=server, library_id=library_id,
-                                   start_index=start_index, limit=limit)
-        else:
-            # 自分页逻辑，通过循环逐步获取所有数据
-            page_size = 10
-            while True:
-                data_generator = self.run_module("mediaserver_items", server=server, library_id=library_id,
-                                                 start_index=start_index, limit=page_size)
-                if not data_generator:
-                    break
-                count = 0
-                for item in data_generator:
-                    if item:
-                        count += 1
-                        yield item
-                if count < page_size:
-                    break
-                start_index += page_size
+        获取媒体服务器所有项目
        """
-        yield from self.run_module("mediaserver_items", server=server, library_id=library_id,
-                                   start_index=start_index, limit=limit)
+        return self.run_module("mediaserver_items", server=server, library_id=library_id)

-    def iteminfo(self, server: str, item_id: Union[str, int]) -> MediaServerItem:
+    def iteminfo(self, server: str, item_id: Union[str, int]) -> schemas.MediaServerItem:
        """
        获取媒体服务器项目信息
        """
        return self.run_module("mediaserver_iteminfo", server=server, item_id=item_id)

-    def episodes(self, server: str, item_id: Union[str, int]) -> List[MediaServerSeasonInfo]:
+    def episodes(self, server: str, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
        """
        获取媒体服务器剧集信息
        """
        return self.run_module("mediaserver_tv_episodes", server=server, item_id=item_id)

-    def playing(self, server: str, count: Optional[int] = 20,
-                username: Optional[str] = None) -> List[MediaServerPlayItem]:
+    def playing(self, count: int = 20, server: str = None, username: str = None) -> List[schemas.MediaServerPlayItem]:
        """
        获取媒体服务器正在播放信息
        """
        return self.run_module("mediaserver_playing", count=count, server=server, username=username)

-    def latest(self, server: str, count: Optional[int] = 20,
-               username: Optional[str] = None) -> List[MediaServerPlayItem]:
+    def latest(self, count: int = 20, server: str = None, username: str = None) -> List[schemas.MediaServerPlayItem]:
        """
        获取媒体服务器最新入库条目
        """
        return self.run_module("mediaserver_latest", count=count, server=server, username=username)

-    def get_latest_wallpapers(self, server: Optional[str] = None, count: Optional[int] = 10,
-                              remote: bool = True, username: Optional[str] = None) -> List[str]:
-        """
-        获取最新最新入库条目海报作为壁纸，缓存1小时
-        """
-        return self.run_module("mediaserver_latest_images", server=server, count=count,
-                               remote=remote, username=username)
-
-    def get_latest_wallpaper(self, server: Optional[str] = None,
-                             remote: bool = True, username: Optional[str] = None) -> Optional[str]:
-        """
-        获取最新最新入库条目海报作为壁纸，缓存1小时
-        """
-        wallpapers = self.get_latest_wallpapers(server=server, count=1, remote=remote, username=username)
-        return wallpapers[0] if wallpapers else None
-
    def get_play_url(self, server: str, item_id: Union[str, int]) -> Optional[str]:
        """
        获取播放地址
        """
        return self.run_module("mediaserver_play_url", server=server, item_id=item_id)

-    def get_image_cookies(
-        self, server: Optional[str], image_url: str
-    ) -> Optional[str | dict]:
-        """
-        获取图片的Cookies
-        """
-        return self.run_module(
-            "mediaserver_image_cookies", server=server, image_url=image_url
-        )
-
    def sync(self):
        """
        同步媒体库所有数据到本地数据库
        """
        # 设置的媒体服务器
-        mediaservers = ServiceConfigHelper.get_mediaserver_configs()
-        if not mediaservers:
+        if not settings.MEDIASERVER:
            return
+        # 同步黑名单
+        sync_blacklist = settings.MEDIASERVER_SYNC_BLACKLIST.split(
+            ",") if settings.MEDIASERVER_SYNC_BLACKLIST else []
+        mediaservers = settings.MEDIASERVER.split(",")
        with lock:
            # 汇总统计
            total_count = 0
            # 清空登记薄
-            dboper = MediaServerOper()
-            dboper.empty()
+            self.dboper.empty()
            # 遍历媒体服务器
            for mediaserver in mediaservers:
                if not mediaserver:
                    continue
-                logger.info(f"正在准备同步媒体服务器 {mediaserver.name} 的数据")
-                if not mediaserver.enabled:
-                    logger.info(f"媒体服务器 {mediaserver.name} 未启用，跳过")
-                    continue
-                server_name = mediaserver.name
-                sync_libraries = mediaserver.sync_libraries or []
-                logger.info(f"开始同步媒体服务器 {server_name} 的数据 ...")
-                libraries = self.librarys(server_name)
-                if not libraries:
-                    logger.info(f"没有获取到媒体服务器 {server_name} 的媒体库，跳过")
-                    continue
-                for library in libraries:
-                    if sync_libraries \
-                            and "all" not in sync_libraries \
-                            and str(library.id) not in sync_libraries:
-                        logger.info(f"{library.name} 未在 {server_name} 同步媒体库列表中，跳过")
+                logger.info(f"开始同步媒体库 {mediaserver} 的数据 ...")
+                for library in self.librarys(mediaserver):
+                    # 同步黑名单 跳过
+                    if library.name in sync_blacklist:
                        continue
-                    logger.info(f"正在同步 {server_name} 媒体库 {library.name} ...")
+                    logger.info(f"正在同步 {mediaserver} 媒体库 {library.name} ...")
                    library_count = 0
-                    for item in self.items(server=server_name, library_id=library.id):
-                        if global_vars.is_system_stopped:
-                            return
-                        if not item or not item.item_id:
+                    for item in self.items(mediaserver, library.id):
+                        if not item:
+                            continue
+                        if not item.item_id:
                            continue
                        logger.debug(f"正在同步 {item.title} ...")
                        # 计数
                        library_count += 1
                        seasoninfo = {}
                        # 类型
-                        item_type = "电视剧" if item.item_type in ["Series", "show"] else "电影"
+                        item_type = "电视剧" if item.item_type in ['Series', 'show'] else "电影"
                        if item_type == "电视剧":
                            # 查询剧集信息
-                            espisodes_info = self.episodes(server_name, item.item_id) or []
+                            espisodes_info = self.episodes(mediaserver, item.item_id) or []
                            for episode in espisodes_info:
                                seasoninfo[episode.season] = episode.episodes
                        # 插入数据
-                        item_dict = item.model_dump()
-                        item_dict["seasoninfo"] = seasoninfo
-                        item_dict["item_type"] = item_type
-                        dboper.add(**item_dict)
-                    logger.info(f"{server_name} 媒体库 {library.name} 同步完成，共同步数量：{library_count}")
+                        item_dict = item.dict()
+                        item_dict['seasoninfo'] = json.dumps(seasoninfo)
+                        item_dict['item_type'] = item_type
+                        self.dboper.add(**item_dict)
+                    logger.info(f"{mediaserver} 媒体库 {library.name} 同步完成，共同步数量：{library_count}")
                    # 总数累加
                    total_count += library_count
-                logger.info(f"媒体服务器 {server_name} 数据同步完成，总同步数量：{total_count}")
+            logger.info("【MediaServer】媒体库数据同步完成，同步数量：%s" % total_count)
--- a/app/chain/message.py
+++ b/app/chain/message.py
--- a/app/chain/recommend.py
+++ b/app/chain/recommend.py
@@ -1,412 +0,0 @@
-from typing import List, Optional
-
-import pillow_avif  # noqa 用于自动注册AVIF支持
-
-from app.chain import ChainBase
-from app.chain.bangumi import BangumiChain
-from app.chain.douban import DoubanChain
-from app.chain.tmdb import TmdbChain
-from app.core.cache import cached
-from app.core.config import settings, global_vars
-from app.helper.image import ImageHelper
-from app.log import logger
-from app.schemas import MediaType
-from app.utils.common import log_execution_time
-from app.utils.singleton import Singleton
-
-
-class RecommendChain(ChainBase, metaclass=Singleton):
-    """
-    推荐处理链，单例运行
-    """
-
-    # 推荐缓存时间
-    recommend_ttl = 24 * 3600
-    # 推荐缓存页数
-    cache_max_pages = 5
-    # 推荐缓存区域
-    recommend_cache_region = "recommend"
-
-    def refresh_recommend(self):
-        """
-        刷新推荐
-        """
-        logger.debug("Starting to refresh Recommend data.")
-
-        # 推荐来源方法
-        recommend_methods = [
-            self.tmdb_movies,
-            self.tmdb_tvs,
-            self.tmdb_trending,
-            self.bangumi_calendar,
-            self.douban_movie_showing,
-            self.douban_movies,
-            self.douban_tvs,
-            self.douban_movie_top250,
-            self.douban_tv_weekly_chinese,
-            self.douban_tv_weekly_global,
-            self.douban_tv_animation,
-            self.douban_movie_hot,
-            self.douban_tv_hot,
-        ]
-
-        # 缓存并刷新所有推荐数据
-        recommends = []
-        # 记录哪些方法已完成
-        methods_finished = set()
-        # 这里避免区间内连续调用相同来源，因此遍历方案为每页遍历所有推荐来源，再进行页数遍历
-        for page in range(1, self.cache_max_pages + 1):
-            for method in recommend_methods:
-                if global_vars.is_system_stopped:
-                    return
-                if method in methods_finished:
-                    continue
-                logger.debug(f"Fetch {method.__name__} data for page {page}.")
-                data = method(page=page)
-                if not data:
-                    logger.debug("All recommendation methods have finished fetching data. Ending pagination early.")
-                    methods_finished.add(method)
-                    continue
-                recommends.extend(data)
-            # 如果所有方法都已经完成，提前结束循环
-            if len(methods_finished) == len(recommend_methods):
-                break
-
-        # 缓存收集到的海报
-        self.__cache_posters(recommends)
-        logger.debug("Recommend data refresh completed.")
-
-    def __cache_posters(self, datas: List[dict]):
-        """
-        提取 poster_path 并缓存图片
-        :param datas: 数据列表
-        """
-        if not settings.GLOBAL_IMAGE_CACHE:
-            return
-
-        for data in datas:
-            if global_vars.is_system_stopped:
-                return
-            poster_path = data.get("poster_path")
-            if poster_path:
-                poster_url = poster_path.replace("original", "w500")
-                logger.debug(f"Caching poster image: {poster_url}")
-                self.__fetch_and_save_image(poster_url)
-
-    @staticmethod
-    def __fetch_and_save_image(url: str):
-        """
-        请求并保存图片
-        :param url: 图片路径
-        """
-        ImageHelper().fetch_image(url=url)
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def tmdb_movies(self, sort_by: Optional[str] = "popularity.desc",
-                    with_genres: Optional[str] = "",
-                    with_original_language: Optional[str] = "",
-                    with_keywords: Optional[str] = "",
-                    with_watch_providers: Optional[str] = "",
-                    vote_average: Optional[float] = 0.0,
-                    vote_count: Optional[int] = 0,
-                    release_date: Optional[str] = "",
-                    page: Optional[int] = 1) -> List[dict]:
-        """
-        TMDB热门电影
-        """
-        movies = TmdbChain().tmdb_discover(mtype=MediaType.MOVIE,
-                                           sort_by=sort_by,
-                                           with_genres=with_genres,
-                                           with_original_language=with_original_language,
-                                           with_keywords=with_keywords,
-                                           with_watch_providers=with_watch_providers,
-                                           vote_average=vote_average,
-                                           vote_count=vote_count,
-                                           release_date=release_date,
-                                           page=page)
-        return [movie.to_dict() for movie in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def tmdb_tvs(self, sort_by: Optional[str] = "popularity.desc",
-                 with_genres: Optional[str] = "",
-                 with_original_language: Optional[str] = "zh|en|ja|ko",
-                 with_keywords: Optional[str] = "",
-                 with_watch_providers: Optional[str] = "",
-                 vote_average: Optional[float] = 0.0,
-                 vote_count: Optional[int] = 0,
-                 release_date: Optional[str] = "",
-                 page: Optional[int] = 1) -> List[dict]:
-        """
-        TMDB热门电视剧
-        """
-        tvs = TmdbChain().tmdb_discover(mtype=MediaType.TV,
-                                        sort_by=sort_by,
-                                        with_genres=with_genres,
-                                        with_original_language=with_original_language,
-                                        with_keywords=with_keywords,
-                                        with_watch_providers=with_watch_providers,
-                                        vote_average=vote_average,
-                                        vote_count=vote_count,
-                                        release_date=release_date,
-                                        page=page)
-        return [tv.to_dict() for tv in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def tmdb_trending(self, page: Optional[int] = 1) -> List[dict]:
-        """
-        TMDB流行趋势
-        """
-        infos = TmdbChain().tmdb_trending(page=page)
-        return [info.to_dict() for info in infos] if infos else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def bangumi_calendar(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        Bangumi每日放送
-        """
-        medias = BangumiChain().calendar()
-        return [media.to_dict() for media in medias[(page - 1) * count: page * count]] if medias else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣正在热映
-        """
-        movies = DoubanChain().movie_showing(page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movies(self, sort: Optional[str] = "R", tags: Optional[str] = "",
-                      page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣最新电影
-        """
-        movies = DoubanChain().douban_discover(mtype=MediaType.MOVIE,
-                                               sort=sort, tags=tags, page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tvs(self, sort: Optional[str] = "R", tags: Optional[str] = "",
-                   page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣最新电视剧
-        """
-        tvs = DoubanChain().douban_discover(mtype=MediaType.TV,
-                                            sort=sort, tags=tags, page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣电影TOP250
-        """
-        movies = DoubanChain().movie_top250(page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣国产剧集榜
-        """
-        tvs = DoubanChain().tv_weekly_chinese(page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣全球剧集榜
-        """
-        tvs = DoubanChain().tv_weekly_global(page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣热门动漫
-        """
-        tvs = DoubanChain().tv_animation(page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣热门电影
-        """
-        movies = DoubanChain().movie_hot(page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    def douban_tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        豆瓣热门电视剧
-        """
-        tvs = DoubanChain().tv_hot(page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_tmdb_movies(self, sort_by: Optional[str] = "popularity.desc",
-                                with_genres: Optional[str] = "",
-                                with_original_language: Optional[str] = "",
-                                with_keywords: Optional[str] = "",
-                                with_watch_providers: Optional[str] = "",
-                                vote_average: Optional[float] = 0.0,
-                                vote_count: Optional[int] = 0,
-                                release_date: Optional[str] = "",
-                                page: Optional[int] = 1) -> List[dict]:
-        """
-        异步TMDB热门电影
-        """
-        movies = await TmdbChain().async_run_module("async_tmdb_discover", mtype=MediaType.MOVIE,
-                                                    sort_by=sort_by,
-                                                    with_genres=with_genres,
-                                                    with_original_language=with_original_language,
-                                                    with_keywords=with_keywords,
-                                                    with_watch_providers=with_watch_providers,
-                                                    vote_average=vote_average,
-                                                    vote_count=vote_count,
-                                                    release_date=release_date,
-                                                    page=page)
-        return [movie.to_dict() for movie in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_tmdb_tvs(self, sort_by: Optional[str] = "popularity.desc",
-                             with_genres: Optional[str] = "",
-                             with_original_language: Optional[str] = "zh|en|ja|ko",
-                             with_keywords: Optional[str] = "",
-                             with_watch_providers: Optional[str] = "",
-                             vote_average: Optional[float] = 0.0,
-                             vote_count: Optional[int] = 0,
-                             release_date: Optional[str] = "",
-                             page: Optional[int] = 1) -> List[dict]:
-        """
-        异步TMDB热门电视剧
-        """
-        tvs = await TmdbChain().async_run_module("async_tmdb_discover", mtype=MediaType.TV,
-                                                 sort_by=sort_by,
-                                                 with_genres=with_genres,
-                                                 with_original_language=with_original_language,
-                                                 with_keywords=with_keywords,
-                                                 with_watch_providers=with_watch_providers,
-                                                 vote_average=vote_average,
-                                                 vote_count=vote_count,
-                                                 release_date=release_date,
-                                                 page=page)
-        return [tv.to_dict() for tv in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_tmdb_trending(self, page: Optional[int] = 1) -> List[dict]:
-        """
-        异步TMDB流行趋势
-        """
-        infos = await TmdbChain().async_run_module("async_tmdb_trending", page=page)
-        return [info.to_dict() for info in infos] if infos else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_bangumi_calendar(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步Bangumi每日放送
-        """
-        medias = await BangumiChain().async_run_module("async_bangumi_calendar")
-        return [media.to_dict() for media in medias[(page - 1) * count: page * count]] if medias else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣正在热映
-        """
-        movies = await DoubanChain().async_run_module("async_movie_showing", page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_movies(self, sort: Optional[str] = "R", tags: Optional[str] = "",
-                                  page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣最新电影
-        """
-        movies = await DoubanChain().async_run_module("async_douban_discover", mtype=MediaType.MOVIE,
-                                                      sort=sort, tags=tags, page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_tvs(self, sort: Optional[str] = "R", tags: Optional[str] = "",
-                               page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣最新电视剧
-        """
-        tvs = await DoubanChain().async_run_module("async_douban_discover", mtype=MediaType.TV,
-                                                   sort=sort, tags=tags, page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣电影TOP250
-        """
-        movies = await DoubanChain().async_run_module("async_movie_top250", page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣国产剧集榜
-        """
-        tvs = await DoubanChain().async_run_module("async_tv_weekly_chinese", page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣全球剧集榜
-        """
-        tvs = await DoubanChain().async_run_module("async_tv_weekly_global", page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣热门动漫
-        """
-        tvs = await DoubanChain().async_run_module("async_tv_animation", page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣热门电影
-        """
-        movies = await DoubanChain().async_run_module("async_movie_hot", page=page, count=count)
-        return [media.to_dict() for media in movies] if movies else []
-
-    @log_execution_time(logger=logger)
-    @cached(ttl=recommend_ttl, region=recommend_cache_region)
-    async def async_douban_tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
-        """
-        异步豆瓣热门电视剧
-        """
-        tvs = await DoubanChain().async_run_module("async_tv_hot", page=page, count=count)
-        return [media.to_dict() for media in tvs] if tvs else []
--- a/app/chain/search.py
+++ b/app/chain/search.py
@@ -1,22 +1,18 @@
-import asyncio
-import random
-import time
+import pickle
+import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
-from typing import Dict, Tuple
+from typing import Dict
 from typing import List, Optional

-from app.helper.sites import SitesHelper  # noqa
-from fastapi.concurrency import run_in_threadpool
-
 from app.chain import ChainBase
-from app.core.config import global_vars, settings
 from app.core.context import Context
 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.progress import ProgressHelper
+from app.helper.sites import SitesHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import NotExistMediaInfo
@@ -28,20 +24,22 @@ class SearchChain(ChainBase):
    站点资源搜索处理链
    """

-    __result_temp_file = "__search_result__"
+    def __init__(self):
+        super().__init__()
+        self.siteshelper = SitesHelper()
+        self.progress = ProgressHelper()
+        self.systemconfig = SystemConfigOper()
+        self.torrenthelper = TorrentHelper()

-    def search_by_id(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
-                     mtype: MediaType = None, area: Optional[str] = "title", season: Optional[int] = None,
-                     sites: List[int] = None, cache_local: bool = False) -> List[Context]:
+    def search_by_id(self, tmdbid: int = None, doubanid: str = None,
+                     mtype: MediaType = None, area: str = "title", season: int = None) -> List[Context]:
        """
-        根据TMDBID/豆瓣ID搜索资源，精确匹配，不过滤本地存在的资源
+        根据TMDBID/豆瓣ID搜索资源，精确匹配，但不不过滤本地存在的资源
        :param tmdbid: TMDB ID
        :param doubanid: 豆瓣 ID
        :param mtype: 媒体，电影 or 电视剧
        :param area: 搜索范围，title or imdbid
        :param season: 季数
-        :param sites: 站点ID列表
-        :param cache_local: 是否缓存到本地
        """
        mediainfo = self.recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
        if not mediainfo:
@@ -54,114 +52,92 @@ class SearchChain(ChainBase):
                    season: NotExistMediaInfo(episodes=[])
                }
            }
-        results = self.process(mediainfo=mediainfo, sites=sites, area=area, no_exists=no_exists)
-        # 保存到本地文件
-        if cache_local:
-            self.save_cache(results, self.__result_temp_file)
+        results = self.process(mediainfo=mediainfo, area=area, no_exists=no_exists)
+        # 保存结果
+        bytes_results = pickle.dumps(results)
+        self.systemconfig.set(SystemConfigKey.SearchResults, bytes_results)
        return results

-    def search_by_title(self, title: str, page: Optional[int] = 0,
-                        sites: List[int] = None, cache_local: Optional[bool] = False) -> List[Context]:
+    def search_by_title(self, title: str, page: int = 0, site: int = None) -> List[Context]:
        """
        根据标题搜索资源，不识别不过滤，直接返回站点内容
        :param title: 标题，为空时返回所有站点首页内容
        :param page: 页码
-        :param sites: 站点ID列表
-        :param cache_local: 是否缓存到本地
+        :param site: 站点ID
        """
        if title:
            logger.info(f'开始搜索资源，关键词：{title} ...')
        else:
-            logger.info(f'开始浏览资源，站点：{sites} ...')
+            logger.info(f'开始浏览资源，站点：{site} ...')
        # 搜索
-        torrents = self.__search_all_sites(keyword=title, sites=sites, page=page) or []
+        torrents = self.__search_all_sites(keywords=[title], sites=[site] if site else None, page=page) or []
        if not torrents:
            logger.warn(f'{title} 未搜索到资源')
            return []
        # 组装上下文
        contexts = [Context(meta_info=MetaInfo(title=torrent.title, subtitle=torrent.description),
                            torrent_info=torrent) for torrent in torrents]
-        # 保存到本地文件
-        if cache_local:
-            self.save_cache(contexts, self.__result_temp_file)
+        # 保存结果
+        bytes_results = pickle.dumps(contexts)
+        self.systemconfig.set(SystemConfigKey.SearchResults, bytes_results)
        return contexts

-    def last_search_results(self) -> Optional[List[Context]]:
+    def last_search_results(self) -> List[Context]:
        """
        获取上次搜索结果
        """
-        return self.load_cache(self.__result_temp_file)
+        results = self.systemconfig.get(SystemConfigKey.SearchResults)
+        if not results:
+            return []
+        try:
+            return pickle.loads(results)
+        except Exception as e:
+            logger.error(f'加载搜索结果失败：{str(e)} - {traceback.format_exc()}')
+            return []

-    async def async_last_search_results(self) -> Optional[List[Context]]:
+    def process(self, mediainfo: MediaInfo,
+                keyword: str = None,
+                no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
+                sites: List[int] = None,
+                priority_rule: str = None,
+                filter_rule: Dict[str, str] = None,
+                area: str = "title") -> List[Context]:
        """
-        异步获取上次搜索结果
-        """
-        return await self.async_load_cache(self.__result_temp_file)
-
-    async def async_search_by_id(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
-                                 mtype: MediaType = None, area: Optional[str] = "title", season: Optional[int] = None,
-                                 sites: List[int] = None, cache_local: bool = False) -> List[Context]:
-        """
-        根据TMDBID/豆瓣ID异步搜索资源，精确匹配，不过滤本地存在的资源
-        :param tmdbid: TMDB ID
-        :param doubanid: 豆瓣 ID
-        :param mtype: 媒体，电影 or 电视剧
+        根据媒体信息搜索种子资源，精确匹配，应用过滤规则，同时根据no_exists过滤本地已存在的资源
+        :param mediainfo: 媒体信息
+        :param keyword: 搜索关键词
+        :param no_exists: 缺失的媒体信息
+        :param sites: 站点ID列表，为空时搜索所有站点
+        :param priority_rule: 优先级规则，为空时使用搜索优先级规则
+        :param filter_rule: 过滤规则，为空是使用默认过滤规则
        :param area: 搜索范围，title or imdbid
-        :param season: 季数
-        :param sites: 站点ID列表
-        :param cache_local: 是否缓存到本地
        """
-        mediainfo = await self.async_recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
-        if not mediainfo:
-            logger.error(f'{tmdbid} 媒体信息识别失败！')
-            return []
-        no_exists = None
-        if season:
-            no_exists = {
-                tmdbid or doubanid: {
-                    season: NotExistMediaInfo(episodes=[])
-                }
-            }
-        results = await self.async_process(mediainfo=mediainfo, sites=sites, area=area, no_exists=no_exists)
-        # 保存到本地文件
-        if cache_local:
-            await self.async_save_cache(results, self.__result_temp_file)
-        return results

-    async def async_search_by_title(self, title: str, page: Optional[int] = 0,
-                                    sites: List[int] = None, cache_local: Optional[bool] = False) -> List[Context]:
-        """
-        根据标题异步搜索资源，不识别不过滤，直接返回站点内容
-        :param title: 标题，为空时返回所有站点首页内容
-        :param page: 页码
-        :param sites: 站点ID列表
-        :param cache_local: 是否缓存到本地
-        """
-        if title:
-            logger.info(f'开始搜索资源，关键词：{title} ...')
-        else:
-            logger.info(f'开始浏览资源，站点：{sites} ...')
-        # 搜索
-        torrents = await self.__async_search_all_sites(keyword=title, sites=sites, page=page) or []
-        if not torrents:
-            logger.warn(f'{title} 未搜索到资源')
-            return []
-        # 组装上下文
-        contexts = [Context(meta_info=MetaInfo(title=torrent.title, subtitle=torrent.description),
-                            torrent_info=torrent) for torrent in torrents]
-        # 保存到本地文件
-        if cache_local:
-            await self.async_save_cache(contexts, self.__result_temp_file)
-        return contexts
+        def __do_filter(torrent_list: List[TorrentInfo]) -> List[TorrentInfo]:
+            """
+            执行优先级过滤
+            """
+            return self.filter_torrents(rule_string=priority_rule,
+                                        torrent_list=torrent_list,
+                                        season_episodes=season_episodes,
+                                        mediainfo=mediainfo) or []
+
+        # 豆瓣标题处理
+        if not mediainfo.tmdb_id:
+            meta = MetaInfo(title=mediainfo.title)
+            mediainfo.title = meta.name
+            mediainfo.season = meta.begin_season
+        logger.info(f'开始搜索资源，关键词：{keyword or mediainfo.title} ...')
+
+        # 补充媒体信息
+        if not mediainfo.names:
+            mediainfo: MediaInfo = self.recognize_media(mtype=mediainfo.type,
+                                                        tmdbid=mediainfo.tmdb_id,
+                                                        doubanid=mediainfo.douban_id)
+            if not mediainfo:
+                logger.error(f'媒体信息识别失败！')
+                return []

-    @staticmethod
-    def __prepare_params(mediainfo: MediaInfo,
-                         keyword: Optional[str] = None,
-                         no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None
-                         ) -> Tuple[Dict[int, List[int]], List[str]]:
-        """
-        准备搜索参数
-        """
        # 缺失的季集
        mediakey = mediainfo.tmdb_id or mediainfo.douban_id
        if no_exists and no_exists.get(mediakey):
@@ -182,323 +158,127 @@ class SearchChain(ChainBase):
            keywords = list(dict.fromkeys([k for k in [mediainfo.title,
                                                       mediainfo.original_title,
                                                       mediainfo.en_title,
-                                                       mediainfo.hk_title,
-                                                       mediainfo.tw_title,
                                                       mediainfo.sg_title] if k]))
-            # 限制搜索关键词数量
-            if settings.MAX_SEARCH_NAME_LIMIT:
-                keywords = keywords[:settings.MAX_SEARCH_NAME_LIMIT]
-
-        return season_episodes, keywords
-
-    def __parse_result(self, torrents: List[TorrentInfo],
-                       mediainfo: MediaInfo,
-                       keyword: Optional[str] = None,
-                       rule_groups: List[str] = None,
-                       season_episodes: Dict[int, List[int]] = None,
-                       custom_words: List[str] = None,
-                       filter_params: Dict[str, str] = None) -> List[Context]:
-        """
-        处理搜索结果
-        """
-
-        def __do_filter(torrent_list: List[TorrentInfo]) -> List[TorrentInfo]:
-            """
-            执行优先级过滤
-            """
-            return self.filter_torrents(rule_groups=rule_groups,
-                                        torrent_list=torrent_list,
-                                        mediainfo=mediainfo) or []

+        # 执行搜索
+        torrents: List[TorrentInfo] = self.__search_all_sites(
+            mediainfo=mediainfo,
+            keywords=keywords,
+            sites=sites,
+            area=area
+        )
        if not torrents:
            logger.warn(f'{keyword or mediainfo.title} 未搜索到资源')
            return []

        # 开始新进度
-        progress = ProgressHelper(ProgressKey.Search)
-        progress.start()
-
-        # 开始过滤
-        progress.update(value=0, text=f'开始过滤，总 {len(torrents)} 个资源，请稍候...')
-        # 匹配订阅附加参数
-        if filter_params:
-            logger.info(f'开始附加参数过滤，附加参数：{filter_params} ...')
-            torrents = [torrent for torrent in torrents if TorrentHelper().filter_torrent(torrent, filter_params)]
-        # 开始过滤规则过滤
-        if rule_groups is None:
-            # 取搜索过滤规则
-            rule_groups: List[str] = SystemConfigOper().get(SystemConfigKey.SearchFilterRuleGroups)
-        if rule_groups:
-            logger.info(f'开始过滤规则/剧集过滤，使用规则组：{rule_groups} ...')
-            torrents = __do_filter(torrents)
-            if not torrents:
-                logger.warn(f'{keyword or mediainfo.title} 没有符合过滤规则的资源')
-                return []
-            logger.info(f"过滤规则/剧集过滤完成，剩余 {len(torrents)} 个资源")
-
-        # 过滤完成
-        progress.update(value=50, text=f'过滤完成，剩余 {len(torrents)} 个资源')
+        self.progress.start(ProgressKey.Search)

+        # 开始匹配
+        _match_torrents = []
        # 总数
        _total = len(torrents)
        # 已处理数
        _count = 0
-
-        # 开始匹配
-        _match_torrents = []
-        torrenthelper = TorrentHelper()
-        try:
+        if mediainfo:
            # 英文标题应该在别名/原标题中，不需要再匹配
            logger.info(f"开始匹配结果 标题：{mediainfo.title}，原标题：{mediainfo.original_title}，别名：{mediainfo.names}")
-            progress.update(value=51, text=f'开始匹配，总 {_total} 个资源 ...')
+            self.progress.update(value=0, text=f'开始匹配，总 {_total} 个资源 ...', key=ProgressKey.Search)
            for torrent in torrents:
-                if global_vars.is_system_stopped:
-                    break
                _count += 1
-                progress.update(value=(_count / _total) * 96,
-                                text=f'正在匹配 {torrent.site_name}，已完成 {_count} / {_total} ...')
+                self.progress.update(value=(_count / _total) * 96,
+                                     text=f'正在匹配 {torrent.site_name}，已完成 {_count} / {_total} ...',
+                                     key=ProgressKey.Search)
                if not torrent.title:
                    continue
-
-                # 识别元数据
-                torrent_meta = MetaInfo(title=torrent.title, subtitle=torrent.description,
-                                        custom_words=custom_words)
-                if torrent.title != torrent_meta.org_string:
-                    logger.info(f"种子名称应用识别词后发生改变：{torrent.title} => {torrent_meta.org_string}")
-                # 季集数过滤
-                if season_episodes \
-                        and not torrenthelper.match_season_episodes(torrent=torrent,
-                                                                    meta=torrent_meta,
-                                                                    season_episodes=season_episodes):
-                    continue
                # 比对IMDBID
                if torrent.imdbid \
                        and mediainfo.imdb_id \
                        and torrent.imdbid == mediainfo.imdb_id:
                    logger.info(f'{mediainfo.title} 通过IMDBID匹配到资源：{torrent.site_name} - {torrent.title}')
-                    _match_torrents.append((torrent, torrent_meta))
+                    _match_torrents.append(torrent)
                    continue
-
+                # 识别
+                torrent_meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
+                if torrent.title != torrent_meta.org_string:
+                    logger.info(f"种子名称应用识别词后发生改变：{torrent.title} => {torrent_meta.org_string}")
                # 比对种子
-                if torrenthelper.match_torrent(mediainfo=mediainfo,
-                                               torrent_meta=torrent_meta,
-                                               torrent=torrent):
+                if self.torrenthelper.match_torrent(mediainfo=mediainfo,
+                                                    torrent_meta=torrent_meta,
+                                                    torrent=torrent):
                    # 匹配成功
-                    _match_torrents.append((torrent, torrent_meta))
+                    _match_torrents.append(torrent)
                    continue
            # 匹配完成
            logger.info(f"匹配完成，共匹配到 {len(_match_torrents)} 个资源")
-            progress.update(value=97,
-                            text=f'匹配完成，共匹配到 {len(_match_torrents)} 个资源')
+            self.progress.update(value=97,
+                                 text=f'匹配完成，共匹配到 {len(_match_torrents)} 个资源',
+                                 key=ProgressKey.Search)
+        else:
+            _match_torrents = torrents

-            # 去掉mediainfo中多余的数据
-            mediainfo.clear()
-            # 组装上下文
-            contexts = [Context(torrent_info=t[0],
-                                media_info=mediainfo,
-                                meta_info=t[1]) for t in _match_torrents]
-        finally:
-            torrents.clear()
-            del torrents
-            _match_torrents.clear()
-            del _match_torrents
+        # 开始过滤
+        self.progress.update(value=98, text=f'开始过滤，总 {len(_match_torrents)} 个资源，请稍候...',
+                             key=ProgressKey.Search)
+
+        # 开始过滤规则过滤
+        if _match_torrents:
+            logger.info(f'开始过滤规则过滤，当前规则：{filter_rule} ...')
+            _match_torrents = self.filter_torrents_by_rule(torrents=_match_torrents,
+                                                           mediainfo=mediainfo,
+                                                           filter_rule=filter_rule)
+        if not _match_torrents:
+            logger.warn(f'{keyword or mediainfo.title} 没有符合过滤规则的资源')
+            return []
+        logger.info(f"过滤规则过滤完成，剩余 {len(_match_torrents)} 个资源")
+
+        # 开始优先级规则/剧集过滤
+        if priority_rule is None:
+            # 取搜索优先级规则
+            priority_rule = self.systemconfig.get(SystemConfigKey.SearchFilterRules)
+        if priority_rule:
+            logger.info(f'开始优先级规则/剧集过滤，当前规则：{priority_rule} ...')
+            _match_torrents = __do_filter(_match_torrents)
+            if not _match_torrents:
+                logger.warn(f'{keyword or mediainfo.title} 没有符合优先级规则的资源')
+                return []
+            logger.info(f"优先级规则/剧集过滤完成，剩余 {len(_match_torrents)} 个资源")
+
+        # 去掉mediainfo中多余的数据
+        mediainfo.clear()
+
+        # 组装上下文
+        contexts = [Context(meta_info=MetaInfo(title=torrent.title, subtitle=torrent.description),
+                            media_info=mediainfo,
+                            torrent_info=torrent) for torrent in _match_torrents]
+
+        self.progress.update(value=99, text=f'过滤完成，剩余 {len(contexts)} 个资源', key=ProgressKey.Search)

        # 排序
-        progress.update(value=99,
-                        text=f'正在对 {len(contexts)} 个资源进行排序，请稍候...')
-        contexts = torrenthelper.sort_torrents(contexts)
+        self.progress.update(value=99,
+                             text=f'正在对 {len(contexts)} 个资源进行排序，请稍候...',
+                             key=ProgressKey.Search)
+        contexts = self.torrenthelper.sort_torrents(contexts)

        # 结束进度
+        self.progress.update(value=100,
+                             text=f'搜索完成，共 {len(contexts)} 个资源',
+                             key=ProgressKey.Search)
        logger.info(f'搜索完成，共 {len(contexts)} 个资源')
-        progress.update(value=100,
-                        text=f'搜索完成，共 {len(contexts)} 个资源')
-        progress.end()
+        self.progress.end(ProgressKey.Search)

-        # 去重后返回
-        return self.__remove_duplicate(contexts)
+        # 返回
+        return contexts

-    @staticmethod
-    def __remove_duplicate(_torrents: List[Context]) -> List[Context]:
-        """
-        去除重复的种子
-        :param _torrents: 种子列表
-        :return: 去重后的种子列表
-        """
-        return list({f"{t.torrent_info.site_name}_{t.torrent_info.title}_{t.torrent_info.description}": t
-                     for t in _torrents}.values())
-
-    def process(self, mediainfo: MediaInfo,
-                keyword: Optional[str] = None,
-                no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
-                sites: List[int] = None,
-                rule_groups: List[str] = None,
-                area: Optional[str] = "title",
-                custom_words: List[str] = None,
-                filter_params: Dict[str, str] = None) -> List[Context]:
-        """
-        根据媒体信息搜索种子资源，精确匹配，应用过滤规则，同时根据no_exists过滤本地已存在的资源
-        :param mediainfo: 媒体信息
-        :param keyword: 搜索关键词
-        :param no_exists: 缺失的媒体信息
-        :param sites: 站点ID列表，为空时搜索所有站点
-        :param rule_groups: 过滤规则组名称列表
-        :param area: 搜索范围，title or imdbid
-        :param custom_words: 自定义识别词列表
-        :param filter_params: 过滤参数
-        """
-
-        # 豆瓣标题处理
-        if not mediainfo.tmdb_id:
-            meta = MetaInfo(title=mediainfo.title)
-            mediainfo.title = meta.name
-            mediainfo.season = meta.begin_season
-        logger.info(f'开始搜索资源，关键词：{keyword or mediainfo.title} ...')
-
-        # 补充媒体信息
-        if not mediainfo.names:
-            mediainfo: MediaInfo = self.recognize_media(mtype=mediainfo.type,
-                                                        tmdbid=mediainfo.tmdb_id,
-                                                        doubanid=mediainfo.douban_id)
-            if not mediainfo:
-                logger.error(f'媒体信息识别失败！')
-                return []
-
-        # 准备搜索参数
-        season_episodes, keywords = self.__prepare_params(
-            mediainfo=mediainfo,
-            keyword=keyword,
-            no_exists=no_exists
-        )
-
-        # 站点搜索结果
-        torrents: List[TorrentInfo] = []
-        # 站点搜索次数
-        search_count = 0
-
-        # 多关键字执行搜索
-        for search_word in keywords:
-            # 强制休眠 1-10 秒
-            if search_count > 0:
-                logger.info(f"已搜索 {search_count} 次，强制休眠 1-10 秒 ...")
-                time.sleep(random.randint(1, 10))
-
-            # 搜索站点
-            results = self.__search_all_sites(
-                mediainfo=mediainfo,
-                keyword=search_word,
-                sites=sites,
-                area=area
-            ) or []
-            # 合并结果
-
-            search_count += 1
-            torrents.extend(results)
-
-            # 有结果则停止
-            if not settings.SEARCH_MULTIPLE_NAME and torrents:
-                logger.info(f"共搜索到 {len(torrents)} 个资源，停止搜索")
-                break
-
-        # 处理结果
-        return self.__parse_result(
-            torrents=torrents,
-            mediainfo=mediainfo,
-            keyword=keyword,
-            rule_groups=rule_groups,
-            season_episodes=season_episodes,
-            custom_words=custom_words,
-            filter_params=filter_params
-        )
-
-    async def async_process(self, mediainfo: MediaInfo,
-                            keyword: Optional[str] = None,
-                            no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
-                            sites: List[int] = None,
-                            rule_groups: List[str] = None,
-                            area: Optional[str] = "title",
-                            custom_words: List[str] = None,
-                            filter_params: Dict[str, str] = None) -> List[Context]:
-        """
-        根据媒体信息异步搜索种子资源，精确匹配，应用过滤规则，同时根据no_exists过滤本地已存在的资源
-        :param mediainfo: 媒体信息
-        :param keyword: 搜索关键词
-        :param no_exists: 缺失的媒体信息
-        :param sites: 站点ID列表，为空时搜索所有站点
-        :param rule_groups: 过滤规则组名称列表
-        :param area: 搜索范围，title or imdbid
-        :param custom_words: 自定义识别词列表
-        :param filter_params: 过滤参数
-        """
-
-        # 豆瓣标题处理
-        if not mediainfo.tmdb_id:
-            meta = MetaInfo(title=mediainfo.title)
-            mediainfo.title = meta.name
-            mediainfo.season = meta.begin_season
-        logger.info(f'开始搜索资源，关键词：{keyword or mediainfo.title} ...')
-
-        # 补充媒体信息
-        if not mediainfo.names:
-            mediainfo: MediaInfo = await self.async_recognize_media(mtype=mediainfo.type,
-                                                                    tmdbid=mediainfo.tmdb_id,
-                                                                    doubanid=mediainfo.douban_id)
-            if not mediainfo:
-                logger.error(f'媒体信息识别失败！')
-                return []
-
-        # 准备搜索参数
-        season_episodes, keywords = self.__prepare_params(
-            mediainfo=mediainfo,
-            keyword=keyword,
-            no_exists=no_exists
-        )
-
-        # 站点搜索结果
-        torrents: List[TorrentInfo] = []
-        # 站点搜索次数
-        search_count = 0
-
-        # 多关键字执行搜索
-        for search_word in keywords:
-            # 强制休眠 1-10 秒
-            if search_count > 0:
-                logger.info(f"已搜索 {search_count} 次，强制休眠 1-10 秒 ...")
-                await asyncio.sleep(random.randint(1, 10))
-            # 搜索站点
-            torrents.extend(
-                await self.__async_search_all_sites(
-                    mediainfo=mediainfo,
-                    keyword=search_word,
-                    sites=sites,
-                    area=area
-                ) or []
-            )
-            search_count += 1
-            # 有结果则停止
-            if torrents:
-                logger.info(f"共搜索到 {len(torrents)} 个资源，停止搜索")
-                break
-
-        # 处理结果
-        return await run_in_threadpool(self.__parse_result,
-                                       torrents=torrents,
-                                       mediainfo=mediainfo,
-                                       keyword=keyword,
-                                       rule_groups=rule_groups,
-                                       season_episodes=season_episodes,
-                                       custom_words=custom_words,
-                                       filter_params=filter_params
-                                       )
-
-    def __search_all_sites(self, keyword: str,
+    def __search_all_sites(self, keywords: List[str],
                           mediainfo: Optional[MediaInfo] = None,
                           sites: List[int] = None,
-                           page: Optional[int] = 0,
-                           area: Optional[str] = "title") -> Optional[List[TorrentInfo]]:
+                           page: int = 0,
+                           area: str = "title") -> Optional[List[TorrentInfo]]:
        """
        多线程搜索多个站点
        :param mediainfo:  识别的媒体信息
-        :param keyword:  搜索关键词
+        :param keywords:  搜索关键词列表
        :param sites:  指定站点ID列表，如有则只搜索指定站点，否则搜索所有站点
        :param page:  搜索页码
        :param area:  搜索区域 title or imdbid
@@ -509,19 +289,23 @@ class SearchChain(ChainBase):

        # 配置的索引站点
        if not sites:
-            sites = SystemConfigOper().get(SystemConfigKey.IndexerSites) or []
+            sites = self.systemconfig.get(SystemConfigKey.IndexerSites) or []

-        for indexer in SitesHelper().get_indexers():
+        for indexer in self.siteshelper.get_indexers():
            # 检查站点索引开关
            if not sites or indexer.get("id") in sites:
+                # 站点流控
+                state, msg = self.siteshelper.check(indexer.get("domain"))
+                if state:
+                    logger.warn(msg)
+                    continue
                indexer_sites.append(indexer)
        if not indexer_sites:
            logger.warn('未开启任何有效站点，无法搜索资源')
            return []

        # 开始进度
-        progress = ProgressHelper(ProgressKey.Search)
-        progress.start()
+        self.progress.start(ProgressKey.Search)
        # 开始计时
        start_time = datetime.now()
        # 总数
@@ -529,134 +313,77 @@ class SearchChain(ChainBase):
        # 完成数
        finish_count = 0
        # 更新进度
-        progress.update(value=0,
-                        text=f"开始搜索，共 {total_num} 个站点 ...")
-        # 结果集
-        results = []
+        self.progress.update(value=0,
+                             text=f"开始搜索，共 {total_num} 个站点 ...",
+                             key=ProgressKey.Search)
        # 多线程
-        with ThreadPoolExecutor(max_workers=len(indexer_sites)) as executor:
-            all_task = []
-            for site in indexer_sites:
-                if area == "imdbid":
-                    # 搜索IMDBID
-                    task = executor.submit(self.search_torrents, site=site,
-                                           keyword=mediainfo.imdb_id if mediainfo else None,
-                                           mtype=mediainfo.type if mediainfo else None,
-                                           page=page)
-                else:
-                    # 搜索标题
-                    task = executor.submit(self.search_torrents, site=site,
-                                           keyword=keyword,
-                                           mtype=mediainfo.type if mediainfo else None,
-                                           page=page)
-                all_task.append(task)
-            for future in as_completed(all_task):
-                if global_vars.is_system_stopped:
-                    break
-                finish_count += 1
-                result = future.result()
-                if result:
-                    results.extend(result)
-                logger.info(f"站点搜索进度：{finish_count} / {total_num}")
-                progress.update(value=finish_count / total_num * 100,
-                                text=f"正在搜索{keyword or ''}，已完成 {finish_count} / {total_num} 个站点 ...")
-        # 计算耗时
-        end_time = datetime.now()
-        # 更新进度
-        progress.update(value=100,
-                        text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
-        logger.info(f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
-        # 结束进度
-        progress.end()
-
-        # 返回
-        return results
-
-    async def __async_search_all_sites(self, keyword: str,
-                                       mediainfo: Optional[MediaInfo] = None,
-                                       sites: List[int] = None,
-                                       page: Optional[int] = 0,
-                                       area: Optional[str] = "title") -> Optional[List[TorrentInfo]]:
-        """
-        异步搜索多个站点
-        :param mediainfo:  识别的媒体信息
-        :param keyword:  搜索关键词
-        :param sites:  指定站点ID列表，如有则只搜索指定站点，否则搜索所有站点
-        :param page:  搜索页码
-        :param area:  搜索区域 title or imdbid
-        :reutrn: 资源列表
-        """
-        # 未开启的站点不搜索
-        indexer_sites = []
-
-        # 配置的索引站点
-        if not sites:
-            sites = SystemConfigOper().get(SystemConfigKey.IndexerSites) or []
-
-        for indexer in await SitesHelper().async_get_indexers():
-            # 检查站点索引开关
-            if not sites or indexer.get("id") in sites:
-                indexer_sites.append(indexer)
-        if not indexer_sites:
-            logger.warn('未开启任何有效站点，无法搜索资源')
-            return []
-
-        # 开始进度
-        progress = ProgressHelper(ProgressKey.Search)
-        progress.start()
-        # 开始计时
-        start_time = datetime.now()
-        # 总数
-        total_num = len(indexer_sites)
-        # 完成数
-        finish_count = 0
-        # 更新进度
-        progress.update(value=0,
-                        text=f"开始搜索，共 {total_num} 个站点 ...")
-        # 结果集
-        results = []
-
-        # 创建异步任务列表
-        tasks = []
+        executor = ThreadPoolExecutor(max_workers=len(indexer_sites))
+        all_task = []
        for site in indexer_sites:
            if area == "imdbid":
                # 搜索IMDBID
-                task = self.async_search_torrents(site=site,
-                                                  keyword=mediainfo.imdb_id if mediainfo else None,
-                                                  mtype=mediainfo.type if mediainfo else None,
-                                                  page=page)
+                task = executor.submit(self.search_torrents, site=site,
+                                       keywords=[mediainfo.imdb_id] if mediainfo else None,
+                                       mtype=mediainfo.type if mediainfo else None,
+                                       page=page)
            else:
                # 搜索标题
-                task = self.async_search_torrents(site=site,
-                                                  keyword=keyword,
-                                                  mtype=mediainfo.type if mediainfo else None,
-                                                  page=page)
-            tasks.append(task)
-
-        # 使用asyncio.as_completed来处理并发任务
-        for future in asyncio.as_completed(tasks):
-            if global_vars.is_system_stopped:
-                break
+                task = executor.submit(self.search_torrents, site=site,
+                                       keywords=keywords,
+                                       mtype=mediainfo.type if mediainfo else None,
+                                       page=page)
+            all_task.append(task)
+        # 结果集
+        results = []
+        for future in as_completed(all_task):
            finish_count += 1
-            result = await future
+            result = future.result()
            if result:
                results.extend(result)
            logger.info(f"站点搜索进度：{finish_count} / {total_num}")
-            progress.update(value=finish_count / total_num * 100,
-                            text=f"正在搜索{keyword or ''}，已完成 {finish_count} / {total_num} 个站点 ...")
-
+            self.progress.update(value=finish_count / total_num * 100,
+                                 text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
+                                 key=ProgressKey.Search)
        # 计算耗时
        end_time = datetime.now()
        # 更新进度
-        progress.update(value=100,
-                        text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
+        self.progress.update(value=100,
+                             text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒",
+                             key=ProgressKey.Search)
        logger.info(f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
        # 结束进度
-        progress.end()
-
+        self.progress.end(ProgressKey.Search)
        # 返回
        return results

+    def filter_torrents_by_rule(self,
+                                torrents: List[TorrentInfo],
+                                mediainfo: MediaInfo,
+                                filter_rule: Dict[str, str] = None,
+                                ) -> List[TorrentInfo]:
+        """
+        使用过滤规则过滤种子
+        :param torrents: 种子列表
+        :param filter_rule: 过滤规则
+        :param mediainfo: 媒体信息
+        """
+
+        if not filter_rule:
+            # 没有则取搜索默认过滤规则
+            filter_rule = self.systemconfig.get(SystemConfigKey.DefaultSearchFilterRules)
+        if not filter_rule:
+            return torrents
+
+        # 使用默认过滤规则再次过滤
+        return list(filter(
+            lambda t: self.torrenthelper.filter_torrent(
+                torrent_info=t,
+                filter_rule=filter_rule,
+                mediainfo=mediainfo
+            ),
+            torrents
+        ))
+
    @eventmanager.register(EventType.SiteDeleted)
    def remove_site(self, event: Event):
        """
--- a/app/chain/site.py
+++ b/app/chain/site.py
@@ -1,26 +1,30 @@
 import base64
 import re
 from datetime import datetime
-from typing import Optional, Tuple, Union, Dict
+from typing import Tuple, Optional
+from typing import Union
 from urllib.parse import urljoin

 from lxml import etree

 from app.chain import ChainBase
-from app.core.config import global_vars, settings
-from app.core.event import Event, eventmanager
+from app.core.config import settings
+from app.core.event import eventmanager, Event, EventManager
 from app.db.models.site import Site
 from app.db.site_oper import SiteOper
+from app.db.siteicon_oper import SiteIconOper
 from app.db.systemconfig_oper import SystemConfigOper
+from app.db.sitestatistic_oper import SiteStatisticOper
 from app.helper.browser import PlaywrightHelper
 from app.helper.cloudflare import under_challenge
 from app.helper.cookie import CookieHelper
 from app.helper.cookiecloud import CookieCloudHelper
+from app.helper.message import MessageHelper
 from app.helper.rss import RssHelper
-from app.helper.sites import SitesHelper  # noqa
+from app.helper.sites import SitesHelper
 from app.log import logger
-from app.schemas import MessageChannel, Notification, SiteUserData
-from app.schemas.types import EventType, NotificationType
+from app.schemas import MessageChannel, Notification
+from app.schemas.types import EventType
 from app.utils.http import RequestUtils
 from app.utils.site import SiteUtils
 from app.utils.string import StringUtils
@@ -33,6 +37,15 @@ class SiteChain(ChainBase):

    def __init__(self):
        super().__init__()
+        self.siteoper = SiteOper()
+        self.siteiconoper = SiteIconOper()
+        self.siteshelper = SitesHelper()
+        self.rsshelper = RssHelper()
+        self.cookiehelper = CookieHelper()
+        self.message = MessageHelper()
+        self.cookiecloud = CookieCloudHelper()
+        self.systemconfig = SystemConfigOper()
+        self.sitestatistic = SiteStatisticOper()

        # 特殊站点登录验证
        self.special_site_test = {
@@ -43,72 +56,8 @@ class SiteChain(ChainBase):
            "1ptba.com": self.__indexphp_test,
            "star-space.net": self.__indexphp_test,
            "yemapt.org": self.__yema_test,
-            "hddolby.com": self.__hddolby_test,
        }

-    def refresh_userdata(self, site: dict = None) -> Optional[SiteUserData]:
-        """
-        刷新站点的用户数据
-        :param site:  站点
-        :return: 用户数据
-        """
-        userdata: SiteUserData = self.run_module("refresh_userdata", site=site)
-        if userdata:
-            SiteOper().update_userdata(domain=StringUtils.get_url_domain(site.get("domain")),
-                                       name=site.get("name"),
-                                       payload=userdata.model_dump())
-            # 发送事件
-            eventmanager.send_event(EventType.SiteRefreshed, {
-                "site_id": site.get("id")
-            })
-            # 发送站点消息
-            if userdata.message_unread:
-                if userdata.message_unread_contents and len(userdata.message_unread_contents) > 0:
-                    for head, date, content in userdata.message_unread_contents:
-                        msg_title = f"【站点 {site.get('name')} 消息】"
-                        msg_text = f"时间：{date}\n标题：{head}\n内容：\n{content}"
-                        self.post_message(Notification(
-                            mtype=NotificationType.SiteMessage,
-                            title=msg_title, text=msg_text, link=site.get("url")
-                        ))
-                else:
-                    self.post_message(Notification(
-                        mtype=NotificationType.SiteMessage,
-                        title=f"站点 {site.get('name')} 收到 "
-                              f"{userdata.message_unread} 条新消息，请登陆查看",
-                        link=site.get("url")
-                    ))
-            # 低分享率警告
-            if userdata.ratio and float(userdata.ratio) < 1 and not bool(
-                    re.search(r"(贵宾|VIP?)", userdata.user_level or "", re.IGNORECASE)):
-                self.post_message(Notification(
-                    mtype=NotificationType.SiteMessage,
-                    title=f"【站点分享率低预警】",
-                    text=f"站点 {site.get('name')} 分享率 {userdata.ratio}，请注意！"
-                ))
-        return userdata
-
-    def refresh_userdatas(self) -> Optional[Dict[str, SiteUserData]]:
-        """
-        刷新所有站点的用户数据
-        """
-        any_site_updated = False
-        result = {}
-        for site in SitesHelper().get_indexers():
-            if global_vars.is_system_stopped:
-                return None
-            if site.get("is_active"):
-                userdata = self.refresh_userdata(site)
-                if userdata:
-                    any_site_updated = True
-                    result[site.get("name")] = userdata
-        if any_site_updated:
-            eventmanager.send_event(EventType.SiteRefreshed, {
-                "site_id": "*"
-            })
-
-        return result
-
    def is_special_site(self, domain: str) -> bool:
        """
        判断是否特殊站点
@@ -129,14 +78,10 @@ class SiteChain(ChainBase):
            proxies=settings.PROXY if site.proxy else None,
            timeout=site.timeout or 15
        ).get_res(url=site.url)
-        if res is None:
-            return False, "无法打开网站！"
-        if res.status_code == 200:
+        if res and res.status_code == 200:
            csrf_token = re.search(r'<meta name="x-csrf-token" content="(.+?)">', res.text)
            if csrf_token:
                token = csrf_token.group(1)
-        else:
-            return False, f"错误：{res.status_code} {res.reason}"
        if not token:
            return False, "无法获取Token"
        # 调用查询用户信息接口
@@ -150,15 +95,11 @@ class SiteChain(ChainBase):
            proxies=settings.PROXY if site.proxy else None,
            timeout=site.timeout or 15
        ).get_res(url=f"{site.url}api/user/getInfo")
-        if user_res is None:
-            return False, "无法打开网站！"
-        if user_res.status_code == 200:
+        if user_res and user_res.status_code == 200:
            user_info = user_res.json()
            if user_info and user_info.get("data"):
                return True, "连接成功"
-            return False, "Cookie已失效"
-        else:
-            return False, f"错误：{user_res.status_code} {user_res.reason}"
+        return False, "Cookie已失效"

    @staticmethod
    def __mteam_test(site: Site) -> Tuple[bool, str]:
@@ -169,24 +110,30 @@ class SiteChain(ChainBase):
        domain = StringUtils.get_url_domain(site.url)
        url = f"https://api.{domain}/api/member/profile"
        headers = {
+            "Content-Type": "application/json",
            "User-Agent": user_agent,
            "Accept": "application/json, text/plain, */*",
-            "x-api-key": site.apikey,
+            "Authorization": site.token
        }
        res = RequestUtils(
            headers=headers,
            proxies=settings.PROXY if site.proxy else None,
            timeout=site.timeout or 15
        ).post_res(url=url)
-        if res is None:
-            return False, "无法打开网站！"
-        if res.status_code == 200:
-            user_info = res.json() or {}
-            if user_info.get("data"):
-                return True, "连接成功"
-            return False, user_info.get("message", "鉴权已过期或无效")
-        else:
-            return False, f"错误：{res.status_code} {res.reason}"
+        if res and res.status_code == 200:
+            user_info = res.json()
+            if user_info and user_info.get("data"):
+                # 更新最后访问时间
+                res = RequestUtils(headers=headers,
+                                   timeout=site.timeout or 15,
+                                   proxies=settings.PROXY if site.proxy else None,
+                                   referer=f"{site.url}index"
+                                   ).post_res(url=f"https://api.{domain}/api/member/updateLastBrowse")
+                if res:
+                    return True, "连接成功"
+                else:
+                    return True, f"连接成功，但更新状态失败"
+        return False, "鉴权已过期或无效"

    @staticmethod
    def __yema_test(site: Site) -> Tuple[bool, str]:
@@ -206,15 +153,11 @@ class SiteChain(ChainBase):
            proxies=settings.PROXY if site.proxy else None,
            timeout=site.timeout or 15
        ).get_res(url=url)
-        if res is None:
-            return False, "无法打开网站！"
-        if res.status_code == 200:
+        if res and res.status_code == 200:
            user_info = res.json()
            if user_info and user_info.get("success"):
                return True, "连接成功"
-            return False, "Cookie已过期"
-        else:
-            return False, f"错误：{res.status_code} {res.reason}"
+        return False, "Cookie已过期"

    def __indexphp_test(self, site: Site) -> Tuple[bool, str]:
        """
@@ -223,32 +166,6 @@ class SiteChain(ChainBase):
        site.url = f"{site.url}index.php"
        return self.__test(site)

-    @staticmethod
-    def __hddolby_test(site: Site) -> Tuple[bool, str]:
-        """
-        判断站点是否已经登陆：hddolby
-        """
-        url = f"{site.url}api/v1/user/data"
-        headers = {
-            "Content-Type": "application/json",
-            "Accept": "application/json, text/plain, */*",
-            "x-api-key": site.apikey,
-        }
-        res = RequestUtils(
-            headers=headers,
-            proxies=settings.PROXY if site.proxy else None,
-            timeout=site.timeout or 15
-        ).get_res(url=url)
-        if res is None:
-            return False, "无法打开网站！"
-        if res.status_code == 200:
-            user_info = res.json()
-            if user_info and user_info.get("status") == 0:
-                return True, "连接成功"
-            return False, "APIKEY已过期"
-        else:
-            return False, f"错误：{res.status_code} {res.reason}"
-
    @staticmethod
    def __parse_favicon(url: str, cookie: str, ua: str) -> Tuple[str, Optional[str]]:
        """
@@ -266,20 +183,16 @@ class SiteChain(ChainBase):
            logger.error(f"获取站点页面失败：{url}")
            return favicon_url, None
        html = etree.HTML(html_text)
-        try:
-            if StringUtils.is_valid_html_element(html):
-                fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
-                if fav_link:
-                    favicon_url = urljoin(url, fav_link[0])
+        if html:
+            fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
+            if fav_link:
+                favicon_url = urljoin(url, fav_link[0])

-            res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
-            if res:
-                return favicon_url, base64.b64encode(res.content).decode()
-            else:
-                logger.error(f"获取站点图标失败：{favicon_url}")
-        finally:
-            if html is not None:
-                del html
+        res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
+        if res:
+            return favicon_url, base64.b64encode(res.content).decode()
+        else:
+            logger.error(f"获取站点图标失败：{favicon_url}")
        return favicon_url, None

    def sync_cookies(self, manual=False) -> Tuple[bool, str]:
@@ -293,36 +206,28 @@ class SiteChain(ChainBase):
            """
            if StringUtils.get_url_domain(inx.get("domain")) == sub_domain:
                return inx.get("domain")
-            for ext_d in inx.get("ext_domains", []):
+            for ext_d in inx.get("ext_domains"):
                if StringUtils.get_url_domain(ext_d) == sub_domain:
                    return ext_d
            return sub_domain

        logger.info("开始同步CookieCloud站点 ...")
-        cookies, msg = CookieCloudHelper().download()
+        cookies, msg = self.cookiecloud.download()
        if not cookies:
            logger.error(f"CookieCloud同步失败：{msg}")
            if manual:
-                self.messagehelper.put(msg, title="CookieCloud同步失败", role="system")
+                self.message.put(msg, title="CookieCloud同步失败", role="system")
            return False, msg
        # 保存Cookie或新增站点
        _update_count = 0
        _add_count = 0
        _fail_count = 0
-        siteshelper = SitesHelper()
-        siteoper = SiteOper()
-        rsshelper = RssHelper()
        for domain, cookie in cookies.items():
-            # 检查系统是否停止
-            if global_vars.is_system_stopped:
-                logger.info("系统正在停止，中断CookieCloud同步")
-                return False, "系统正在停止，同步被中断"
-                
            # 索引器信息
-            indexer = siteshelper.get_indexer(domain)
+            indexer = self.siteshelper.get_indexer(domain)
            # 数据库的站点信息
-            site_info = siteoper.get_by_domain(domain)
-            if site_info and site_info.is_active:
+            site_info = self.siteoper.get_by_domain(domain)
+            if site_info and site_info.is_active == 1:
                # 站点已存在，检查站点连通性
                status, msg = self.test(domain)
                # 更新站点Cookie
@@ -331,22 +236,21 @@ class SiteChain(ChainBase):
                    # 更新站点rss地址
                    if not site_info.public and not site_info.rss:
                        # 自动生成rss地址
-                        rss_url, errmsg = rsshelper.get_rss_link(
+                        rss_url, errmsg = self.rsshelper.get_rss_link(
                            url=site_info.url,
                            cookie=cookie,
                            ua=site_info.ua or settings.USER_AGENT,
-                            proxy=True if site_info.proxy else False,
-                            timeout=site_info.timeout or 15
+                            proxy=True if site_info.proxy else False
                        )
                        if rss_url:
                            logger.info(f"更新站点 {domain} RSS地址 ...")
-                            siteoper.update_rss(domain=domain, rss=rss_url)
+                            self.siteoper.update_rss(domain=domain, rss=rss_url)
                        else:
                            logger.warn(errmsg)
                    continue
                # 更新站点Cookie
                logger.info(f"更新站点 {domain} Cookie ...")
-                siteoper.update_cookie(domain=domain, cookies=cookie)
+                self.siteoper.update_cookie(domain=domain, cookies=cookie)
                _update_count += 1
            elif indexer:
                if settings.COOKIECLOUD_BLACKLIST and any(
@@ -356,15 +260,13 @@ class SiteChain(ChainBase):
                    continue
                # 新增站点
                domain_url = __indexer_domain(inx=indexer, sub_domain=domain)
-                proxy = False
                res = RequestUtils(cookies=cookie,
                                   ua=settings.USER_AGENT
                                   ).get_res(url=domain_url)
                if res and res.status_code in [200, 500, 403]:
-                    content = res.text
-                    if not indexer.get("public") and not SiteUtils.is_logged_in(content):
+                    if not indexer.get("public") and not SiteUtils.is_logged_in(res.text):
                        _fail_count += 1
-                        if under_challenge(content):
+                        if under_challenge(res.text):
                            logger.warn(f"站点 {indexer.get('name')} 被Cloudflare防护，无法登录，无法添加站点")
                            continue
                        logger.warn(
@@ -375,53 +277,31 @@ class SiteChain(ChainBase):
                    logger.warn(f"站点 {indexer.get('name')} 连接状态码：{res.status_code}，无法添加站点")
                    continue
                else:
-                    if not settings.PROXY_HOST:
-                        _fail_count += 1
-                        logger.warn(f"站点 {indexer.get('name')} 连接失败，无法添加站点")
-                        continue
-                    else:
-                        # 如果配置了代理，尝试通过代理重试
-                        logger.info(f"站点 {indexer.get('name')} 初次连接失败，尝试通过代理重试...")
-                        proxy = True
-                        res = RequestUtils(cookies=cookie,
-                                           ua=settings.USER_AGENT,
-                                           proxies=settings.PROXY
-                                           ).get_res(url=domain_url)
-                        if res and res.status_code in [200, 500, 403]:
-                            if not indexer.get("public") and not SiteUtils.is_logged_in(res.text):
-                                logger.warn(f"站点 {indexer.get('name')} 登录失败，即使通过代理，无法添加站点")
-                                _fail_count += 1
-                                continue
-                            logger.info(f"站点 {indexer.get('name')} 通过代理连接成功")
-                        else:
-                            logger.warn(f"站点 {indexer.get('name')} 通过代理连接失败，无法添加站点")
-                            _fail_count += 1
-                            continue
-
+                    _fail_count += 1
+                    logger.warn(f"站点 {indexer.get('name')} 连接失败，无法添加站点")
+                    continue
                # 获取rss地址
                rss_url = None
                if not indexer.get("public") and domain_url:
                    # 自动生成rss地址
-                    rss_url, errmsg = rsshelper.get_rss_link(url=domain_url,
-                                                             cookie=cookie,
-                                                             ua=settings.USER_AGENT,
-                                                             proxy=proxy)
+                    rss_url, errmsg = self.rsshelper.get_rss_link(url=domain_url,
+                                                                  cookie=cookie,
+                                                                  ua=settings.USER_AGENT)
                    if errmsg:
                        logger.warn(errmsg)
                # 插入数据库
                logger.info(f"新增站点 {indexer.get('name')} ...")
-                siteoper.add(name=indexer.get("name"),
-                             url=domain_url,
-                             domain=domain,
-                             cookie=cookie,
-                             rss=rss_url,
-                             proxy=1 if proxy else 0,
-                             public=1 if indexer.get("public") else 0)
+                self.siteoper.add(name=indexer.get("name"),
+                                  url=domain_url,
+                                  domain=domain,
+                                  cookie=cookie,
+                                  rss=rss_url,
+                                  public=1 if indexer.get("public") else 0)
                _add_count += 1

            # 通知站点更新
            if indexer:
-                eventmanager.send_event(EventType.SiteUpdated, {
+                EventManager().send_event(EventType.SiteUpdated, {
                    "domain": domain,
                })
        # 处理完成
@@ -429,7 +309,7 @@ class SiteChain(ChainBase):
        if _fail_count > 0:
            ret_msg += f"，{_fail_count}个站点添加失败，下次同步时将重试，也可以手动添加"
        if manual:
-            self.messagehelper.put(ret_msg, title="CookieCloud同步成功", role="system")
+            self.message.put(ret_msg, title="CookieCloud同步成功", role="system")
        logger.info(f"CookieCloud同步成功：{ret_msg}")
        return True, ret_msg

@@ -448,31 +328,29 @@ class SiteChain(ChainBase):
        if str(domain).startswith("http"):
            domain = StringUtils.get_url_domain(domain)
        # 站点信息
-        siteoper = SiteOper()
-        siteshelper = SitesHelper()
-        siteinfo = siteoper.get_by_domain(domain)
+        siteinfo = self.siteoper.get_by_domain(domain)
        if not siteinfo:
            logger.warn(f"未维护站点 {domain} 信息！")
            return
        # Cookie
        cookie = siteinfo.cookie
        # 索引器
-        indexer = siteshelper.get_indexer(domain)
+        indexer = self.siteshelper.get_indexer(domain)
        if not indexer:
            logger.warn(f"站点 {domain} 索引器不存在！")
            return
        # 查询站点图标
-        site_icon = siteoper.get_icon_by_domain(domain)
+        site_icon = self.siteiconoper.get_by_domain(domain)
        if not site_icon or not site_icon.base64:
            logger.info(f"开始缓存站点 {indexer.get('name')} 图标 ...")
            icon_url, icon_base64 = self.__parse_favicon(url=indexer.get("domain"),
                                                         cookie=cookie,
                                                         ua=settings.USER_AGENT)
            if icon_url:
-                siteoper.update_icon(name=indexer.get("name"),
-                                     domain=domain,
-                                     icon_url=icon_url,
-                                     icon_base64=icon_base64)
+                self.siteiconoper.update_icon(name=indexer.get("name"),
+                                              domain=domain,
+                                              icon_url=icon_url,
+                                              icon_base64=icon_base64)
                logger.info(f"缓存站点 {indexer.get('name')} 图标成功")
            else:
                logger.warn(f"缓存站点 {indexer.get('name')} 图标失败")
@@ -492,32 +370,11 @@ class SiteChain(ChainBase):
        # 获取主域名中间那段
        domain_host = StringUtils.get_url_host(domain)
        # 查询以"site.domain_host"开头的配置项，并清除
-        systemconfig = SystemConfigOper()
-        site_keys = systemconfig.all().keys()
+        site_keys = self.systemconfig.all().keys()
        for key in site_keys:
            if key.startswith(f"site.{domain_host}"):
                logger.info(f"清理站点配置：{key}")
-                systemconfig.delete(key)
-
-    @eventmanager.register(EventType.SiteUpdated)
-    def cache_site_userdata(self, event: Event):
-        """
-        缓存站点用户数据
-        """
-        if not event:
-            return
-        event_data = event.event_data or {}
-        # 主域名
-        domain = event_data.get("domain")
-        if not domain:
-            return
-        if str(domain).startswith("http"):
-            domain = StringUtils.get_url_domain(domain)
-        indexer = SitesHelper().get_indexer(domain)
-        if not indexer:
-            return
-        # 刷新站点用户数据
-        self.refresh_userdata(site=indexer) or {}
+                self.systemconfig.delete(key)

    def test(self, url: str) -> Tuple[bool, str]:
        """
@@ -527,8 +384,7 @@ class SiteChain(ChainBase):
        """
        # 检查域名是否可用
        domain = StringUtils.get_url_domain(url)
-        siteoper = SiteOper()
-        site_info = siteoper.get_by_domain(domain)
+        site_info = self.siteoper.get_by_domain(domain)
        if not site_info:
            return False, f"站点【{url}】不存在"

@@ -545,9 +401,9 @@ class SiteChain(ChainBase):
            # 统计
            seconds = (datetime.now() - start_time).seconds
            if state:
-                siteoper.success(domain=domain, seconds=seconds)
+                self.sitestatistic.success(domain=domain, seconds=seconds)
            else:
-                siteoper.fail(domain)
+                self.sitestatistic.fail(domain)
            return state, message
        except Exception as e:
            return False, f"{str(e)}！"
@@ -564,15 +420,13 @@ class SiteChain(ChainBase):
        public = site_info.public
        proxies = settings.PROXY if site_info.proxy else None
        proxy_server = settings.PROXY_SERVER if site_info.proxy else None
-        timeout = site_info.timeout or 60

        # 访问链接
        if render:
            page_source = PlaywrightHelper().get_page_source(url=site_url,
                                                             cookies=site_cookie,
                                                             ua=ua,
-                                                             proxies=proxy_server,
-                                                             timeout=timeout)
+                                                             proxies=proxy_server)
            if not public and not SiteUtils.is_logged_in(page_source):
                if under_challenge(page_source):
                    return False, f"无法通过Cloudflare！"
@@ -584,29 +438,27 @@ class SiteChain(ChainBase):
                               ).get_res(url=site_url)
            # 判断登录状态
            if res and res.status_code in [200, 500, 403]:
-                content = res.text
-                if not public and not SiteUtils.is_logged_in(content):
-                    if under_challenge(content):
+                if not public and not SiteUtils.is_logged_in(res.text):
+                    if under_challenge(res.text):
                        msg = "站点被Cloudflare防护，请打开站点浏览器仿真"
                    elif res.status_code == 200:
                        msg = "Cookie已失效"
                    else:
-                        msg = f"错误：{res.status_code} {res.reason}"
+                        msg = f"状态码：{res.status_code}"
                    return False, f"{msg}！"
                elif public and res.status_code != 200:
-                    return False, f"错误：{res.status_code} {res.reason}！"
+                    return False, f"状态码：{res.status_code}！"
            elif res is not None:
-                return False, f"错误：{res.status_code} {res.reason}！"
+                return False, f"状态码：{res.status_code}！"
            else:
                return False, f"无法打开网站！"
        return True, "连接成功"

-    def remote_list(self, channel: MessageChannel,
-                    userid: Union[str, int] = None, source: Optional[str] = None):
+    def remote_list(self, channel: MessageChannel, userid: Union[str, int] = None):
        """
        查询所有站点，发送消息
        """
-        site_list = SiteOper().list()
+        site_list = self.siteoper.list()
        if not site_list:
            self.post_message(Notification(
                channel=channel,
@@ -630,13 +482,10 @@ class SiteChain(ChainBase):
        # 发送列表
        self.post_message(Notification(
            channel=channel,
-            source=source,
            title=title, text="\n".join(messages), userid=userid,
-            link=settings.MP_DOMAIN('#/site'))
-        )
+            link=settings.MP_DOMAIN('#/site')))

-    def remote_disable(self, arg_str: str, channel: MessageChannel,
-                       userid: Union[str, int] = None, source: Optional[str] = None):
+    def remote_disable(self, arg_str, channel: MessageChannel, userid: Union[str, int] = None):
        """
        禁用站点
        """
@@ -646,8 +495,7 @@ class SiteChain(ChainBase):
        if not arg_str.isdigit():
            return
        site_id = int(arg_str)
-        siteoper = SiteOper()
-        site = siteoper.get(site_id)
+        site = self.siteoper.get(site_id)
        if not site:
            self.post_message(Notification(
                channel=channel,
@@ -655,42 +503,39 @@ class SiteChain(ChainBase):
                userid=userid))
            return
        # 禁用站点
-        siteoper.update(site_id, {
+        self.siteoper.update(site_id, {
            "is_active": False
        })
        # 重新发送消息
-        self.remote_list(channel=channel, userid=userid, source=source)
+        self.remote_list(channel, userid)

-    def remote_enable(self, arg_str: str, channel: MessageChannel,
-                      userid: Union[str, int] = None, source: Optional[str] = None):
+    def remote_enable(self, arg_str, channel: MessageChannel, userid: Union[str, int] = None):
        """
        启用站点
        """
        if not arg_str:
            return
        arg_strs = str(arg_str).split()
-        siteoper = SiteOper()
        for arg_str in arg_strs:
            arg_str = arg_str.strip()
            if not arg_str.isdigit():
                continue
            site_id = int(arg_str)
-            site = siteoper.get(site_id)
+            site = self.siteoper.get(site_id)
            if not site:
                self.post_message(Notification(
                    channel=channel,
                    title=f"站点编号 {site_id} 不存在！", userid=userid))
                return
            # 禁用站点
-            siteoper.update(site_id, {
+            self.siteoper.update(site_id, {
                "is_active": True
            })
        # 重新发送消息
-        self.remote_list(channel=channel, userid=userid, source=source)
+        self.remote_list(channel, userid)

-    @staticmethod
-    def update_cookie(site_info: Site,
-                      username: str, password: str, two_step_code: Optional[str] = None) -> Tuple[bool, str]:
+    def update_cookie(self, site_info: Site,
+                      username: str, password: str, two_step_code: str = None) -> Tuple[bool, str]:
        """
        根据用户名密码更新站点Cookie
        :param site_info: 站点信息
@@ -700,27 +545,25 @@ class SiteChain(ChainBase):
        :return: (是否成功, 错误信息)
        """
        # 更新站点Cookie
-        result = CookieHelper().get_site_cookie_ua(
+        result = self.cookiehelper.get_site_cookie_ua(
            url=site_info.url,
            username=username,
            password=password,
            two_step_code=two_step_code,
-            proxies=settings.PROXY_SERVER if site_info.proxy else None,
-            timeout=site_info.timeout or 60
+            proxies=settings.PROXY_HOST if site_info.proxy else None
        )
        if result:
            cookie, ua, msg = result
            if not cookie:
                return False, msg
-            SiteOper().update(site_info.id, {
+            self.siteoper.update(site_info.id, {
                "cookie": cookie,
                "ua": ua
            })
            return True, msg
        return False, "未知错误"

-    def remote_cookie(self, arg_str: str, channel: MessageChannel,
-                      userid: Union[str, int] = None, source: Optional[str] = None):
+    def remote_cookie(self, arg_str: str, channel: MessageChannel, userid: Union[str, int] = None):
        """
        使用用户名密码更新站点Cookie
        """
@@ -729,7 +572,6 @@ class SiteChain(ChainBase):
        if not arg_str:
            self.post_message(Notification(
                channel=channel,
-                source=source,
                title=err_title, userid=userid))
            return
        arg_str = str(arg_str).strip()
@@ -741,29 +583,25 @@ class SiteChain(ChainBase):
        elif len(args) != 3:
            self.post_message(Notification(
                channel=channel,
-                source=source,
                title=err_title, userid=userid))
            return
        site_id = args[0]
        if not site_id.isdigit():
            self.post_message(Notification(
                channel=channel,
-                source=source,
                title=err_title, userid=userid))
            return
        # 站点ID
        site_id = int(site_id)
        # 站点信息
-        site_info = SiteOper().get(site_id)
+        site_info = self.siteoper.get(site_id)
        if not site_info:
            self.post_message(Notification(
                channel=channel,
-                source=source,
                title=f"站点编号 {site_id} 不存在！", userid=userid))
            return
        self.post_message(Notification(
            channel=channel,
-            source=source,
            title=f"开始更新【{site_info.name}】Cookie&UA ...", userid=userid))
        # 用户名
        username = args[1]
@@ -778,76 +616,11 @@ class SiteChain(ChainBase):
            logger.error(msg)
            self.post_message(Notification(
                channel=channel,
-                source=source,
                title=f"【{site_info.name}】 Cookie&UA更新失败！",
                text=f"错误原因：{msg}",
                userid=userid))
        else:
            self.post_message(Notification(
                channel=channel,
-                source=source,
                title=f"【{site_info.name}】 Cookie&UA更新成功",
                userid=userid))
-
-    def remote_refresh_userdatas(self, channel: MessageChannel,
-                                 userid: Union[str, int] = None, source: Optional[str] = None):
-        """
-        刷新所有站点用户数据
-        """
-        logger.info("收到命令，开始刷新站点数据 ...")
-        self.post_message(Notification(
-            channel=channel,
-            source=source,
-            title="开始刷新站点数据 ...",
-            userid=userid
-        ))
-        # 刷新站点数据
-        site_datas = self.refresh_userdatas()
-        if site_datas:
-            # 发送消息
-            messages = {}
-            # 总上传
-            incUploads = 0
-            # 总下载
-            incDownloads = 0
-            # 今天日期
-            today_date = datetime.now().strftime("%Y-%m-%d")
-
-            for rand, site in enumerate(site_datas.keys()):
-                upload = int(site_datas[site].upload or 0)
-                download = int(site_datas[site].download or 0)
-                updated_date = site_datas[site].updated_day
-                if updated_date and updated_date != today_date:
-                    updated_date = f"（{updated_date}）"
-                else:
-                    updated_date = ""
-
-                if upload > 0 or download > 0:
-                    incUploads += upload
-                    incDownloads += download
-                    messages[upload + (rand / 1000)] = (
-                            f"【{site}】{updated_date}\n"
-                            + f"上传量：{StringUtils.str_filesize(upload)}\n"
-                            + f"下载量：{StringUtils.str_filesize(download)}\n"
-                            + "————————————"
-                    )
-            if incDownloads or incUploads:
-                sorted_messages = [messages[key] for key in sorted(messages.keys(), reverse=True)]
-                sorted_messages.insert(0, f"【汇总】\n"
-                                          f"总上传：{StringUtils.str_filesize(incUploads)}\n"
-                                          f"总下载：{StringUtils.str_filesize(incDownloads)}\n"
-                                          f"————————————")
-                self.post_message(Notification(
-                    channel=channel,
-                    source=source,
-                    title="【站点数据统计】",
-                    text="\n".join(sorted_messages),
-                    userid=userid
-                ))
-        else:
-            self.post_message(Notification(
-                channel=channel,
-                source=source,
-                title="没有刷新到任何站点数据！",
-                userid=userid
-            ))
--- a/app/chain/storage.py
+++ b/app/chain/storage.py
@@ -1,211 +0,0 @@
-from pathlib import Path
-from typing import Optional, Tuple, List, Dict
-
-from app import schemas
-from app.chain import ChainBase
-from app.core.config import settings
-from app.helper.directory import DirectoryHelper
-from app.log import logger
-
-
-class StorageChain(ChainBase):
-    """
-    存储处理链
-    """
-
-    def save_config(self, storage: str, conf: dict) -> None:
-        """
-        保存存储配置
-        """
-        self.run_module("save_config", storage=storage, conf=conf)
-
-    def reset_config(self, storage: str) -> None:
-        """
-        重置存储配置
-        """
-        self.run_module("reset_config", storage=storage)
-
-    def generate_qrcode(self, storage: str) -> Optional[Tuple[dict, str]]:
-        """
-        生成二维码
-        """
-        return self.run_module("generate_qrcode", storage=storage)
-
-    def check_login(self, storage: str, **kwargs) -> Optional[Tuple[dict, str]]:
-        """
-        登录确认
-        """
-        return self.run_module("check_login", storage=storage, **kwargs)
-
-    def list_files(self, fileitem: schemas.FileItem, recursion: bool = False) -> Optional[List[schemas.FileItem]]:
-        """
-        查询当前目录下所有目录和文件
-        """
-        return self.run_module("list_files", fileitem=fileitem, recursion=recursion)
-
-    def any_files(self, fileitem: schemas.FileItem, extensions: list = None) -> Optional[bool]:
-        """
-        查询当前目录下是否存在指定扩展名任意文件
-        """
-        return self.run_module("any_files", fileitem=fileitem, extensions=extensions)
-
-    def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
-        """
-        创建目录
-        """
-        return self.run_module("create_folder", fileitem=fileitem, name=name)
-
-    def download_file(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
-        """
-        下载文件
-        :param fileitem: 文件项
-        :param path: 本地保存路径
-        """
-        return self.run_module("download_file", fileitem=fileitem, path=path)
-
-    def upload_file(self, fileitem: schemas.FileItem, path: Path,
-                    new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
-        """
-        上传文件
-        :param fileitem: 保存目录项
-        :param path: 本地文件路径
-        :param new_name: 新文件名
-        """
-        return self.run_module("upload_file", fileitem=fileitem, path=path, new_name=new_name)
-
-    def delete_file(self, fileitem: schemas.FileItem) -> Optional[bool]:
-        """
-        删除文件或目录
-        """
-        return self.run_module("delete_file", fileitem=fileitem)
-
-    def rename_file(self, fileitem: schemas.FileItem, name: str) -> Optional[bool]:
-        """
-        重命名文件或目录
-        """
-        return self.run_module("rename_file", fileitem=fileitem, name=name)
-
-    def exists(self, fileitem: schemas.FileItem) -> Optional[bool]:
-        """
-        判断文件或目录是否存在
-        """
-        return True if self.get_item(fileitem) else False
-
-    def get_item(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
-        """
-        查询目录或文件
-        """
-        return self.get_file_item(storage=fileitem.storage, path=Path(fileitem.path))
-
-    def get_file_item(self, storage: str, path: Path) -> Optional[schemas.FileItem]:
-        """
-        根据路径获取文件项
-        """
-        return self.run_module("get_file_item", storage=storage, path=path)
-
-    def get_parent_item(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
-        """
-        获取上级目录项
-        """
-        return self.run_module("get_parent_item", fileitem=fileitem)
-
-    def snapshot_storage(self, storage: str, path: Path,
-                         last_snapshot_time: float = None, max_depth: int = 5) -> Optional[Dict[str, Dict]]:
-        """
-        快照存储
-        :param storage: 存储类型
-        :param path: 路径
-        :param last_snapshot_time: 上次快照时间，用于增量快照
-        :param max_depth: 最大递归深度，避免过深遍历
-        """
-        return self.run_module("snapshot_storage", storage=storage, path=path,
-                               last_snapshot_time=last_snapshot_time, max_depth=max_depth)
-
-    def storage_usage(self, storage: str) -> Optional[schemas.StorageUsage]:
-        """
-        存储使用情况
-        """
-        return self.run_module("storage_usage", storage=storage)
-
-    def support_transtype(self, storage: str) -> Optional[dict]:
-        """
-        获取支持的整理方式
-        """
-        return self.run_module("support_transtype", storage=storage)
-
-    def delete_media_file(self, fileitem: schemas.FileItem, delete_self: bool = True) -> bool:
-        """
-        删除媒体文件，以及不含媒体文件的目录
-        """
-
-        def __is_bluray_dir(_fileitem: schemas.FileItem) -> bool:
-            """
-            检查是否蓝光目录
-            """
-            _dir_files = self.list_files(fileitem=_fileitem, recursion=False)
-            if _dir_files:
-                for _f in _dir_files:
-                    if _f.type == "dir" and _f.name in ["BDMV", "CERTIFICATE"]:
-                        return True
-            return False
-
-        media_exts = settings.RMT_MEDIAEXT + settings.DOWNLOAD_TMPEXT
-        fileitem_path = Path(fileitem.path) if fileitem.path else Path("")
-        if len(fileitem_path.parts) <= 2:
-            logger.warn(f"【{fileitem.storage}】{fileitem.path} 根目录或一级目录不允许删除")
-            return False
-        if fileitem.type == "dir":
-            # 本身是目录
-            if __is_bluray_dir(fileitem):
-                logger.warn(f"正在删除蓝光原盘目录：【{fileitem.storage}】{fileitem.path}")
-                if not self.delete_file(fileitem):
-                    logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
-                    return False
-
-        elif delete_self:
-            # 本身是文件，需要删除文件
-            logger.warn(f"正在删除文件【{fileitem.storage}】{fileitem.path}")
-            if not self.delete_file(fileitem):
-                logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
-                return False
-
-        # 检查和删除上级空目录
-        dir_item = fileitem if fileitem.type == "dir" else self.get_parent_item(fileitem)
-        if not dir_item:
-            logger.warn(f"【{fileitem.storage}】{fileitem.path} 上级目录不存在")
-            return True
-
-        # 查找操作文件项匹配的配置目录(资源目录、媒体库目录)
-        associated_dir = max(
-            (
-                Path(p)
-                for d in DirectoryHelper().get_dirs()
-                for p in (d.download_path, d.library_path)
-                if p and fileitem_path.is_relative_to(p)
-            ),
-            key=lambda path: len(path.parts),
-            default=None,
-        )
-
-        while dir_item and len(Path(dir_item.path).parts) > 2:
-            # 目录是资源目录、媒体库目录的上级，则不处理
-            if associated_dir and associated_dir.is_relative_to(Path(dir_item.path)):
-                logger.debug(f"【{dir_item.storage}】{dir_item.path} 位于资源或媒体库目录结构中，不删除")
-                break
-
-            elif not associated_dir and self.list_files(dir_item, recursion=False):
-                logger.debug(f"【{dir_item.storage}】{dir_item.path} 不是空目录，不删除")
-                break
-
-            if self.any_files(dir_item, extensions=media_exts) is not False:
-                logger.debug(f"【{dir_item.storage}】{dir_item.path} 存在媒体文件，不删除")
-                break
-
-            # 删除空目录并继续处理父目录
-            logger.warn(f"【{dir_item.storage}】{dir_item.path} 不存在其它媒体文件，正在删除空目录")
-            if not self.delete_file(dir_item):
-                logger.warn(f"【{dir_item.storage}】{dir_item.path} 删除失败")
-                return False
-            dir_item = self.get_parent_item(dir_item)
-
-        return True
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jxxghp	52d0703812	v1.9.11 - 支持环境变量配置DOH域名和DNS服务器 - 问题修复	2024-07-09 08:09:58 +08:00
jxxghp	23fe643526	Merge pull request #2534 from InfinityPacer/main	2024-07-08 12:23:16 +08:00
jxxghp	545b3c0482	Merge pull request #2527 from s0urcelab/main	2024-07-08 12:22:50 +08:00
InfinityPacer	f102119eef	fix #2526 Backdrop优先调整为取art	2024-07-07 23:03:34 +08:00
s0urce	9bb3d707c9	feat: history query add `title` field	2024-07-07 18:27:06 +08:00
jxxghp	b892ef50dc	Merge pull request #2526 from InfinityPacer/main	2024-07-07 16:49:11 +08:00
InfinityPacer	41e2907168	fix jxxghp/MoviePilot-Plugins#38	2024-07-07 16:32:37 +08:00
jxxghp	14e28ed693	Merge pull request #2518 from InfinityPacer/main	2024-07-07 08:58:39 +08:00
InfinityPacer	79393c21ff	feat: 支持插件进行私钥认证	2024-07-06 20:03:49 +08:00
InfinityPacer	cafa4d217c	feat: 增加指定的仓库Github token	2024-07-06 16:07:46 +08:00
jxxghp	2b9e69b112	Merge pull request #2515 from BrettDean/main	2024-07-06 07:50:59 +08:00
Dean	3ffcea70a7	Fixed parsing of Telegram entities	2024-07-06 01:44:51 +08:00
jxxghp	ffc72ba6fe	fix #2508	2024-07-05 17:03:00 +08:00
jxxghp	848becd946	Merge pull request #2506 from Akimio521/main	2024-07-05 14:44:50 +08:00
Akimio521	71fe96d7f9	feat: 添加 DOH 解析服务器列表至配置文件实现自定义 DOH 服务器	2024-07-05 13:55:48 +08:00
jxxghp	35c7238ede	Merge pull request #2503 from Akimio521/main	2024-07-05 11:31:21 +08:00
Akimio521	3578204508	style	2024-07-05 10:52:39 +08:00
Akimio521	c11cf17f62	style:app.core.config.settings	2024-07-05 10:34:57 +08:00
Akimio521	5a59652684	feat:将使用 DOH 域名解析的域名添加至 app.core.config.settings	2024-07-05 09:31:41 +08:00
jxxghp	7f5f31f143	Merge pull request #2484 from InfinityPacer/main	2024-07-02 06:12:13 +08:00
InfinityPacer	dc1cee80b1	fix plugin install and reg	2024-07-02 01:11:42 +08:00
jxxghp	92cb066748	更新 version.py	2024-07-01 21:46:07 +08:00
jxxghp	6c8ef4122b	fix `e5ec02e043`	2024-07-01 12:23:02 +08:00
jxxghp	971b02ac8c	- 重新兼容了v1.9.1之前的版本直接升级 - 索引站点新增支持`HDVBits` - 自定义重命名新增季年份`season_year`占位符 - 修复了普通用户搜索越权问题	2024-07-01 10:46:29 +08:00
jxxghp	d4a9643f47	Merge pull request #2463 from InfinityPacer/main 处理链run_module支持raise_exception	2024-07-01 10:33:55 +08:00
InfinityPacer	e56d31fedc	fix exception	2024-06-30 11:50:26 +08:00
InfinityPacer	b9d91c5cd7	feat: DoubanModule触发限流时支持立即抛出限流异常	2024-06-30 11:48:29 +08:00
InfinityPacer	57cdb57331	feat: retry支持立即抛出异常	2024-06-30 11:47:30 +08:00
InfinityPacer	0f7a7ef44f	feat: 添加ImmediateException	2024-06-30 11:47:00 +08:00
InfinityPacer	6267b3f670	feat: run_module支持raise_exception	2024-06-30 11:41:00 +08:00
jxxghp	82f77b4729	Merge pull request #2456 from AisukaYuki/main	2024-06-30 09:09:36 +08:00
jxxghp	58da0ebb4f	Merge pull request #2460 from thsrite/main	2024-06-30 09:08:35 +08:00
thsrite	7a43e43478	fix 删除文件未删除thumb.jpg	2024-06-29 20:12:26 +08:00
AisukaYuki	e5ec02e043	add 自定义重命名新增季年份season_year	2024-06-29 13:50:40 +08:00
jxxghp	2944c343a8	Merge pull request #2432 from InfinityPacer/main	2024-06-26 18:21:00 +08:00
InfinityPacer	940cc566c8	fix douban rate_limit tips	2024-06-26 18:17:31 +08:00
jxxghp	db7b2cdcac	fix error	2024-06-26 17:42:08 +08:00
jxxghp	8111cf5dc8	- 站点索引及用户认证新增支持`海胆之家`	2024-06-26 16:18:14 +08:00