chore: update version to v1.3.7

Updated the funding model to include a custom sponsorship URL.

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: https://foxel.cc/sponsor.html

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,75 @@
+name: Bug Report / 缺陷报告
+description: Report reproducible defects with clear context / 请提供可复现的缺陷信息
+title: "[Bug] "
+labels:
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for helping us improve Foxel! / 感谢你帮助改进 Foxel！
+        Please confirm the checklist below before filing. / 在提交前请确认以下事项。
+  - type: checkboxes
+    id: validations
+    attributes:
+      label: Pre-flight Check / 提交前检查
+      options:
+        - label: I searched existing issues and docs / 我已搜索现有 Issue 与文档
+          required: true
+        - label: This is not a question or feature request / 这不是问题咨询或功能需求
+          required: true
+  - type: textarea
+    id: summary
+    attributes:
+      label: Bug Summary / 缺陷摘要
+      description: Briefly describe what is wrong / 简要说明出现了什么问题
+      placeholder: e.g. Upload fails with 500 error / 例如：上传时报 500 错误
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to Reproduce / 复现步骤
+      description: List numbered steps to trigger the bug / 列出触发问题的步骤
+      placeholder: |
+        1. ...
+        2. ...
+        3. ...
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected Behavior / 预期行为
+      description: What should happen instead? / 期望看到什么结果？
+    validations:
+      required: true
+  - type: textarea
+    id: actual
+    attributes:
+      label: Actual Behavior / 实际行为
+      description: What actually happens? Include messages or screenshots / 实际发生了什么？可附报错或截图
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: Version / 版本信息
+      description: Git commit, tag, or build number / 提供 Git 提交、标签或构建号
+    validations:
+      required: false
+  - type: textarea
+    id: environment
+    attributes:
+      label: Environment / 运行环境
+      description: OS, browser, API server config, etc. / 操作系统、浏览器、服务端配置等
+    validations:
+      required: false
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs & Attachments / 日志与附件
+      description: Paste relevant logs, stack traces, screenshots / 粘贴相关日志、堆栈或截图
+      render: shell
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,56 @@
+name: Feature Request / 功能需求
+description: Suggest enhancements or new capabilities / 提出改进或新增能力
+title: "[Feature] "
+labels:
+  - enhancement
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Tell us about your idea! / 欢迎分享你的想法！
+        Please complete the sections below so we can evaluate it quickly. / 请完整填写以下信息，便于快速评估。
+  - type: checkboxes
+    id: prechecks
+    attributes:
+      label: Pre-flight Check / 提交前检查
+      options:
+        - label: I searched existing issues and roadmap / 我已搜索现有 Issue 与路线图
+          required: true
+        - label: This is not a bug report or question / 这不是缺陷或问题咨询
+          required: true
+  - type: textarea
+    id: summary
+    attributes:
+      label: Feature Summary / 功能概述
+      description: What do you want to build? / 希望新增什么能力？
+      placeholder: e.g. Support sharing download links / 例如：支持分享下载链接
+    validations:
+      required: true
+  - type: textarea
+    id: motivation
+    attributes:
+      label: Motivation / 背景与价值
+      description: Why is this feature important? Who benefits? / 为什么重要？受益者是谁？
+    validations:
+      required: true
+  - type: textarea
+    id: scope
+    attributes:
+      label: Proposed Solution / 建议方案
+      description: Outline how the feature might work, including API or UI hints / 描述可能的实现方式，包含 API 或 UI 提示
+    validations:
+      required: false
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives / 可选方案
+      description: List any alternatives considered / 如有考虑过其他方案请列出
+    validations:
+      required: false
+  - type: textarea
+    id: extra
+    attributes:
+      label: Additional Context / 补充信息
+      description: Diagrams, sketches, links, constraints, etc. / 可附上草图、链接或约束
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/question.yml

@@ -0,0 +1,42 @@
+name: Question / 问题咨询
+description: Ask about usage, configuration, or clarification / 用于使用、配置或澄清问题
+title: "[Question] "
+labels:
+  - question
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Need help? You're in the right place. / 需要帮助？请按以下提示填写。
+        Check the docs before filing. / 提交前请先查阅文档。
+  - type: checkboxes
+    id: prechecks
+    attributes:
+      label: Pre-flight Check / 提交前检查
+      options:
+        - label: I searched existing issues and discussions / 我已搜索现有 Issue 和讨论
+          required: true
+        - label: I read the relevant documentation / 我已阅读相关文档
+          required: true
+  - type: textarea
+    id: question
+    attributes:
+      label: Question Details / 问题详情
+      description: What do you need help with? Be specific. / 具体说明需要帮助的内容
+      placeholder: Describe the scenario, expectation, and blockers / 说明场景、期望结果与阻碍
+    validations:
+      required: true
+  - type: textarea
+    id: tried
+    attributes:
+      label: What You Tried / 已尝试方案
+      description: List commands, configs, or steps attempted / 列出尝试过的命令、配置或步骤
+    validations:
+      required: false
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional Context / 补充信息
+      description: Environment details, logs, screenshots / 可补充运行环境、日志或截图
+    validations:
+      required: false

.github/release-drafter.yml

@@ -0,0 +1,22 @@
+name-template: 'v$RESOLVED_VERSION'
+tag-template: 'v$RESOLVED_VERSION'
+categories:
+  - title: '🚀 Features'
+    labels:
+      - 'feat'
+  - title: '🐛 Bug Fixes'
+    labels:
+      - 'fix'
+  - title: '📦 Code Refactoring'
+    labels:
+      - 'refactor'
+  - title: '📄 Documentation'
+    labels:
+      - 'docs'
+  - title: '🧰 Maintenance'
+    label: 'chore'
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+template: |
+  ## Changes
+
+  $CHANGES

.github/workflows/docker-clean.yml

@@ -0,0 +1,51 @@
+name: Clean dangling Docker images
+
+on:
+  workflow_dispatch:
+
+jobs:
+  docker-clean:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Delete untagged GHCR versions
+        shell: bash
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          OWNER="${GITHUB_REPOSITORY_OWNER}"
+          PACKAGE="$(echo "${GITHUB_REPOSITORY##*/}" | tr '[:upper:]' '[:lower:]')"
+
+          OWNER_TYPE="$(gh api "/users/${OWNER}" -q '.type')"
+          if [[ "${OWNER_TYPE}" == "Organization" ]]; then
+            SCOPE="orgs/${OWNER}"
+          else
+            SCOPE="users/${OWNER}"
+          fi
+
+          BASE_PATH="/${SCOPE}/packages/container/${PACKAGE}"
+
+          if ! gh api "${BASE_PATH}" >/dev/null 2>&1; then
+            echo "Package ghcr.io/${OWNER}/${PACKAGE} not found or accessible. Nothing to clean."
+            exit 0
+          fi
+
+          mapfile -t VERSION_IDS < <(gh api --paginate "${BASE_PATH}/versions?per_page=100" \
+            -q '.[] | select(.metadata.container.tags | length == 0) | .id')
+
+          if [[ ${#VERSION_IDS[@]} -eq 0 ]]; then
+            echo "No untagged versions to delete."
+            exit 0
+          fi
+
+          echo "Deleting ${#VERSION_IDS[@]} untagged versions from ghcr.io/${OWNER}/${PACKAGE}..."
+          for id in "${VERSION_IDS[@]}"; do
+            gh api -X DELETE "${BASE_PATH}/versions/${id}" >/dev/null
+            echo "Deleted version ${id}"
+          done
+
+          echo "Cleanup complete."

.github/workflows/docker.yml

@@ -2,6 +2,8 @@ name: Build and Push Docker image
 
 on:
   push:
+    branches:
+      - main
     tags:
       - 'v*.*.*'
   workflow_dispatch:
@@ -32,7 +34,7 @@ jobs:
             VERSION=${GITHUB_REF#refs/tags/}
             echo "DOCKER_TAGS=ghcr.io/${REPO_LC}:${VERSION},ghcr.io/${REPO_LC}:latest" >> $GITHUB_ENV
           else
-            echo "DOCKER_TAGS=ghcr.io/${REPO_LC}:latest" >> $GITHUB_ENV
+            echo "DOCKER_TAGS=ghcr.io/${REPO_LC}:dev" >> $GITHUB_ENV
           fi
 
       - name: Log in to GitHub Container Registry
@@ -42,10 +44,10 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push Docker image
+      - name: Build and push Docker image (multi arch)
         uses: docker/build-push-action@v5
         with:
           context: .
-          platforms: linux/amd64
+          platforms: linux/amd64,linux/arm64
           push: true
-          tags: ${{ env.DOCKER_TAGS }}
+          tags: ${{ env.DOCKER_TAGS }}

.github/workflows/release-drafter.yml

@@ -0,0 +1,17 @@
+name: Release Drafter
+
+on:
+  workflow_dispatch:
+
+jobs:
+  update_release_draft:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - uses: release-drafter/release-drafter@v5
+        with:
+          config-name: release-drafter.yml
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -5,5 +5,6 @@ __pycache__/
 .venv/
 .vscode/
 data/
-
-.env
+migrate/
+.env
+AGENTS.md

.python-version

@@ -0,0 +1 @@
+3.13

CONTRIBUTING.md

@@ -1,149 +1,162 @@
+<div align="right">
+  <b>English</b> | <a href="./CONTRIBUTING_zh.md">简体中文</a>
+</div>
+
 # Contributing to Foxel
 
-🎉 首先，非常感谢您愿意花时间为 Foxel 做出贡献！
+We appreciate every minute you spend helping Foxel improve. This guide explains the contribution workflow so you can get started quickly.
 
-我们热烈欢迎各种形式的贡献。无论是报告 Bug、提出新功能建议、完善文档，还是直接提交代码，都将对项目产生积极的影响。
+## Table of Contents
 
-本指南将帮助您顺利地参与到项目中来。
-
-## 目录
-
-- [如何贡献](#如何贡献)
-  - [🐛 报告 Bug](#-报告-bug)
-  - [✨ 提交功能建议](#-提交功能建议)
-  - [🛠️ 贡献代码](#️-贡献代码)
-- [开发环境搭建](#开发环境搭建)
-  - [依赖准备](#依赖准备)
-  - [后端 (FastAPI)](#后端-fastapi)
-  - [前端 (React + Vite)](#前端-react--vite)
-- [代码贡献指南](#代码贡献指南)
-  - [贡献存储适配器 (Adapter)](#贡献存储适配器-adapter)
-  - [贡献前端应用 (App)](#贡献前端应用-app)
-- [提交规范](#提交规范)
-  - [Git 分支管理](#git-分支管理)
-  - [Commit Message 格式](#commit-message-格式)
-  - [Pull Request 流程](#pull-request-流程)
+- [How to Contribute](#how-to-contribute)
+  - [🐛 Report Bugs](#-report-bugs)
+  - [✨ Suggest Features](#-suggest-features)
+  - [🛠️ Contribute Code](#️-contribute-code)
+- [Development Environment](#development-environment)
+  - [Prerequisites](#prerequisites)
+  - [Backend (FastAPI)](#backend-fastapi)
+  - [Frontend (React + Vite)](#frontend-react--vite)
+- [Contribution Guidelines](#contribution-guidelines)
+  - [Storage Adapters](#storage-adapters)
+  - [Frontend Apps](#frontend-apps)
+- [Submission Rules](#submission-rules)
+  - [Git Branching](#git-branching)
+  - [Commit Message Format](#commit-message-format)
+  - [Pull Request Flow](#pull-request-flow)
 
 ---
 
-## 如何贡献
+## How to Contribute
 
-### 🐛 报告 Bug
+### 🐛 Report Bugs
 
-如果您在使用的过程中发现了 Bug，请通过 [GitHub Issues](https://github.com/DrizzleTime/Foxel/issues) 来报告。请在报告中提供以下信息：
+If you discover a bug, open a ticket via [GitHub Issues](https://github.com/DrizzleTime/Foxel/issues) and include:
 
-- **清晰的标题**：简明扼要地描述问题。
-- **复现步骤**：详细说明如何一步步重现该 Bug。
-- **期望行为** vs **实际行为**：描述您预期的结果和实际发生的情况。
-- **环境信息**：例如操作系统、浏览器版本、Foxel 版本等。
+- **A clear title** that summarises the problem.
+- **Reproduction steps** with enough detail to trigger the bug.
+- **Expected vs actual behaviour** to highlight the gap.
+- **Environment details** such as operating system, browser version, and the Foxel build you used.
 
-### ✨ 提交功能建议
+### ✨ Suggest Features
 
-我们欢迎任何关于新功能或改进的建议。请通过 [GitHub Issues](https://github.com/DrizzleTime/Foxel/issues) 创建一个 "Feature Request"，并详细阐述您的想法：
+To propose a new capability or an improvement, create an Issue and choose the "Feature Request" template. Document:
 
-- **问题描述**：说明该功能要解决什么问题。
-- **方案设想**：描述您希望该功能如何工作。
-- **相关信息**：提供任何有助于理解您想法的截图、链接或参考。
+- **Problem statement** – what pain point will the feature solve?
+- **Proposed solution** – how you expect it to work.
+- **Supporting material** – screenshots, references, or related links if helpful.
 
-### 🛠️ 贡献代码
+### 🛠️ Contribute Code
 
-如果您希望直接贡献代码，请参考下面的开发和提交流程。
+Follow the development setup below before opening a pull request. Keep changes focused and small so they are easier to review.
 
-## 开发环境搭建
+## Development Environment
 
-### 依赖准备
+### Prerequisites
 
-- **Git**: 用于版本控制。
-- **Python**: >= 3.13
-- **Bun**: 用于前端包管理和脚本运行。
+Install the following tooling first:
 
-### 后端 (FastAPI)
+- **Git** for version control
+- **Python** 3.13 or newer
+- **Bun** for frontend package management and scripts
 
-后端 API 服务基于 Python 和 FastAPI 构建。
+### Backend (FastAPI)
 
-1. **克隆仓库**
+1. **Clone the repository**
 
     ```bash
     git clone https://github.com/DrizzleTime/foxel.git
     cd Foxel
     ```
 
-2. **创建并激活 Python 虚拟环境**
+2. **Create and activate a virtual environment**
+
+    `uv` is recommended for performance and reproducibility:
 
     ```bash
-    python3 -m venv .venv
+    uv venv
     source .venv/bin/activate
     # On Windows: .venv\Scripts\activate
     ```
 
-3. **安装依赖**
+3. **Install dependencies**
 
     ```bash
-    pip install -r requirements.txt
+    uv sync
     ```
 
-4. **启动开发服务器**
+4. **Prepare local resources**
+
+    - Create the data directory:
+
+      ```bash
+      mkdir -p data/db
+      ```
+
+      Ensure the application user can read and write to `data/db`.
+
+    - Create an `.env` file in the project root and provide the required secrets. Replace the sample values with your own random strings:
+
+      ```dotenv
+      SECRET_KEY=EnsRhL9NFPxgFVc+7t96/y70DIOR+9SpntcIqQa90TU=
+      TEMP_LINK_SECRET_KEY=EnsRhL9NFPxgFVc+7t96/y70DIOR+9SpntcIqQa90TU=
+      ```
+
+5. **Start the development server**
 
     ```bash
     uvicorn main:app --reload --host 0.0.0.0 --port 8000
     ```
 
-    API 服务将在 `http://localhost:8000` 上运行，您可以通过 `http://localhost:8000/docs` 访问自动生成的 API 文档。
+    The API is available at `http://localhost:8000`, and the interactive docs live at `http://localhost:8000/docs`.
 
-### 前端 (React + Vite)
+### Frontend (React + Vite)
 
-前端应用使用 React, Vite, 和 TypeScript 构建。
-
-1. **进入前端目录**
+1. **Enter the frontend directory**
 
     ```bash
     cd web
     ```
 
-2. **安装依赖**
+2. **Install dependencies**
 
     ```bash
     bun install
     ```
 
-3. **启动开发服务器**
+3. **Run the dev server**
 
     ```bash
     bun run dev
     ```
 
-    前端开发服务器将在 `http://localhost:5173` 运行。它已经配置了代理，会自动将 `/api` 请求转发到后端服务。
+    The Vite dev server runs at `http://localhost:5173` and proxies `/api` requests to the backend.
 
-## 代码贡献指南
+## Contribution Guidelines
 
-### 贡献存储适配器 (Adapter)
+### Storage Adapters
 
-存储适配器是 Foxel 的核心扩展点，用于接入不同的存储后端 (如 S3, FTP, Alist 等)。
+Storage adapters integrate new storage providers (for example S3, FTP, or Alist).
 
-1. **创建适配器文件**: 在 [`services/adapters/`](services/adapters/) 目录下，创建一个新文件，例如 `my_new_adapter.py`。
-2. **实现适配器类**:
-    - 创建一个类，继承自 [`services.adapters.base.BaseAdapter`](services/adapters/base.py)。
-    - 实现 `BaseAdapter` 中定义的所有抽象方法，如 `list_dir`, `get_meta`, `upload`, `download` 等。请仔细阅读基类中的文档注释以理解每个方法的作用和参数。
+1. Create a new module under [`services/adapters/`](services/adapters/) (for example `my_new_adapter.py`).
+2. Implement a class that inherits from [`services.adapters.base.BaseAdapter`](services/adapters/base.py) and provide concrete implementations for the abstract methods such as `list_dir`, `get_meta`, `upload`, and `download`.
 
-### 贡献前端应用 (App)
+### Frontend Apps
 
-前端应用允许用户在浏览器中直接预览或编辑特定类型的文件。
+Frontend apps enable in-browser previews or editors for specific file types.
 
-1. **创建应用组件**: 在 [`web/src/apps/`](web/src/apps/) 目录下，为您的应用创建一个新的文件夹，并在其中创建 React 组件。
-2. **定义应用类型**: 您的应用需要实现 [`web/src/apps/types.ts`](web/src/apps/types.ts) 中定义的 `FoxelApp` 接口。
-3. **注册应用**: 在 [`web/src/apps/registry.ts`](web/src/apps/registry.ts) 中，导入您的应用组件，并将其添加到 `APP_REGISTRY`。在注册时，您需要指定该应用可以处理的文件类型（通过 MIME Type 或文件扩展名）。
+1. Add a new folder in [`web/src/apps/`](web/src/apps/) for your app and expose a React component.
+2. Implement the `FoxelApp` interface defined in [`web/src/apps/types.ts`](web/src/apps/types.ts).
+3. Register the app in [`web/src/apps/registry.ts`](web/src/apps/registry.ts) and declare the MIME types or extensions it supports.
 
-## 提交规范
+## Submission Rules
 
-### Git 分支管理
+### Git Branching
 
-- 从最新的 `main` 分支创建您的特性分支。
+Start your work from the latest `main` branch and push feature changes on a dedicated branch.
 
-### Commit Message 格式
+### Commit Message Format
 
-我们遵循 [Conventional Commits](https://www.conventionalcommits.org/) 规范。这有助于自动化生成更新日志和版本管理。
-
-Commit Message 格式如下:
+We follow the [Conventional Commits](https://www.conventionalcommits.org/) specification to drive release tooling.
 
 ```
 <type>(<scope>): <subject>
@@ -153,27 +166,27 @@ Commit Message 格式如下:
 <footer>
 ```
 
-- **type**: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore` 等。
-- **scope**: (可选) 本次提交影响的范围，例如 `adapter`, `ui`, `api`。
-- **subject**: 简明扼要的描述。
+- **type**: e.g. `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`.
+- **scope** (optional): the area impacted by the change, such as `adapter`, `ui`, or `api`.
+- **subject**: a concise summary written in the imperative mood.
 
-**示例:**
+**Examples:**
 
 ```
-feat(adapter): Add support for Alist storage
+feat(adapter): add support for Alist storage
 ```
 
 ```
-fix(ui): Correct display issue in file list view
+fix(ui): correct display issue in file list view
 ```
 
-### Pull Request 流程
+### Pull Request Flow
 
-1. Fork 仓库并克隆到本地。
-2. 创建并切换到您的特性分支。
-3. 完成代码编写和测试。
-4. 将您的分支推送到您的 Fork 仓库。
-5. 在 Foxel 主仓库创建一个 Pull Request，目标分支为 `main`。
-6. 在 PR 描述中清晰地说明您的更改内容、目的和任何相关的 Issue 编号。
+1. Fork the repository and clone it locally.
+2. Create and switch to your feature branch.
+3. Implement the change and run relevant checks.
+4. Push the branch to your fork.
+5. Open a pull request against `main` in the Foxel repository.
+6. Explain the change set, its motivation, and reference related Issues in the PR description.
 
-项目维护者会尽快审查您的 PR。感谢您的耐心和贡献！
+Maintainers will review your pull request as soon as possible.

CONTRIBUTING_zh.md

@@ -0,0 +1,202 @@
+<div align="right">
+  <a href="./CONTRIBUTING.md">English</a> | <b>简体中文</b>
+</div>
+
+# Contributing to Foxel
+
+🎉 首先，非常感谢您愿意花时间为 Foxel 做出贡献！
+
+我们热烈欢迎各种形式的贡献。无论是报告 Bug、提出新功能建议、完善文档，还是直接提交代码，都将对项目产生积极的影响。
+
+本指南将帮助您顺利地参与到项目中来。
+
+## 目录
+
+- [如何贡献](#如何贡献)
+  - [🐛 报告 Bug](#-报告-bug)
+  - [✨ 提交功能建议](#-提交功能建议)
+  - [🛠️ 贡献代码](#️-贡献代码)
+- [开发环境搭建](#开发环境搭建)
+  - [依赖准备](#依赖准备)
+  - [后端 (FastAPI)](#后端-fastapi)
+  - [前端 (React + Vite)](#前端-react--vite)
+- [代码贡献指南](#代码贡献指南)
+  - [贡献存储适配器 (Adapter)](#贡献存储适配器-adapter)
+  - [贡献前端应用 (App)](#贡献前端应用-app)
+- [提交规范](#提交规范)
+  - [Git 分支管理](#git-分支管理)
+  - [Commit Message 格式](#commit-message-格式)
+  - [Pull Request 流程](#pull-request-流程)
+
+---
+
+## 如何贡献
+
+### 🐛 报告 Bug
+
+如果您在使用的过程中发现了 Bug，请通过 [GitHub Issues](https://github.com/DrizzleTime/Foxel/issues) 来报告。请在报告中提供以下信息：
+
+- **清晰的标题**：简明扼要地描述问题。
+- **复现步骤**：详细说明如何一步步重现该 Bug。
+- **期望行为** vs **实际行为**：描述您预期的结果和实际发生的情况。
+- **环境信息**：例如操作系统、浏览器版本、Foxel 版本等。
+
+### ✨ 提交功能建议
+
+我们欢迎任何关于新功能或改进的建议。请通过 [GitHub Issues](https://github.com/DrizzleTime/Foxel/issues) 创建一个 "Feature Request"，并详细阐述您的想法：
+
+- **问题描述**：说明该功能要解决什么问题。
+- **方案设想**：描述您希望该功能如何工作。
+- **相关信息**：提供任何有助于理解您想法的截图、链接或参考。
+
+### 🛠️ 贡献代码
+
+如果您希望直接贡献代码，请参考下面的开发和提交流程。
+
+## 开发环境搭建
+
+### 依赖准备
+
+- **Git**: 用于版本控制。
+- **Python**: >= 3.13
+- **Bun**: 用于前端包管理和脚本运行。
+
+### 后端 (FastAPI)
+
+后端 API 服务基于 Python 和 FastAPI 构建。
+
+1. **克隆仓库**
+
+    ```bash
+    git clone https://github.com/DrizzleTime/foxel.git
+    cd Foxel
+    ```
+
+2. **创建并激活 Python 虚拟环境**
+
+    我们推荐使用 `uv` 来管理虚拟环境，以获得最佳性能。
+
+    ```bash
+    uv venv
+    source .venv/bin/activate
+    # On Windows: .venv\Scripts\activate
+    ```
+
+3. **安装依赖**
+
+    ```bash
+    uv sync
+    ```
+
+4. **初始化环境**
+
+    在启动服务前，请进行以下准备：
+
+    - **创建数据目录**:
+      在项目根目录执行 `mkdir -p data/db`。这将创建用于存放数据库等文件的目录。
+      > [!IMPORTANT]
+      > 请确保应用拥有对 `data/db` 目录的读写权限。
+
+    - **创建 `.env` 配置文件**:
+      在项目根目录创建名为 `.env` 的文件，并填入以下内容。这些密钥用于保障应用安全，您可以按需修改。
+
+      ```dotenv
+      SECRET_KEY=EnsRhL9NFPxgFVc+7t96/y70DIOR+9SpntcIqQa90TU=
+      TEMP_LINK_SECRET_KEY=EnsRhL9NFPxgFVc+7t96/y70DIOR+9SpntcIqQa90TU=
+      ```
+
+5. **启动开发服务器**
+
+    ```bash
+    uvicorn main:app --reload --host 0.0.0.0 --port 8000
+    ```
+
+    API 服务将在 `http://localhost:8000` 上运行，您可以通过 `http://localhost:8000/docs` 访问自动生成的 API 文档。
+
+### 前端 (React + Vite)
+
+前端应用使用 React, Vite, 和 TypeScript 构建。
+
+1. **进入前端目录**
+
+    ```bash
+    cd web
+    ```
+
+2. **安装依赖**
+
+    ```bash
+    bun install
+    ```
+
+3. **启动开发服务器**
+
+    ```bash
+    bun run dev
+    ```
+
+    前端开发服务器将在 `http://localhost:5173` 运行。它已经配置了代理，会自动将 `/api` 请求转发到后端服务。
+
+## 代码贡献指南
+
+### 贡献存储适配器 (Adapter)
+
+存储适配器是 Foxel 的核心扩展点，用于接入不同的存储后端 (如 S3, FTP, Alist 等)。
+
+1. **创建适配器文件**: 在 [`services/adapters/`](services/adapters/) 目录下，创建一个新文件，例如 `my_new_adapter.py`。
+2. **实现适配器类**:
+    - 创建一个类，继承自 [`services.adapters.base.BaseAdapter`](services/adapters/base.py)。
+    - 实现 `BaseAdapter` 中定义的所有抽象方法，如 `list_dir`, `get_meta`, `upload`, `download` 等。请仔细阅读基类中的文档注释以理解每个方法的作用和参数。
+
+### 贡献前端应用 (App)
+
+前端应用允许用户在浏览器中直接预览或编辑特定类型的文件。
+
+1. **创建应用组件**: 在 [`web/src/apps/`](web/src/apps/) 目录下，为您的应用创建一个新的文件夹，并在其中创建 React 组件。
+2. **定义应用类型**: 您的应用需要实现 [`web/src/apps/types.ts`](web/src/apps/types.ts) 中定义的 `FoxelApp` 接口。
+3. **注册应用**: 在 [`web/src/apps/registry.ts`](web/src/apps/registry.ts) 中，导入您的应用组件，并将其添加到 `APP_REGISTRY`。在注册时，您需要指定该应用可以处理的文件类型（通过 MIME Type 或文件扩展名）。
+
+## 提交规范
+
+### Git 分支管理
+
+- 从最新的 `main` 分支创建您的特性分支。
+
+### Commit Message 格式
+
+我们遵循 [Conventional Commits](https://www.conventionalcommits.org/) 规范。这有助于自动化生成更新日志和版本管理。
+
+Commit Message 格式如下:
+
+```
+<type>(<scope>): <subject>
+<BLANK LINE>
+<body>
+<BLANK LINE>
+<footer>
+```
+
+- **type**: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore` 等。
+- **scope**: (可选) 本次提交影响的范围，例如 `adapter`, `ui`, `api`。
+- **subject**: 简明扼要的描述。
+
+**示例:**
+
+```
+feat(adapter): Add support for Alist storage
+```
+
+```
+fix(ui): Correct display issue in file list view
+```
+
+### Pull Request 流程
+
+1. Fork 仓库并克隆到本地。
+2. 创建并切换到您的特性分支。
+3. 完成代码编写和测试。
+4. 将您的分支推送到您的 Fork 仓库。
+5. 在 Foxel 主仓库创建一个 Pull Request，目标分支为 `main`。
+6. 在 PR 描述中清晰地说明您的更改内容、目的和任何相关的 Issue 编号。
+
+项目维护者会尽快审查您的 PR。感谢您的耐心和贡献！

Dockerfile

@@ -13,10 +13,15 @@ FROM python:3.13-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y nginx && rm -rf /var/lib/apt/lists/*
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends nginx git ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt && pip install gunicorn
+RUN pip install uv
+COPY pyproject.toml uv.lock ./
+RUN uv pip install --system . gunicorn
+
+RUN git clone https://github.com/DrizzleTime/FoxelUpgrade /app/migrate
 
 COPY --from=frontend-builder /app/web/dist /app/web/dist
 
@@ -24,9 +29,12 @@ COPY . .
 
 COPY nginx.conf /etc/nginx/nginx.conf
 
+RUN mkdir -p data/db data/mount && \
+    chmod 777 data/db data/mount
+    
 EXPOSE 80
 
 COPY entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh
 
-CMD ["/entrypoint.sh"]
+CMD ["/entrypoint.sh"]

README.md

@@ -1,8 +1,12 @@
+<div align="right">
+  <b>English</b> | <a href="./README_zh.md">简体中文</a>
+</div>
+
 <div align="center">
 
 # Foxel
 
-**一个面向个人和团队的、高度可扩展的私有云盘解决方案，支持 AI 语义搜索。**
+**A highly extensible private cloud storage solution for individuals and teams, featuring AI-powered semantic search.**
 
 ![Python Version](https://img.shields.io/badge/Python-3.13+-blue.svg)
 ![React](https://img.shields.io/badge/React-19.0-blue.svg)
@@ -11,26 +15,32 @@
 
 ---
   <blockquote>
-    <em><strong>数据之洋浩瀚无涯，当以洞察之目引航，然其脉络深隐，非表象所能尽窥。</strong></em><br>
     <em><strong>The ocean of data is boundless, let the eye of insight guide the voyage, yet its intricate connections lie deep, not fully discernible from the surface.</strong></em>
   </blockquote>
+  <img src="https://foxel.cc/image/ad-min.png" alt="UI Screenshot">
 </div>
 
-## ✨ 核心功能
+## 👀 Online Demo
 
-- **统一文件管理**：集中管理分布于不同存储后端的文件。
-- **插件化存储后端**：采用可扩展的适配器模式，方便集成多种存储类型。
-- **语义搜索**：支持自然语言描述搜索图片、文档等非结构化数据内容。
-- **内置文件预览**：可直接预览图片、视频、PDF、Office 文档及文本、代码文件，无需下载。
-- **权限与分享**：支持公开或私密分享链接，便于文件共享。
-- **任务处理中心**：支持异步任务处理，如文件索引和数据备份，不影响主应用运行。
+> [https://demo.foxel.cc](https://demo.foxel.cc)
+>
+> Account/Password: `admin` / `admin`
 
-## 🚀 快速开始
+## ✨ Core Features
 
-使用 Docker Compose 是启动 Foxel 最推荐的方式。
+- **Unified File Management**: Centralize management of files distributed across different storage backends.
+- **Pluggable Storage Backends**: Utilizes an extensible adapter pattern to easily integrate various storage types.
+- **Semantic Search**: Supports natural language search for content within unstructured data like images and documents.
+- **Built-in File Preview**: Preview images, videos, PDFs, Office documents, text, and code files directly without downloading.
+- **Permissions and Sharing**: Supports public or private sharing links for easy file distribution.
+- **Task Processing Center**: Supports asynchronous task processing, such as file indexing and data backups, without impacting the main application.
 
-1. **创建数据目录**:
-新建 `data` 文件夹用于持久化数据：
+## 🚀 Quick Start
+
+Using Docker Compose is the most recommended way to start Foxel.
+
+1. **Create Data Directories**:
+Create a `data` folder for persistent data:
 
 ```bash
 mkdir -p data/db
@@ -38,40 +48,40 @@ mkdir -p data/mount
 chmod 777 data/db data/mount
 ```
 
-2. **下载 Docker Compose 文件**：
+2. **Download Docker Compose File**:
 
   ```bash
   curl -L -O https://github.com/DrizzleTime/Foxel/raw/main/compose.yaml
   ```
 
-  下载完成后，**强烈建议**修改 `compose.yaml` 文件中的环境变量以确保安全：
+  After downloading, it is **strongly recommended** to modify the environment variables in the `compose.yaml` file to ensure security:
 
-- 修改 `SECRET_KEY` 和 `TEMP_LINK_SECRET_KEY`：将默认的密钥替换为随机生成的强密钥
+- Modify `SECRET_KEY` and `TEMP_LINK_SECRET_KEY`: Replace the default keys with randomly generated strong keys.
 
-3. **启动服务**:
+3. **Start the Services**:
 
   ```bash
   docker-compose up -d
   ```
 
-4. **访问应用**:
+4. **Access the Application**:
 
-  服务启动后，在浏览器中打开页面。
+  Once the services are running, open the page in your browser.
 
-  > 首次启动，请根据引导页面完成管理员账号的初始化设置。
+  > On the first launch, please follow the setup guide to initialize the administrator account.
 
-## 🤝 如何贡献
+## 🤝 How to Contribute
 
-我们非常欢迎来自社区的贡献！无论是提交 Bug、建议新功能还是直接贡献代码。
+We welcome contributions from the community! Whether it's submitting bugs, suggesting new features, or contributing code directly.
 
-在开始之前，请先阅读我们的 [`CONTRIBUTING.md`](CONTRIBUTING.md) 文件，它会指导你如何设置开发环境以及提交流程。
+Before you start, please read our [`CONTRIBUTING.md`](CONTRIBUTING.md) file, which explains the development environment and submission process. A Simplified Chinese translation is available in [`CONTRIBUTING_zh.md`](CONTRIBUTING_zh.md).
 
-## 🌐 社区
+## 🌐 Community
 
-加入我们的交流社区：[Telegram 群组](https://t.me/+thDsBfyqJxZkNTU1)，与开发者和用户一起讨论！
+Join our community on [Telegram](https://t.me/+thDsBfyqJxZkNTU1) to discuss with developers and other users!
 
-你也可以加入我们的微信群，获取更多实时交流与支持。请扫描下方二维码加入：
+You can also join our WeChat group for more real-time communication and support. Please scan the QR code below to join:
 
-<img src="https://foxel.cc/image/wechat.png" alt="微信群二维码" width="180">
+<img src="https://foxel.cc/image/wechat.png" alt="WeChat Group QR Code" width="180">
 
-> 如果二维码失效，请添加微信号 **drizzle2001**，我们会邀请你加入群聊。
+> If the QR code is invalid, please add WeChat ID **drizzle2001**, and we will invite you to the group.

README_zh.md

@@ -0,0 +1,88 @@
+<div align="right">
+  <a href="./README.md">English</a> | <b>简体中文</b>
+</div>
+
+<div align="center">
+
+# Foxel
+
+**一个面向个人和团队的、高度可扩展的私有云盘解决方案，支持 AI 语义搜索。**
+
+![Python Version](https://img.shields.io/badge/Python-3.13+-blue.svg)
+![React](https://img.shields.io/badge/React-19.0-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+![GitHub stars](https://img.shields.io/github/stars/DrizzleTime/foxel?style=social)
+
+---
+  <blockquote>
+    <em><strong>数据之洋浩瀚无涯，当以洞察之目引航，然其脉络深隐，非表象所能尽窥。</strong></em><br>
+    <em><strong>The ocean of data is boundless, let the eye of insight guide the voyage, yet its intricate connections lie deep, not fully discernible from the surface.</strong></em>
+  </blockquote>
+  <img src="https://foxel.cc/image/ad-min.png" alt="UI Screenshot">
+</div>
+
+## 👀 在线体验
+
+> [https://demo.foxel.cc](https://demo.foxel.cc)
+>
+> 账号/密码：`admin` / `admin`
+
+## ✨ 核心功能
+
+- **统一文件管理**：集中管理分布于不同存储后端的文件。
+- **插件化存储后端**：采用可扩展的适配器模式，方便集成多种存储类型。
+- **语义搜索**：支持自然语言描述搜索图片、文档等非结构化数据内容。
+- **内置文件预览**：可直接预览图片、视频、PDF、Office 文档及文本、代码文件，无需下载。
+- **权限与分享**：支持公开或私密分享链接，便于文件共享。
+- **任务处理中心**：支持异步任务处理，如文件索引和数据备份，不影响主应用运行。
+
+## 🚀 快速开始
+
+使用 Docker Compose 是启动 Foxel 最推荐的方式。
+
+1. **创建数据目录**:
+新建 `data` 文件夹用于持久化数据：
+
+```bash
+mkdir -p data/db
+mkdir -p data/mount
+chmod 777 data/db data/mount
+```
+
+2. **下载 Docker Compose 文件**：
+
+  ```bash
+  curl -L -O https://github.com/DrizzleTime/Foxel/raw/main/compose.yaml
+  ```
+
+  下载完成后，**强烈建议**修改 `compose.yaml` 文件中的环境变量以确保安全：
+
+- 修改 `SECRET_KEY` 和 `TEMP_LINK_SECRET_KEY`：将默认的密钥替换为随机生成的强密钥
+
+3. **启动服务**:
+
+  ```bash
+  docker-compose up -d
+  ```
+
+4. **访问应用**:
+
+  服务启动后，在浏览器中打开页面。
+
+  > 首次启动，请根据引导页面完成管理员账号的初始化设置。
+
+## 🤝 如何贡献
+
+我们非常欢迎来自社区的贡献！无论是提交 Bug、建议新功能还是直接贡献代码。
+
+在开始之前，请先阅读我们的 [`CONTRIBUTING_zh.md`](CONTRIBUTING_zh.md) 文件，它会指导你如何设置开发环境以及提交流程。
+
+## 🌐 社区
+
+加入我们的交流社区：[Telegram 群组](https://t.me/+thDsBfyqJxZkNTU1)，与开发者和用户一起讨论！
+
+你也可以加入我们的微信群，获取更多实时交流与支持。请扫描下方二维码加入：
+
+<img src="https://foxel.cc/image/wechat.png" alt="微信群二维码" width="180">
+
+> 如果二维码失效，请添加微信号 **drizzle2001**，我们会邀请你加入群聊。

api/routers.py

@@ -1,13 +1,14 @@
 from fastapi import FastAPI
 
-from .routes import adapters, virtual_fs, mounts, auth, config, processors, tasks, logs, share, backup, search
+from .routes import adapters, virtual_fs, auth, config, processors, tasks, logs, share, backup, search, vector_db, offline_downloads, ai_providers, email
+from .routes import webdav, s3
+from .routes import plugins
 
 
 def include_routers(app: FastAPI):
     app.include_router(adapters.router)
     app.include_router(virtual_fs.router)
     app.include_router(search.router)
-    app.include_router(mounts.router)
     app.include_router(auth.router)
     app.include_router(config.router)
     app.include_router(processors.router)
@@ -15,4 +16,11 @@ def include_routers(app: FastAPI):
     app.include_router(logs.router)
     app.include_router(share.router)
     app.include_router(share.public_router)
-    app.include_router(backup.router)
+    app.include_router(backup.router)
+    app.include_router(vector_db.router)
+    app.include_router(ai_providers.router)
+    app.include_router(plugins.router)
+    app.include_router(webdav.router)
+    app.include_router(s3.router)
+    app.include_router(offline_downloads.router)
+    app.include_router(email.router)

api/routes/adapters.py

@@ -2,7 +2,7 @@ from fastapi import APIRouter, HTTPException, Depends
 from tortoise.transactions import in_transaction
 from typing import Annotated
 
-from models import StorageAdapter, Mount
+from models import StorageAdapter
 from schemas import AdapterCreate, AdapterOut
 from services.auth import get_current_active_user, User
 from services.adapters.registry import runtime_registry, get_config_schemas
@@ -39,27 +39,22 @@ async def create_adapter(
     data: AdapterCreate,
     current_user: Annotated[User, Depends(get_current_active_user)]
 ):
+    norm_path = AdapterCreate.normalize_mount_path(data.path)
+    exists = await StorageAdapter.get_or_none(path=norm_path)
+    if exists:
+        raise HTTPException(400, detail="Mount path already exists")
+
     adapter_fields = {
         "name": data.name,
         "type": data.type,
         "config": validate_and_normalize_config(data.type, data.config or {}),
         "enabled": data.enabled,
+        "path": norm_path,
+        "sub_path": data.sub_path,
     }
-    norm_path = AdapterCreate.normalize_mount_path(data.mount_path)
-    exists = await Mount.get_or_none(path=norm_path)
-    if exists:
-        raise HTTPException(400, detail="Mount path already exists")
-    async with in_transaction():
-        rec = await StorageAdapter.create(**adapter_fields)
-        await Mount.create(
-            path=norm_path,
-            sub_path=data.sub_path,
-            adapter=rec,
-            enabled=True,
-        )
-    rec.mount_path = norm_path
-    rec.sub_path = data.sub_path
-    await runtime_registry.refresh()
+
+    rec = await StorageAdapter.create(**adapter_fields)
+    await runtime_registry.upsert(rec)
     await LogService.action(
         "route:adapters",
         f"Created adapter {rec.name}",
@@ -73,20 +68,8 @@ async def create_adapter(
 async def list_adapters(
     current_user: Annotated[User, Depends(get_current_active_user)]
 ):
-    adapters = await StorageAdapter.all().prefetch_related("mounts")
-    out = []
-    for a in adapters:
-        mount = a.mounts[0] if a.mounts else None
-        item = AdapterOut(
-            name=a.name,
-            type=a.type,
-            config=a.config,
-            enabled=a.enabled,
-            id=a.id,
-            mount_path=mount.path if mount else None,
-            sub_path=mount.sub_path if mount else None
-        )
-        out.append(item)
+    adapters = await StorageAdapter.all()
+    out = [AdapterOut.model_validate(a) for a in adapters]
     return success(out)
 
 
@@ -109,13 +92,10 @@ async def get_adapter(
     adapter_id: int,
     current_user: Annotated[User, Depends(get_current_active_user)]
 ):
-    rec = await StorageAdapter.get_or_none(id=adapter_id).prefetch_related("mounts")
+    rec = await StorageAdapter.get_or_none(id=adapter_id)
     if not rec:
         raise HTTPException(404, detail="Not found")
-    mount = rec.mounts[0] if rec.mounts else None
-    rec.mount_path = mount.path if mount else None
-    rec.sub_path = mount.sub_path if mount else None
-    return success(rec)
+    return success(AdapterOut.model_validate(rec))
 
 
 @router.put("/{adapter_id}")
@@ -124,34 +104,24 @@ async def update_adapter(
     data: AdapterCreate,
     current_user: Annotated[User, Depends(get_current_active_user)]
 ):
-
-    rec = await StorageAdapter.get_or_none(id=adapter_id).prefetch_related("mounts")
+    rec = await StorageAdapter.get_or_none(id=adapter_id)
     if not rec:
         raise HTTPException(404, detail="Not found")
-    norm_path = AdapterCreate.normalize_mount_path(data.mount_path)
-    existing = await Mount.get_or_none(path=norm_path)
-    mount = rec.mounts[0] if rec.mounts else None
-    if existing and (not mount or existing.id != mount.id):
+
+    norm_path = AdapterCreate.normalize_mount_path(data.path)
+    existing = await StorageAdapter.get_or_none(path=norm_path)
+    if existing and existing.id != adapter_id:
         raise HTTPException(400, detail="Mount path already exists")
+
     rec.name = data.name
     rec.type = data.type
     rec.config = validate_and_normalize_config(data.type, data.config or {})
     rec.enabled = data.enabled
+    rec.path = norm_path
+    rec.sub_path = data.sub_path
     await rec.save()
-    if mount:
-        mount.path = norm_path
-        mount.sub_path = data.sub_path
-        await mount.save()
-    else:
-        mount = await Mount.create(
-            path=norm_path,
-            sub_path=data.sub_path,
-            adapter=rec,
-            enabled=True,
-        )
-    rec.mount_path = mount.path
-    rec.sub_path = mount.sub_path
-    await runtime_registry.refresh()
+
+    await runtime_registry.upsert(rec)
     await LogService.action(
         "route:adapters",
         f"Updated adapter {rec.name}",
@@ -169,7 +139,7 @@ async def delete_adapter(
     deleted = await StorageAdapter.filter(id=adapter_id).delete()
     if not deleted:
         raise HTTPException(404, detail="Not found")
-    await runtime_registry.refresh()
+    runtime_registry.remove(adapter_id)
     await LogService.action(
         "route:adapters",
         f"Deleted adapter {adapter_id}",

api/routes/ai_providers.py

@@ -0,0 +1,177 @@
+from typing import Annotated, Dict, Optional
+
+import httpx
+from fastapi import APIRouter, Depends, HTTPException, Path
+
+from api.response import success
+from schemas.ai import (
+    AIDefaultsUpdate,
+    AIModelCreate,
+    AIModelUpdate,
+    AIProviderCreate,
+    AIProviderUpdate,
+)
+from services.ai_providers import AIProviderService
+from services.auth import User, get_current_active_user
+from services.vector_db import VectorDBService
+
+
+router = APIRouter(prefix="/api/ai", tags=["ai"])
+service = AIProviderService()
+
+
+@router.get("/providers")
+async def list_providers(
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    providers = await service.list_providers()
+    return success({"providers": providers})
+
+
+@router.post("/providers")
+async def create_provider(
+    payload: AIProviderCreate,
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    provider = await service.create_provider(payload.dict())
+    return success(provider)
+
+
+@router.get("/providers/{provider_id}")
+async def get_provider(
+    provider_id: Annotated[int, Path(..., gt=0)],
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    provider = await service.get_provider(provider_id, with_models=True)
+    return success(provider)
+
+
+@router.put("/providers/{provider_id}")
+async def update_provider(
+    provider_id: Annotated[int, Path(..., gt=0)],
+    payload: AIProviderUpdate,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    data = {k: v for k, v in payload.dict().items() if v is not None}
+    if not data:
+        raise HTTPException(status_code=400, detail="No fields to update")
+    provider = await service.update_provider(provider_id, data)
+    return success(provider)
+
+
+@router.delete("/providers/{provider_id}")
+async def delete_provider(
+    provider_id: Annotated[int, Path(..., gt=0)],
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    await service.delete_provider(provider_id)
+    return success({"id": provider_id})
+
+
+@router.post("/providers/{provider_id}/sync-models")
+async def sync_models(
+    provider_id: Annotated[int, Path(..., gt=0)],
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    try:
+        result = await service.sync_models(provider_id)
+    except (httpx.RequestError, httpx.HTTPStatusError) as exc:
+        raise HTTPException(status_code=502, detail=f"Failed to synchronize models: {exc}") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    return success(result)
+
+
+@router.get("/providers/{provider_id}/remote-models")
+async def fetch_remote_models(
+    provider_id: Annotated[int, Path(..., gt=0)],
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    try:
+        models = await service.fetch_remote_models(provider_id)
+    except (httpx.RequestError, httpx.HTTPStatusError) as exc:
+        raise HTTPException(status_code=502, detail=f"Failed to pull models: {exc}") from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    return success({"models": models})
+
+
+@router.get("/providers/{provider_id}/models")
+async def list_models(
+    provider_id: Annotated[int, Path(..., gt=0)],
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    models = await service.list_models(provider_id)
+    return success({"models": models})
+
+
+@router.post("/providers/{provider_id}/models")
+async def create_model(
+    provider_id: Annotated[int, Path(..., gt=0)],
+    payload: AIModelCreate,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    model = await service.create_model(provider_id, payload.dict())
+    return success(model)
+
+
+@router.put("/models/{model_id}")
+async def update_model(
+    model_id: Annotated[int, Path(..., gt=0)],
+    payload: AIModelUpdate,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    data = {k: v for k, v in payload.dict().items() if v is not None}
+    if not data:
+        raise HTTPException(status_code=400, detail="No fields to update")
+    model = await service.update_model(model_id, data)
+    return success(model)
+
+
+@router.delete("/models/{model_id}")
+async def delete_model(
+    model_id: Annotated[int, Path(..., gt=0)],
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    await service.delete_model(model_id)
+    return success({"id": model_id})
+
+
+def _get_embedding_dimension(entry: Optional[Dict]) -> Optional[int]:
+    if not entry:
+        return None
+    value = entry.get("embedding_dimensions")
+    return int(value) if value is not None else None
+
+
+@router.get("/defaults")
+async def get_defaults(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    defaults = await service.get_default_models()
+    return success(defaults)
+
+
+@router.put("/defaults")
+async def update_defaults(
+    payload: AIDefaultsUpdate,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    previous = await service.get_default_models()
+    try:
+        updated = await service.set_default_models(payload.as_mapping())
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    prev_dim = _get_embedding_dimension(previous.get("embedding"))
+    next_dim = _get_embedding_dimension(updated.get("embedding"))
+
+    if prev_dim and next_dim and prev_dim != next_dim:
+        try:
+            await VectorDBService().clear_all_data()
+        except Exception as exc:  # noqa: BLE001
+            raise HTTPException(status_code=500, detail=f"Failed to clear vector database: {exc}") from exc
+
+    return success(updated)

api/routes/auth.py

@@ -1,5 +1,6 @@
 from typing import Annotated
 from fastapi import APIRouter, HTTPException, Depends, Form
+import hashlib
 from fastapi.security import OAuth2PasswordRequestForm
 from services.auth import (
     authenticate_user_db,
@@ -7,10 +8,17 @@ from services.auth import (
     ACCESS_TOKEN_EXPIRE_MINUTES,
     register_user,
     Token,
+    get_current_active_user,
+    User,
+    request_password_reset,
+    verify_password_reset_token,
+    reset_password_with_token,
 )
 from pydantic import BaseModel
 from datetime import timedelta
 from api.response import success
+from models.database import UserAccount
+from services.auth import verify_password, get_password_hash
 
 router = APIRouter(prefix="/api/auth", tags=["auth"])
 
@@ -21,6 +29,7 @@ class RegisterRequest(BaseModel):
     email: str | None = None
     full_name: str | None = None
 
+
 @router.post("/register", summary="注册第一个管理员用户")
 async def register(data: RegisterRequest):
     """
@@ -51,3 +60,96 @@ async def login_for_access_token(
         data={"sub": user.username}, expires_delta=access_token_expires
     )
     return Token(access_token=access_token, token_type="bearer")
+
+
+@router.get("/me", summary="获取当前登录用户信息")
+async def get_me(current_user: Annotated[User, Depends(get_current_active_user)]):
+    """
+    返回当前登录用户的基本信息，并附带 gravatar 头像链接。
+    """
+    email = (current_user.email or "").strip().lower()
+    md5_hash = hashlib.md5(email.encode("utf-8")).hexdigest()
+    gravatar_url = f"https://cn.cravatar.com/avatar/{md5_hash}?s=64&d=identicon"
+    return success({
+        "id": current_user.id,
+        "username": current_user.username,
+        "email": current_user.email,
+        "full_name": current_user.full_name,
+        "gravatar_url": gravatar_url,
+    })
+
+
+class UpdateMeRequest(BaseModel):
+    email: str | None = None
+    full_name: str | None = None
+    old_password: str | None = None
+    new_password: str | None = None
+
+
+class PasswordResetRequest(BaseModel):
+    email: str
+
+
+class PasswordResetConfirm(BaseModel):
+    token: str
+    password: str
+
+
+@router.put("/me", summary="更新当前登录用户信息")
+async def update_me(
+    payload: UpdateMeRequest,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    db_user = await UserAccount.get_or_none(id=current_user.id)
+    if not db_user:
+        raise HTTPException(status_code=404, detail="用户不存在")
+
+    if payload.email is not None:
+        exists = await UserAccount.filter(email=payload.email).exclude(id=db_user.id).exists()
+        if exists:
+            raise HTTPException(status_code=400, detail="邮箱已被占用")
+        db_user.email = payload.email
+
+    if payload.full_name is not None:
+        db_user.full_name = payload.full_name
+
+    if payload.new_password:
+        if not payload.old_password:
+            raise HTTPException(status_code=400, detail="请提供原密码")
+        if not verify_password(payload.old_password, db_user.hashed_password):
+            raise HTTPException(status_code=400, detail="原密码错误")
+        db_user.hashed_password = get_password_hash(payload.new_password)
+
+    await db_user.save()
+
+    email = (db_user.email or "").strip().lower()
+    md5_hash = hashlib.md5(email.encode("utf-8")).hexdigest()
+    gravatar_url = f"https://cn.cravatar.com/avatar/{md5_hash}?s=64&d=identicon"
+    return success({
+        "id": db_user.id,
+        "username": db_user.username,
+        "email": db_user.email,
+        "full_name": db_user.full_name,
+        "gravatar_url": gravatar_url,
+    })
+
+
+@router.post("/password-reset/request", summary="请求密码重置邮件")
+async def password_reset_request_endpoint(payload: PasswordResetRequest):
+    await request_password_reset(payload.email)
+    return success(msg="如果邮箱存在，将发送重置邮件")
+
+
+@router.get("/password-reset/verify", summary="校验密码重置令牌")
+async def password_reset_verify(token: str):
+    user = await verify_password_reset_token(token)
+    return success({
+        "username": user.username,
+        "email": user.email,
+    })
+
+
+@router.post("/password-reset/confirm", summary="使用令牌重置密码")
+async def password_reset_confirm(payload: PasswordResetConfirm):
+    await reset_password_with_token(payload.token, payload.password)
+    return success(msg="密码已重置")

api/routes/config.py

@@ -37,11 +37,16 @@ async def get_all_config(
 
 @router.get("/status")
 async def get_system_status():
+    logo = await ConfigCenter.get("APP_LOGO", "/logo.svg")
+    favicon = await ConfigCenter.get("APP_FAVICON", logo)
     system_info = {
         "version": VERSION,
         "title": await ConfigCenter.get("APP_NAME", "Foxel"),
-        "logo": await ConfigCenter.get("APP_LOGO", "/logo.svg"),
-        "is_initialized": await has_users()
+        "logo": logo,
+        "favicon": favicon,
+        "is_initialized": await has_users(),
+        "app_domain": await ConfigCenter.get("APP_DOMAIN"),
+        "file_domain": await ConfigCenter.get("FILE_DOMAIN"),
     }
     return success(system_info)
 

api/routes/email.py

@@ -0,0 +1,92 @@
+from fastapi import APIRouter, Depends, HTTPException
+
+from services.auth import User, get_current_active_user
+from services.email import EmailService, EmailTemplateRenderer
+from schemas.email import EmailTestRequest, EmailTemplateUpdate, EmailTemplatePreviewPayload
+from api.response import success
+from services.logging import LogService
+
+
+router = APIRouter(
+    prefix="/api/email",
+    tags=["email"],
+)
+
+
+@router.post("/test")
+async def trigger_test_email(
+    payload: EmailTestRequest,
+    current_user: User = Depends(get_current_active_user),
+):
+    try:
+        task = await EmailService.enqueue_email(
+            recipients=[str(payload.to)],
+            subject=payload.subject,
+            template=payload.template,
+            context=payload.context,
+        )
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    await LogService.action(
+        "route:email",
+        "Triggered email test",
+        details={"task_id": task.id, "template": payload.template, "to": str(payload.to)},
+        user_id=getattr(current_user, "id", None),
+    )
+    return success({"task_id": task.id})
+
+
+@router.get("/templates")
+async def list_email_templates(
+    current_user: User = Depends(get_current_active_user),
+):
+    templates = await EmailTemplateRenderer.list_templates()
+    return success({"templates": templates})
+
+
+@router.get("/templates/{name}")
+async def get_email_template(
+    name: str,
+    current_user: User = Depends(get_current_active_user),
+):
+    try:
+        content = await EmailTemplateRenderer.load(name)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="模板不存在")
+    return success({"name": name, "content": content})
+
+
+@router.post("/templates/{name}")
+async def update_email_template(
+    name: str,
+    payload: EmailTemplateUpdate,
+    current_user: User = Depends(get_current_active_user),
+):
+    try:
+        await EmailTemplateRenderer.save(name, payload.content)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    await LogService.action(
+        "route:email",
+        "Updated email template",
+        details={"template": name},
+        user_id=getattr(current_user, "id", None),
+    )
+    return success({"name": name})
+
+
+@router.post("/templates/{name}/preview")
+async def preview_email_template(
+    name: str,
+    payload: EmailTemplatePreviewPayload,
+    current_user: User = Depends(get_current_active_user),
+):
+    try:
+        html = await EmailTemplateRenderer.render(name, payload.context)
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="模板不存在")
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return success({"html": html})

api/routes/mounts.py

@@ -1,84 +0,0 @@
-from fastapi import APIRouter, HTTPException, Depends
-from typing import Annotated
-
-from models import StorageAdapter, Mount
-from schemas import MountCreate, MountOut
-from api.response import success
-from services.auth import get_current_active_user, User
-from services.logging import LogService
-
-router = APIRouter(prefix="/api/mounts", tags=["mounts"])
-
-
-@router.post("")
-async def create_mount(
-    data: MountCreate,
-    current_user: Annotated[User, Depends(get_current_active_user)],
-):
-    adapter = await StorageAdapter.get_or_none(id=data.adapter_id)
-    if not adapter:
-        raise HTTPException(400, detail="Adapter not found")
-    rec = await Mount.create(
-        path=MountCreate.normalize(data.path),
-        adapter=adapter,
-        sub_path=data.sub_path,
-        enabled=data.enabled,
-    )
-    await LogService.action(
-        "route:mounts",
-        f"Created mount {rec.path}",
-        details=data.model_dump(),
-        user_id=current_user.id if hasattr(current_user, "id") else None,
-    )
-    return success(rec)
-
-
-@router.get("")
-async def list_mounts(
-    current_user: Annotated[User, Depends(get_current_active_user)],
-):
-    recs = await Mount.all()
-    return success(recs)
-
-
-@router.put("/{mount_id}")
-async def update_mount(
-    mount_id: int,
-    data: MountCreate,
-    current_user: Annotated[User, Depends(get_current_active_user)],
-):
-    rec = await Mount.get_or_none(id=mount_id)
-    if not rec:
-        raise HTTPException(404, detail="Not found")
-    adapter = await StorageAdapter.get_or_none(id=data.adapter_id)
-    if not adapter:
-        raise HTTPException(400, detail="Adapter not found")
-    rec.path = MountCreate.normalize(data.path)
-    rec.adapter = adapter
-    rec.sub_path = data.sub_path
-    rec.enabled = data.enabled
-    await rec.save()
-    await LogService.action(
-        "route:mounts",
-        f"Updated mount {rec.path}",
-        details=data.model_dump(),
-        user_id=current_user.id if hasattr(current_user, "id") else None,
-    )
-    return success(rec)
-
-
-@router.delete("/{mount_id}")
-async def delete_mount(
-    mount_id: int,
-    current_user: Annotated[User, Depends(get_current_active_user)],
-):
-    deleted = await Mount.filter(id=mount_id).delete()
-    if not deleted:
-        raise HTTPException(404, detail="Not found")
-    await LogService.action(
-        "route:mounts",
-        f"Deleted mount {mount_id}",
-        details={"mount_id": mount_id},
-        user_id=current_user.id if hasattr(current_user, "id") else None,
-    )
-    return success({"deleted": True})

api/routes/offline_downloads.py

@@ -0,0 +1,79 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from api.response import success
+from schemas.offline_downloads import OfflineDownloadCreate
+from services.auth import User, get_current_active_user
+from services.logging import LogService
+from services.task_queue import task_queue_service, TaskProgress
+from services.virtual_fs import path_is_directory
+
+
+router = APIRouter(
+    prefix="/api/offline-downloads",
+    tags=["OfflineDownloads"],
+)
+
+
+@router.post("/")
+async def create_offline_download(
+    payload: OfflineDownloadCreate,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    dest_dir = payload.dest_dir
+    try:
+        is_dir = await path_is_directory(dest_dir)
+    except HTTPException:
+        is_dir = False
+    if not is_dir:
+        raise HTTPException(400, detail="Destination directory not found")
+
+    task = await task_queue_service.add_task(
+        "offline_http_download",
+        {
+            "url": str(payload.url),
+            "dest_dir": dest_dir,
+            "filename": payload.filename,
+        },
+    )
+
+    await task_queue_service.update_progress(
+        task.id,
+        TaskProgress(
+            stage="queued",
+            percent=0.0,
+            bytes_total=None,
+            bytes_done=0,
+            detail="Waiting to start",
+        ),
+    )
+
+    await LogService.action(
+        "route:offline_downloads",
+        f"Offline download task created {task.id}",
+        details={"url": str(payload.url), "dest_dir": dest_dir, "filename": payload.filename},
+        user_id=current_user.id if hasattr(current_user, "id") else None,
+    )
+
+    return success({"task_id": task.id})
+
+
+@router.get("/")
+async def list_offline_downloads(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    tasks = [t for t in task_queue_service.get_all_tasks() if t.name == "offline_http_download"]
+    data = [t.dict() for t in tasks]
+    return success(data)
+
+
+@router.get("/{task_id}")
+async def get_offline_download(
+    task_id: str,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    task = task_queue_service.get_task(task_id)
+    if not task or task.name != "offline_http_download":
+        raise HTTPException(status_code=404, detail="Task not found")
+    return success(task.dict())

api/routes/plugins.py

@@ -0,0 +1,73 @@
+from typing import List, Any, Dict
+from fastapi import APIRouter, HTTPException, Body
+from models import database
+from schemas import PluginCreate, PluginOut
+
+router = APIRouter(prefix="/api/plugins", tags=["plugins"])
+
+
+@router.post("", response_model=PluginOut)
+async def create_plugin(payload: PluginCreate):
+    rec = await database.Plugin.create(
+        url=payload.url,
+        enabled=payload.enabled,
+    )
+    return PluginOut.model_validate(rec)
+
+
+@router.get("", response_model=List[PluginOut])
+async def list_plugins():
+    rows = await database.Plugin.all().order_by("-id")
+    return [PluginOut.model_validate(r) for r in rows]
+
+
+@router.delete("/{plugin_id}")
+async def delete_plugin(plugin_id: int):
+    rec = await database.Plugin.get_or_none(id=plugin_id)
+    if not rec:
+        raise HTTPException(status_code=404, detail="Plugin not found")
+    await rec.delete()
+    return {"code": 0, "msg": "ok"}
+
+
+@router.put("/{plugin_id}", response_model=PluginOut)
+async def update_plugin(plugin_id: int, payload: PluginCreate):
+    rec = await database.Plugin.get_or_none(id=plugin_id)
+    if not rec:
+        raise HTTPException(status_code=404, detail="Plugin not found")
+    rec.url = payload.url
+    rec.enabled = payload.enabled
+    await rec.save()
+    return PluginOut.model_validate(rec)
+
+
+@router.post("/{plugin_id}/metadata", response_model=PluginOut)
+async def update_manifest(plugin_id: int, manifest: Dict[str, Any] = Body(...)):
+    rec = await database.Plugin.get_or_none(id=plugin_id)
+    if not rec:
+        raise HTTPException(status_code=404, detail="Plugin not found")
+    key_map = {
+        'key': 'key',
+        'name': 'name',
+        'version': 'version',
+        'supported_exts': 'supported_exts',
+        'supportedExts': 'supported_exts',
+        'default_bounds': 'default_bounds',
+        'defaultBounds': 'default_bounds',
+        'default_maximized': 'default_maximized',
+        'defaultMaximized': 'default_maximized',
+        'icon': 'icon',
+        'description': 'description',
+        'author': 'author',
+        'website': 'website',
+        'github': 'github',
+    }
+    for k, v in list(manifest.items()):
+        if v is None:
+            continue
+        attr = key_map.get(k)
+        if not attr:
+            continue
+        setattr(rec, attr, v)
+    await rec.save()
+    return PluginOut.model_validate(rec)

api/routes/processors.py

@@ -1,10 +1,20 @@
-from fastapi import APIRouter, Depends, Body
+from pathlib import Path
+from fastapi import APIRouter, Depends, Body, HTTPException
+from fastapi.concurrency import run_in_threadpool
 from typing import Annotated
-from services.processors.registry import get_config_schemas
-from services.virtual_fs import process_file
+from services.processors.registry import (
+    get,
+    get_config_schema,
+    get_config_schemas,
+    get_module_path,
+    reload_processors,
+)
+from services.task_queue import task_queue_service
 from services.auth import get_current_active_user, User
 from api.response import success
 from pydantic import BaseModel
+from services.virtual_fs import path_is_directory, resolve_adapter_and_rel
+from typing import List, Optional, Tuple
 
 router = APIRouter(prefix="/api/processors", tags=["processors"])
 
@@ -21,7 +31,8 @@ async def list_processors(
             "name": meta["name"],
             "supported_exts": meta.get("supported_exts", []),
             "config_schema": meta["config_schema"],
-            "produces_file": meta.get("produces_file", False), 
+            "produces_file": meta.get("produces_file", False),
+            "module_path": meta.get("module_path"),
         })
     return success(out)
 
@@ -34,11 +45,206 @@ class ProcessRequest(BaseModel):
     overwrite: bool = False
 
 
+class ProcessDirectoryRequest(BaseModel):
+    path: str
+    processor_type: str
+    config: dict
+    overwrite: bool = True
+    max_depth: Optional[int] = None
+    suffix: Optional[str] = None
+
+
+class UpdateSourceRequest(BaseModel):
+    source: str
+
+
 @router.post("/process")
 async def process_file_with_processor(
     current_user: Annotated[User, Depends(get_current_active_user)],
     req: ProcessRequest = Body(...)
 ):
-    save_to = req.path if req.overwrite else req.save_to
-    result = await process_file(req.path, req.processor_type, req.config, save_to)
-    return success(result)
+    is_dir = await path_is_directory(req.path)
+    if is_dir and not req.overwrite:
+        raise HTTPException(400, detail="Directory processing requires overwrite")
+
+    save_to = None if is_dir else (req.path if req.overwrite else req.save_to)
+    task = await task_queue_service.add_task(
+        "process_file",
+        {
+            "path": req.path,
+            "processor_type": req.processor_type,
+            "config": req.config,
+            "save_to": save_to,
+            "overwrite": req.overwrite,
+        },
+    )
+    return success({"task_id": task.id})
+
+
+@router.post("/process-directory")
+async def process_directory_with_processor(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    req: ProcessDirectoryRequest = Body(...)
+):
+    if req.max_depth is not None and req.max_depth < 0:
+        raise HTTPException(400, detail="max_depth must be >= 0")
+
+    is_dir = await path_is_directory(req.path)
+    if not is_dir:
+        raise HTTPException(400, detail="Path must be a directory")
+
+    schema = get_config_schema(req.processor_type)
+    _processor = get(req.processor_type)
+    if not schema or not _processor:
+        raise HTTPException(404, detail="Processor not found")
+
+    produces_file = bool(schema.get("produces_file"))
+    raw_suffix = req.suffix if req.suffix is not None else None
+    if raw_suffix is not None and raw_suffix.strip() == "":
+        raw_suffix = None
+    suffix = raw_suffix
+    overwrite = req.overwrite
+
+    if produces_file:
+        if not overwrite and not suffix:
+            raise HTTPException(400, detail="Suffix is required when not overwriting files")
+    else:
+        overwrite = False
+        suffix = None
+
+    supported_exts = schema.get("supported_exts") or []
+    allowed_exts = {
+        ext.lower().lstrip('.')
+        for ext in supported_exts
+        if isinstance(ext, str)
+    }
+
+    def matches_extension(file_rel: str) -> bool:
+        if not allowed_exts:
+            return True
+        if '.' not in file_rel:
+            return '' in allowed_exts
+        ext = file_rel.rsplit('.', 1)[-1].lower()
+        return ext in allowed_exts or f'.{ext}' in allowed_exts
+
+    adapter_instance, adapter_model, root, rel = await resolve_adapter_and_rel(req.path)
+    rel = rel.rstrip('/')
+
+    list_dir = getattr(adapter_instance, "list_dir", None)
+    if not callable(list_dir):
+        raise HTTPException(501, detail="Adapter does not implement list_dir")
+
+    def build_absolute_path(mount_path: str, rel_path: str) -> str:
+        rel_norm = rel_path.lstrip('/')
+        mount_norm = mount_path.rstrip('/')
+        if not mount_norm:
+            return '/' + rel_norm if rel_norm else '/'
+        return f"{mount_norm}/{rel_norm}" if rel_norm else mount_norm
+
+    def apply_suffix(path_str: str, suffix_str: str) -> str:
+        path_obj = Path(path_str)
+        name = path_obj.name
+        if not name:
+            return path_str
+        if '.' in name:
+            base, ext = name.rsplit('.', 1)
+            new_name = f"{base}{suffix_str}.{ext}"
+        else:
+            new_name = f"{name}{suffix_str}"
+        return str(path_obj.with_name(new_name))
+
+    scheduled_tasks: List[str] = []
+    stack: List[Tuple[str, int]] = [(rel, 0)]
+    page_size = 200
+
+    while stack:
+        current_rel, depth = stack.pop()
+        page = 1
+        while True:
+            entries, total = await list_dir(root, current_rel, page, page_size, "name", "asc")
+            entries = entries or []
+            if not entries and (total or 0) == 0:
+                break
+
+            for entry in entries:
+                name = entry.get("name")
+                if not name:
+                    continue
+                child_rel = f"{current_rel}/{name}" if current_rel else name
+                if entry.get("is_dir"):
+                    if req.max_depth is None or depth < req.max_depth:
+                        stack.append((child_rel.rstrip('/'), depth + 1))
+                    continue
+                if not matches_extension(child_rel):
+                    continue
+                absolute_path = build_absolute_path(adapter_model.path, child_rel)
+                save_to = None
+                if produces_file and not overwrite and suffix:
+                    save_to = apply_suffix(absolute_path, suffix)
+                task = await task_queue_service.add_task(
+                    "process_file",
+                    {
+                        "path": absolute_path,
+                        "processor_type": req.processor_type,
+                        "config": req.config,
+                        "save_to": save_to,
+                        "overwrite": overwrite,
+                    },
+                )
+                scheduled_tasks.append(task.id)
+
+            if total is None or page * page_size >= total:
+                break
+            page += 1
+
+    return success({
+        "task_ids": scheduled_tasks,
+        "scheduled": len(scheduled_tasks),
+    })
+
+
+@router.get("/source/{processor_type}")
+async def get_processor_source(
+    processor_type: str,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    module_path = get_module_path(processor_type)
+    if not module_path:
+        raise HTTPException(404, detail="Processor not found")
+    path_obj = Path(module_path)
+    if not path_obj.exists():
+        raise HTTPException(404, detail="Processor source not found")
+    try:
+        content = await run_in_threadpool(path_obj.read_text, encoding='utf-8')
+    except Exception as exc:
+        raise HTTPException(500, detail=f"Failed to read source: {exc}")
+    return success({"source": content, "module_path": str(path_obj)})
+
+
+@router.put("/source/{processor_type}")
+async def update_processor_source(
+    processor_type: str,
+    req: UpdateSourceRequest,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    module_path = get_module_path(processor_type)
+    if not module_path:
+        raise HTTPException(404, detail="Processor not found")
+    path_obj = Path(module_path)
+    if not path_obj.exists():
+        raise HTTPException(404, detail="Processor source not found")
+    try:
+        await run_in_threadpool(path_obj.write_text, req.source, encoding='utf-8')
+    except Exception as exc:
+        raise HTTPException(500, detail=f"Failed to write source: {exc}")
+    return success(True)
+
+
+@router.post("/reload")
+async def reload_processor_modules(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    errors = reload_processors()
+    if errors:
+        raise HTTPException(500, detail="; ".join(errors))
+    return success(True)

api/routes/s3.py

@@ -0,0 +1,538 @@
+from __future__ import annotations
+
+import base64
+import datetime as dt
+import hashlib
+import hmac
+import uuid
+from typing import Dict, Iterable, List, Optional, Tuple
+
+from fastapi import APIRouter, Request, Response
+from fastapi import HTTPException
+
+from services.config import ConfigCenter
+from services.virtual_fs import (
+    delete_path,
+    list_virtual_dir,
+    stat_file,
+    stream_file,
+    write_file_stream,
+)
+
+
+router = APIRouter(prefix="/s3", tags=["s3"])
+
+
+FALSEY = {"0", "false", "off", "no"}
+_XML_NS = "http://s3.amazonaws.com/doc/2006-03-01/"
+
+
+class S3Settings(Dict[str, str]):
+    bucket: str
+    region: str
+    base_path: str
+    access_key: str
+    secret_key: str
+
+
+def _now_iso() -> str:
+    return dt.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.000Z")
+
+
+def _etag(key: str, size: Optional[int], mtime: Optional[int]) -> str:
+    raw = f"{key}|{size or 0}|{mtime or 0}".encode("utf-8")
+    return '"' + hashlib.md5(raw).hexdigest() + '"'
+
+
+def _meta_headers() -> Tuple[str, Dict[str, str]]:
+    req_id = uuid.uuid4().hex
+    headers = {
+        "x-amz-request-id": req_id,
+        "x-amz-id-2": uuid.uuid4().hex,
+        "Server": "FoxelS3",
+    }
+    return req_id, headers
+
+
+def _s3_error(code: str, message: str, resource: str = "", status: int = 400) -> Response:
+    req_id, headers = _meta_headers()
+    xml = (
+        f"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        f"<Error>"
+        f"<Code>{code}</Code>"
+        f"<Message>{message}</Message>"
+        f"<Resource>{resource}</Resource>"
+        f"<RequestId>{req_id}</RequestId>"
+        f"</Error>"
+    )
+    return Response(content=xml, status_code=status, media_type="application/xml", headers=headers)
+
+
+async def _ensure_enabled() -> Optional[Response]:
+    flag = await ConfigCenter.get("S3_MAPPING_ENABLED", "1")
+    if str(flag).strip().lower() in FALSEY:
+        return _s3_error("ServiceUnavailable", "S3 mapping disabled", status=503)
+    return None
+
+
+async def _get_settings() -> Tuple[Optional[S3Settings], Optional[Response]]:
+    bucket = (await ConfigCenter.get("S3_MAPPING_BUCKET", "foxel")) or "foxel"
+    region = (await ConfigCenter.get("S3_MAPPING_REGION", "us-east-1")) or "us-east-1"
+    base_path = (await ConfigCenter.get("S3_MAPPING_BASE_PATH", "/")) or "/"
+    access_key = (await ConfigCenter.get("S3_MAPPING_ACCESS_KEY")) or ""
+    secret_key = (await ConfigCenter.get("S3_MAPPING_SECRET_KEY")) or ""
+    if not access_key or not secret_key:
+        return None, _s3_error(
+            "InvalidAccessKeyId",
+            "S3 mapping access key/secret are not configured.",
+            status=403,
+        )
+    settings: S3Settings = {
+        "bucket": bucket,
+        "region": region,
+        "base_path": base_path,
+        "access_key": access_key,
+        "secret_key": secret_key,
+    }
+    return settings, None
+
+
+def _canonical_uri(path: str) -> str:
+    from urllib.parse import quote
+
+    if not path:
+        return "/"
+    return quote(path, safe="/-_.~")
+
+
+def _canonical_query(params: Iterable[Tuple[str, str]]) -> str:
+    from urllib.parse import quote
+
+    encoded = []
+    for key, value in params:
+        enc_key = quote(key, safe="-_.~")
+        enc_val = quote(value or "", safe="-_.~")
+        encoded.append((enc_key, enc_val))
+    encoded.sort()
+    return "&".join(f"{k}={v}" for k, v in encoded)
+
+
+def _normalize_ws(value: str) -> str:
+    return " ".join(value.strip().split())
+
+
+def _sign(key: bytes, msg: str) -> bytes:
+    return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()
+
+
+async def _authorize_sigv4(request: Request, settings: S3Settings) -> Optional[Response]:
+    auth = request.headers.get("authorization")
+    if not auth:
+        return _s3_error("AccessDenied", "Missing Authorization header", status=403)
+    scheme = "AWS4-HMAC-SHA256"
+    if not auth.startswith(scheme + " "):
+        return _s3_error("InvalidRequest", "Signature Version 4 is required", status=400)
+
+    parts: Dict[str, str] = {}
+    for segment in auth[len(scheme) + 1 :].split(","):
+        k, _, v = segment.strip().partition("=")
+        parts[k] = v
+
+    credential = parts.get("Credential")
+    signed_headers = parts.get("SignedHeaders")
+    signature = parts.get("Signature")
+    if not credential or not signed_headers or not signature:
+        return _s3_error("InvalidRequest", "Authorization header is malformed", status=400)
+
+    cred_parts = credential.split("/")
+    if len(cred_parts) != 5 or cred_parts[-1] != "aws4_request":
+        return _s3_error("InvalidRequest", "Credential scope is invalid", status=400)
+
+    access_key, datestamp, region, service, _ = cred_parts
+    if access_key != settings["access_key"]:
+        return _s3_error("InvalidAccessKeyId", "The AWS Access Key Id you provided does not exist in our records.", status=403)
+    if service != "s3":
+        return _s3_error("InvalidRequest", "Only service 's3' is supported", status=400)
+    if region != settings["region"]:
+        return _s3_error("AuthorizationHeaderMalformed", f"Region '{region}' is invalid", status=400)
+
+    amz_date = request.headers.get("x-amz-date")
+    if not amz_date or not amz_date.startswith(datestamp):
+        return _s3_error("AuthorizationHeaderMalformed", "x-amz-date does not match credential scope", status=400)
+
+    payload_hash = request.headers.get("x-amz-content-sha256")
+    if not payload_hash:
+        return _s3_error("AuthorizationHeaderMalformed", "Missing x-amz-content-sha256", status=400)
+    if payload_hash.upper().startswith("STREAMING-AWS4-HMAC-SHA256"):
+        return _s3_error("NotImplemented", "Chunked uploads are not supported", status=400)
+
+    signed_header_names = [h.strip().lower() for h in signed_headers.split(";") if h.strip()]
+    headers = {k.lower(): v for k, v in request.headers.items()}
+    canonical_headers = []
+    for name in signed_header_names:
+        value = headers.get(name)
+        if value is None:
+            return _s3_error("AuthorizationHeaderMalformed", f"Signed header '{name}' missing", status=400)
+        canonical_headers.append(f"{name}:{_normalize_ws(value)}\n")
+
+    canonical_request = "\n".join(
+        [
+            request.method,
+            _canonical_uri(request.url.path),
+            _canonical_query(request.query_params.multi_items()),
+            "".join(canonical_headers),
+            ";".join(signed_header_names),
+            payload_hash,
+        ]
+    )
+
+    hashed_request = hashlib.sha256(canonical_request.encode("utf-8")).hexdigest()
+    scope = "/".join([datestamp, region, "s3", "aws4_request"])
+    string_to_sign = "\n".join([scheme, amz_date, scope, hashed_request])
+
+    k_date = _sign(("AWS4" + settings["secret_key"]).encode("utf-8"), datestamp)
+    k_region = hmac.new(k_date, region.encode("utf-8"), hashlib.sha256).digest()
+    k_service = hmac.new(k_region, b"s3", hashlib.sha256).digest()
+    k_signing = hmac.new(k_service, b"aws4_request", hashlib.sha256).digest()
+    expected = hmac.new(k_signing, string_to_sign.encode("utf-8"), hashlib.sha256).hexdigest()
+    if expected != signature:
+        return _s3_error("SignatureDoesNotMatch", "The request signature we calculated does not match the signature you provided.", status=403)
+    return None
+
+
+def _virtual_path(settings: S3Settings, key: str) -> str:
+    key_norm = key.strip("/")
+    base_norm = settings["base_path"].strip("/")
+    segments = [seg for seg in [base_norm, key_norm] if seg]
+    if not segments:
+        return "/"
+    return "/" + "/".join(segments)
+
+
+def _join_virtual(base: str, name: str) -> str:
+    if not base or base == "/":
+        return "/" + name.strip("/")
+    return base.rstrip("/") + "/" + name.strip("/")
+
+
+async def _list_dir_all(path: str) -> List[Dict]:
+    items: List[Dict] = []
+    page_num = 1
+    page_size = 1000
+    while True:
+        try:
+            res = await list_virtual_dir(path, page_num=page_num, page_size=page_size)
+        except HTTPException as exc:  # directory missing
+            if exc.status_code in (400, 404):
+                return []
+            raise
+        chunk = res.get("items", [])
+        items.extend(chunk)
+        total = int(res.get("total", len(items)))
+        if len(items) >= total or not chunk or len(chunk) < page_size:
+            break
+        page_num += 1
+    return items
+
+
+async def _collect_objects(path: str, key_prefix: str, recursive: bool, collect_prefixes: bool) -> Tuple[List[Tuple[str, Dict]], List[str]]:
+    entries = await _list_dir_all(path)
+    files: List[Tuple[str, Dict]] = []
+    prefixes: List[str] = []
+    for entry in entries:
+        name = entry.get("name")
+        if not name:
+            continue
+        if entry.get("is_dir"):
+            dir_key = f"{key_prefix}{name.strip('/')}/"
+            if collect_prefixes:
+                prefixes.append(dir_key)
+            if recursive:
+                sub_path = _join_virtual(path, name)
+                sub_files, _ = await _collect_objects(sub_path, dir_key, True, False)
+                files.extend(sub_files)
+        else:
+            key = f"{key_prefix}{name}"
+            files.append((key, entry))
+    files.sort(key=lambda item: item[0])
+    prefixes.sort()
+    return files, prefixes
+
+
+def _encode_token(key: str) -> str:
+    raw = base64.urlsafe_b64encode(key.encode("utf-8")).decode("ascii")
+    return raw.rstrip("=")
+
+
+def _decode_token(token: str) -> Optional[str]:
+    if not token:
+        return None
+    padding = "=" * (-len(token) % 4)
+    try:
+        return base64.urlsafe_b64decode(token + padding).decode("utf-8")
+    except Exception:
+        return None
+
+
+def _apply_pagination(entries: List[Tuple[str, Dict]], prefixes: List[str], max_keys: int, start_after: Optional[str], continuation_token: Optional[str]) -> Tuple[List[Tuple[str, Dict]], List[str], bool, Optional[str]]:
+    combined = [(key, data, True) for key, data in entries] + [(prefix, None, False) for prefix in prefixes]
+    combined.sort(key=lambda item: item[0])
+
+    start_key = start_after or _decode_token(continuation_token or "")
+    if start_key:
+        combined = [item for item in combined if item[0] > start_key]
+
+    is_truncated = len(combined) > max_keys
+    sliced = combined[:max_keys]
+    next_token = _encode_token(sliced[-1][0]) if is_truncated and sliced else None
+
+    contents = [(key, data) for key, data, is_file in sliced if is_file]
+    next_prefixes = [key for key, _, is_file in sliced if not is_file]
+    return contents, next_prefixes, is_truncated, next_token
+
+
+def _format_contents(entries: List[Tuple[str, Dict]]) -> str:
+    blocks = []
+    for key, meta in entries:
+        size = int(meta.get("size", 0))
+        mtime = meta.get("mtime")
+        if mtime is not None:
+            try:
+                mtime_val = int(mtime)
+            except Exception:
+                mtime_val = 0
+        else:
+            mtime_val = 0
+        last_modified = dt.datetime.utcfromtimestamp(mtime_val or dt.datetime.utcnow().timestamp()).strftime("%Y-%m-%dT%H:%M:%S.000Z")
+        etag = _etag(key, size, mtime_val)
+        blocks.append(
+            f"<Contents><Key>{key}</Key><LastModified>{last_modified}</LastModified><ETag>{etag}</ETag><Size>{size}</Size><StorageClass>STANDARD</StorageClass></Contents>"
+        )
+    return "".join(blocks)
+
+
+def _format_common_prefixes(prefixes: List[str]) -> str:
+    return "".join(f"<CommonPrefixes><Prefix>{p}</Prefix></CommonPrefixes>" for p in prefixes)
+
+
+def _resource_path(bucket: str, key: Optional[str] = None) -> str:
+    if key:
+        return f"/s3/{bucket}/{key}"
+    return f"/s3/{bucket}"
+
+
+@router.get("")
+async def list_buckets(request: Request):
+    if (resp := await _ensure_enabled()) is not None:
+        return resp
+    settings, err = await _get_settings()
+    if err:
+        return err
+    assert settings
+    if (auth := await _authorize_sigv4(request, settings)) is not None:
+        return auth
+    req_id, headers = _meta_headers()
+    xml = (
+        f"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+        f"<ListAllMyBucketsResult xmlns=\"{_XML_NS}\">"
+        f"<Owner><ID>{settings['access_key']}</ID><DisplayName>Foxel</DisplayName></Owner>"
+        f"<Buckets><Bucket><Name>{settings['bucket']}</Name><CreationDate>{_now_iso()}</CreationDate></Bucket></Buckets>"
+        f"</ListAllMyBucketsResult>"
+    )
+    headers.update({"Content-Type": "application/xml"})
+    return Response(content=xml, media_type="application/xml", headers=headers)
+
+
+@router.get("/{bucket}")
+async def list_objects(request: Request, bucket: str):
+    if (resp := await _ensure_enabled()) is not None:
+        return resp
+    settings, err = await _get_settings()
+    if err:
+        return err
+    assert settings
+    if bucket != settings["bucket"]:
+        return _s3_error("NoSuchBucket", "The specified bucket does not exist.", _resource_path(bucket), status=404)
+    if (auth := await _authorize_sigv4(request, settings)) is not None:
+        return auth
+
+    params = request.query_params
+    if params.get("list-type", "2") != "2":
+        return _s3_error("InvalidArgument", "Only ListObjectsV2 (list-type=2) is supported.", _resource_path(bucket), status=400)
+
+    prefix = (params.get("prefix") or "").lstrip("/")
+    delimiter = params.get("delimiter")
+    recursive = not delimiter
+    max_keys_raw = params.get("max-keys", "1000")
+    try:
+        max_keys = max(1, min(1000, int(max_keys_raw)))
+    except ValueError:
+        max_keys = 1000
+    start_after = (params.get("start-after") or "").lstrip("/") or None
+    continuation = params.get("continuation-token")
+
+    # Exact file match if prefix is non-empty and does not end with '/'
+    files: List[Tuple[str, Dict]] = []
+    prefixes: List[str] = []
+    if prefix and not prefix.endswith("/"):
+        try:
+            info = await stat_file(_virtual_path(settings, prefix))
+            if not info.get("is_dir"):
+                files = [(prefix, info)]
+        except HTTPException as exc:
+            if exc.status_code not in (400, 404):
+                raise
+        if files:
+            contents, next_prefixes, is_truncated, next_token = _apply_pagination(files, [], max_keys, start_after, continuation)
+            xml = _build_list_result(bucket, prefix, delimiter, contents, next_prefixes, max_keys, is_truncated, continuation, next_token, start_after)
+            return xml
+
+    dir_prefix = prefix if not prefix or prefix.endswith("/") else prefix + "/"
+    virtual_dir = _virtual_path(settings, dir_prefix)
+    files, prefixes = await _collect_objects(virtual_dir, dir_prefix, recursive, bool(delimiter))
+
+    contents, next_prefixes, is_truncated, next_token = _apply_pagination(files, prefixes if delimiter else [], max_keys, start_after, continuation)
+    return _build_list_result(bucket, prefix, delimiter, contents, next_prefixes if delimiter else [], max_keys, is_truncated, continuation, next_token, start_after)
+
+
+def _build_list_result(
+    bucket: str,
+    prefix: str,
+    delimiter: Optional[str],
+    contents: List[Tuple[str, Dict]],
+    prefixes: List[str],
+    max_keys: int,
+    is_truncated: bool,
+    continuation: Optional[str],
+    next_token: Optional[str],
+    start_after: Optional[str],
+):
+    req_id, headers = _meta_headers()
+    body = [f"<?xml version=\"1.0\" encoding=\"UTF-8\"?>", f"<ListBucketResult xmlns=\"{_XML_NS}\">"]
+    body.append(f"<Name>{bucket}</Name>")
+    body.append(f"<Prefix>{prefix}</Prefix>")
+    if delimiter:
+        body.append(f"<Delimiter>{delimiter}</Delimiter>")
+    if continuation:
+        body.append(f"<ContinuationToken>{continuation}</ContinuationToken>")
+    if start_after:
+        body.append(f"<StartAfter>{start_after}</StartAfter>")
+    body.append(f"<MaxKeys>{max_keys}</MaxKeys>")
+    body.append(f"<KeyCount>{len(contents) + len(prefixes)}</KeyCount>")
+    body.append(f"<IsTruncated>{str(is_truncated).lower()}</IsTruncated>")
+    if next_token:
+        body.append(f"<NextContinuationToken>{next_token}</NextContinuationToken>")
+    body.append(_format_contents(contents))
+    if prefixes:
+        body.append(_format_common_prefixes(prefixes))
+    body.append("</ListBucketResult>")
+    xml = "".join(body)
+    headers.update({"Content-Type": "application/xml"})
+    return Response(content=xml, media_type="application/xml", headers=headers)
+
+
+async def _ensure_bucket_and_auth(request: Request, bucket: str) -> Tuple[Optional[S3Settings], Optional[Response]]:
+    if (resp := await _ensure_enabled()) is not None:
+        return None, resp
+    settings, err = await _get_settings()
+    if err:
+        return None, err
+    assert settings
+    if bucket != settings["bucket"]:
+        return None, _s3_error("NoSuchBucket", "The specified bucket does not exist.", _resource_path(bucket), status=404)
+    if (auth := await _authorize_sigv4(request, settings)) is not None:
+        return None, auth
+    return settings, None
+
+
+def _object_headers(meta: Dict, key: str) -> Dict[str, str]:
+    size = int(meta.get("size", 0))
+    mtime = meta.get("mtime")
+    if mtime is not None:
+        try:
+            mtime_val = int(mtime)
+        except Exception:
+            mtime_val = 0
+    else:
+        mtime_val = 0
+    last_modified = dt.datetime.utcfromtimestamp(mtime_val or dt.datetime.utcnow().timestamp()).strftime("%a, %d %b %Y %H:%M:%S GMT")
+    headers = {
+        "Content-Length": str(size),
+        "ETag": _etag(key, size, mtime_val),
+        "Last-Modified": last_modified,
+        "Accept-Ranges": "bytes",
+        "x-amz-version-id": "null",
+    }
+    return headers
+
+
+async def _stat_object(settings: S3Settings, key: str) -> Tuple[Optional[Dict], Optional[Response]]:
+    try:
+        info = await stat_file(_virtual_path(settings, key))
+        if info.get("is_dir"):
+            return None, _s3_error("NoSuchKey", "The specified key does not exist.", _resource_path(settings["bucket"], key), status=404)
+        return info, None
+    except HTTPException as exc:
+        if exc.status_code == 404:
+            return None, _s3_error("NoSuchKey", "The specified key does not exist.", _resource_path(settings["bucket"], key), status=404)
+        raise
+
+
+@router.api_route("/{bucket}/{object_path:path}", methods=["GET", "HEAD"])
+async def object_get_head(request: Request, bucket: str, object_path: str):
+    settings, error = await _ensure_bucket_and_auth(request, bucket)
+    if error:
+        return error
+    assert settings
+    key = object_path.lstrip("/")
+    meta, err = await _stat_object(settings, key)
+    if err:
+        return err
+    assert meta
+    _, base_headers = _meta_headers()
+    base_headers.update(_object_headers(meta, key))
+    if request.method == "HEAD":
+        return Response(status_code=200, headers=base_headers)
+    resp = await stream_file(_virtual_path(settings, key), request.headers.get("range"))
+    safe_merge_keys = {"ETag", "Last-Modified", "x-amz-version-id", "Accept-Ranges"}
+    for hk, hv in base_headers.items():
+        if hk in safe_merge_keys:
+            resp.headers.setdefault(hk, hv)
+    resp.headers.setdefault("Content-Type", meta.get("mime") or "application/octet-stream")
+    return resp
+
+
+@router.put("/{bucket}/{object_path:path}")
+async def put_object(request: Request, bucket: str, object_path: str):
+    settings, error = await _ensure_bucket_and_auth(request, bucket)
+    if error:
+        return error
+    assert settings
+    key = object_path.lstrip("/")
+    await write_file_stream(_virtual_path(settings, key), request.stream(), overwrite=True)
+    meta, err = await _stat_object(settings, key)
+    if err:
+        return err
+    headers = _object_headers(meta, key)
+    headers.pop("Content-Length", None)
+    headers.pop("Accept-Ranges", None)
+    headers["Content-Length"] = "0"
+    _, extra = _meta_headers()
+    headers.update(extra)
+    return Response(status_code=200, headers=headers)
+
+
+@router.delete("/{bucket}/{object_path:path}")
+async def delete_object(request: Request, bucket: str, object_path: str):
+    settings, error = await _ensure_bucket_and_auth(request, bucket)
+    if error:
+        return error
+    assert settings
+    key = object_path.lstrip("/")
+    try:
+        await delete_path(_virtual_path(settings, key))
+    except HTTPException as exc:
+        if exc.status_code not in (400, 404):
+            raise
+    _, headers = _meta_headers()
+    return Response(status_code=204, headers=headers)

api/routes/search.py

@@ -1,4 +1,7 @@
+from typing import Any, Dict, List, Tuple
+
 from fastapi import APIRouter, Depends, Query
+
 from schemas.fs import SearchResultItem
 from services.auth import get_current_active_user, User
 from services.ai import get_text_embedding
@@ -6,24 +9,96 @@ from services.vector_db import VectorDBService
 
 router = APIRouter(prefix="/api/search", tags=["search"])
 
-async def search_files_by_vector(q: str, top_k: int):
-    embedding = await get_text_embedding(q)
-    vector_db = VectorDBService()
-    results = vector_db.search_vectors("vector_collection", embedding, top_k)
-    items = [
-        SearchResultItem(id=res["id"], path=res["entity"]["path"], score=res["distance"])
-        for res in results[0]
-    ]
-    return {"items": items, "query": q}
 
-async def search_files_by_name(q: str, top_k: int):
+def _normalize_result(raw: Dict[str, Any], source: str, fallback_score: float = 0.0) -> SearchResultItem:
+    entity = dict(raw.get("entity") or {})
+    source_path = entity.get("source_path")
+    stored_path = entity.get("path")
+    path = source_path or stored_path or ""
+    chunk_id_value = entity.get("chunk_id")
+    chunk_id = str(chunk_id_value) if chunk_id_value is not None else None
+    snippet = entity.get("text") or entity.get("description") or entity.get("name")
+    mime = entity.get("mime")
+    start_offset = entity.get("start_offset")
+    end_offset = entity.get("end_offset")
+    raw_score = raw.get("distance")
+    score = float(raw_score) if raw_score is not None else fallback_score
+
+    metadata = {
+        "retrieval_source": source,
+        "raw_distance": raw_score,
+    }
+    if stored_path and stored_path != path:
+        metadata["stored_path"] = stored_path
+    vector_id = entity.get("vector_id")
+    if vector_id:
+        metadata["vector_id"] = vector_id
+
+    return SearchResultItem(
+        id=str(raw.get("id")),
+        path=path,
+        score=score,
+        chunk_id=chunk_id,
+        snippet=snippet,
+        mime=mime,
+        source_type=entity.get("type") or source,
+        start_offset=start_offset,
+        end_offset=end_offset,
+        metadata=metadata,
+    )
+
+
+async def _vector_search(query: str, top_k: int) -> List[SearchResultItem]:
     vector_db = VectorDBService()
-    results = vector_db.search_by_path("vector_collection", q, top_k)
-    items = [
-        SearchResultItem(id=idx, path=res["entity"]["path"], score=res["distance"])
-        for idx, res in enumerate(results[0])
-    ]
-    return {"items": items, "query": q}
+    try:
+        embedding = await get_text_embedding(query)
+    except Exception:
+        embedding = None
+    if not embedding:
+        return []
+
+    try:
+        raw_results = await vector_db.search_vectors("vector_collection", embedding, max(top_k, 10))
+    except Exception:
+        return []
+
+    results: List[SearchResultItem] = []
+    for bucket in raw_results or []:
+        for record in bucket or []:
+            results.append(_normalize_result(record, "vector"))
+    return results
+
+
+async def _filename_search(query: str, page: int, page_size: int) -> Tuple[List[SearchResultItem], bool]:
+    vector_db = VectorDBService()
+    limit = max(page * page_size + 1, page_size * (page + 2))
+    limit = min(limit, 2000)
+    try:
+        raw_results = await vector_db.search_by_path("vector_collection", query, limit)
+    except Exception:
+        return [], False
+
+    records = raw_results[0] if raw_results else []
+    deduped: List[SearchResultItem] = []
+    seen_paths: set[str] = set()
+    for record in records or []:
+        item = _normalize_result(record, "filename", fallback_score=1.0)
+        stored_path = item.metadata.get("stored_path") if item.metadata else None
+        key = item.path or stored_path or ""
+        if key in seen_paths:
+            continue
+        seen_paths.add(key)
+        deduped.append(item)
+
+    start = max(page - 1, 0) * page_size
+    end = start + page_size
+    page_items = deduped[start:end]
+    for offset, item in enumerate(page_items):
+        if item.metadata is None:
+            item.metadata = {}
+        item.metadata.setdefault("retrieval_rank", start + offset)
+    has_more = len(deduped) > end
+    return page_items, has_more
 
 
 @router.get("")
@@ -31,11 +106,32 @@ async def search_files(
     q: str = Query(..., description="搜索查询"),
     top_k: int = Query(10, description="返回结果数量"),
     mode: str = Query("vector", description="搜索模式: 'vector' 或 'filename'"),
+    page: int = Query(1, description="分页页码，仅在文件名搜索模式下生效"),
+    page_size: int = Query(10, description="分页大小，仅在文件名搜索模式下生效"),
     user: User = Depends(get_current_active_user),
 ):
+    if not q.strip():
+        return {"items": [], "query": q}
+
+    top_k = max(top_k, 1)
+    page = max(page, 1)
+    page_size = max(min(page_size, 100), 1)
+
     if mode == "vector":
-        return await search_files_by_vector(q, top_k)
+        items = (await _vector_search(q, top_k))[:top_k]
     elif mode == "filename":
-        return await search_files_by_name(q, top_k)
+        items, has_more = await _filename_search(q, page, page_size)
+        return {
+            "items": items,
+            "query": q,
+            "mode": mode,
+            "pagination": {
+                "page": page,
+                "page_size": page_size,
+                "has_more": has_more,
+            },
+        }
     else:
-        return {"items": [], "query": q, "error": "Invalid search mode"}
+        items = (await _vector_search(q, top_k))[:top_k]
+
+    return {"items": items, "query": q, "mode": mode}

api/routes/share.py

@@ -83,6 +83,18 @@ async def get_my_shares(current_user: User = Depends(get_current_active_user)):
     return [ShareInfo.from_orm(s) for s in shares]
 
 
+@router.delete("/expired")
+async def delete_expired_shares(
+    current_user: User = Depends(get_current_active_user),
+):
+    """
+    删除当前用户的所有已过期分享。
+    """
+    user_account = await UserAccount.get(id=current_user.id)
+    deleted_count = await share_service.delete_expired_shares(user=user_account)
+    return success({"deleted_count": deleted_count})
+
+
 @router.delete("/{share_id}")
 async def delete_share(
     share_id: int,

api/routes/tasks.py

@@ -2,10 +2,17 @@ from fastapi import APIRouter, Depends, HTTPException
 from typing import Annotated
 
 from models.database import AutomationTask
-from schemas.tasks import AutomationTaskCreate, AutomationTaskUpdate
+from schemas.tasks import (
+    AutomationTaskCreate,
+    AutomationTaskUpdate,
+    TaskQueueSettings,
+    TaskQueueSettingsResponse,
+)
 from api.response import success
 from services.auth import get_current_active_user, User
 from services.logging import LogService
+from services.task_queue import task_queue_service
+from services.config import ConfigCenter
 
 router = APIRouter(
     prefix="/api/tasks",
@@ -15,6 +22,56 @@ router = APIRouter(
 )
 
 
+@router.get("/queue")
+async def get_task_queue_status(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    tasks = task_queue_service.get_all_tasks()
+    return success([task.dict() for task in tasks])
+
+
+@router.get("/queue/settings")
+async def get_task_queue_settings(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    payload = TaskQueueSettingsResponse(
+        concurrency=task_queue_service.get_concurrency(),
+        active_workers=task_queue_service.get_active_worker_count(),
+    )
+    return success(payload.model_dump())
+
+
+@router.post("/queue/settings")
+async def update_task_queue_settings(
+    settings: TaskQueueSettings,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    await task_queue_service.set_concurrency(settings.concurrency)
+    await ConfigCenter.set("TASK_QUEUE_CONCURRENCY", str(task_queue_service.get_concurrency()))
+    await LogService.action(
+        "route:tasks",
+        "Updated task queue settings",
+        details={"concurrency": settings.concurrency},
+        user_id=getattr(current_user, "id", None),
+    )
+    payload = TaskQueueSettingsResponse(
+        concurrency=task_queue_service.get_concurrency(),
+        active_workers=task_queue_service.get_active_worker_count(),
+    )
+    return success(payload.model_dump())
+
+
+@router.get("/queue/{task_id}")
+async def get_task_status(
+    task_id: str,
+    current_user: Annotated[User, Depends(get_current_active_user)],
+):
+    task = task_queue_service.get_task(task_id)
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return success(task.dict())
+
+
 @router.post("/")
 async def create_task(
     task_in: AutomationTaskCreate,

api/routes/vector_db.py

@@ -0,0 +1,91 @@
+from typing import Any, Dict
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+
+from services.auth import get_current_active_user
+from models.database import UserAccount
+from services.vector_db import (
+    VectorDBService,
+    VectorDBConfigManager,
+    list_providers,
+    get_provider_entry,
+)
+from services.vector_db.providers import get_provider_class
+from api.response import success
+
+router = APIRouter(prefix="/api/vector-db", tags=["vector-db"])
+
+
+class VectorDBConfigPayload(BaseModel):
+    type: str = Field(..., description="向量数据库提供者类型")
+    config: Dict[str, Any] = Field(default_factory=dict, description="提供者配置参数")
+
+
+@router.post("/clear-all", summary="清空向量数据库")
+async def clear_vector_db(user: UserAccount = Depends(get_current_active_user)):
+    try:
+        service = VectorDBService()
+        await service.clear_all_data()
+        return success(msg="向量数据库已清空")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/stats", summary="获取向量数据库统计")
+async def get_vector_db_stats(user: UserAccount = Depends(get_current_active_user)):
+    try:
+        service = VectorDBService()
+        data = await service.get_all_stats()
+        return success(data=data)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/providers", summary="列出可用向量数据库提供者")
+async def list_vector_providers(user: UserAccount = Depends(get_current_active_user)):
+    return success(list_providers())
+
+
+@router.get("/config", summary="获取当前向量数据库配置")
+async def get_vector_db_config(user: UserAccount = Depends(get_current_active_user)):
+    service = VectorDBService()
+    data = await service.current_provider()
+    return success(data)
+
+
+@router.post("/config", summary="更新向量数据库配置")
+async def update_vector_db_config(payload: VectorDBConfigPayload, user: UserAccount = Depends(get_current_active_user)):
+    entry = get_provider_entry(payload.type)
+    if not entry:
+        raise HTTPException(
+            status_code=400, detail=f"未知的向量数据库类型: {payload.type}")
+    if not entry.get("enabled", True):
+        raise HTTPException(status_code=400, detail="该向量数据库类型暂不可用")
+
+    provider_cls = get_provider_class(payload.type)
+    if not provider_cls:
+        raise HTTPException(
+            status_code=400, detail=f"未找到类型 {payload.type} 对应的实现")
+
+    # 先尝试建立连接，确保配置有效
+    test_provider = provider_cls(payload.config)
+    try:
+        await test_provider.initialize()
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    finally:
+        client = getattr(test_provider, "client", None)
+        close_fn = getattr(client, "close", None)
+        if callable(close_fn):
+            try:
+                close_fn()
+            except Exception:
+                pass
+
+    await VectorDBConfigManager.save_config(payload.type, payload.config)
+    service = VectorDBService()
+    await service.reload()
+    config_data = await service.current_provider()
+    stats = await service.get_all_stats()
+    return success({"config": config_data, "stats": stats})

api/routes/virtual_fs.py

@@ -15,10 +15,12 @@ from services.virtual_fs import (
     stream_file,
     generate_temp_link_token,
     verify_temp_link_token,
+    maybe_redirect_download,
 )
-from services.thumbnail import is_image_filename, get_or_create_thumb, is_raw_filename
+from services.thumbnail import is_image_filename, get_or_create_thumb, is_raw_filename, is_video_filename
 from schemas import MkdirRequest, MoveRequest
 from api.response import success
+from services.config import ConfigCenter
 
 router = APIRouter(prefix='/api/fs', tags=["virtual-fs"])
 
@@ -49,6 +51,12 @@ async def get_file(
         except Exception as e:
             raise HTTPException(500, detail=f"RAW file processing failed: {e}")
 
+    adapter_instance, adapter_model, root, rel = await resolve_adapter_and_rel(full_path)
+
+    redirect_response = await maybe_redirect_download(adapter_instance, adapter_model, root, rel)
+    if redirect_response is not None:
+        return redirect_response
+
     try:
         content = await read_file(full_path)
     except FileNotFoundError:
@@ -113,10 +121,10 @@ async def get_thumb(
     adapter, mount, root, rel = await resolve_adapter_and_rel(full_path)
     if not rel or rel.endswith('/'):
         raise HTTPException(400, detail="Not a file")
-    if not is_image_filename(rel):
-        raise HTTPException(404, detail="Not an image")
+    if not (is_image_filename(rel) or is_video_filename(rel)):
+        raise HTTPException(404, detail="Not an image or video")
     # type: ignore
-    data, mime, key = await get_or_create_thumb(adapter, mount.adapter_id, root, rel, w, h, fit)
+    data, mime, key = await get_or_create_thumb(adapter, mount.id, root, rel, w, h, fit)
     headers = {
         'Cache-Control': 'public, max-age=3600',
         'ETag': key,
@@ -151,7 +159,13 @@ async def get_temp_link(
     """获取文件的临时公开访问令牌"""
     full_path = '/' + full_path if not full_path.startswith('/') else full_path
     token = await generate_temp_link_token(full_path, expires_in=expires_in)
-    return success({"token": token, "path": full_path})
+    file_domain = await ConfigCenter.get("FILE_DOMAIN")
+    if file_domain:
+        file_domain = file_domain.rstrip('/')
+        url = f"{file_domain}/api/fs/public/{token}"
+    else:
+        url = f"/api/fs/public/{token}"
+    return success({"token": token, "path": full_path, "url": url})
 
 
 @router.get("/public/{token}")
@@ -212,31 +226,41 @@ async def api_mkdir(
 @router.post("/move")
 async def api_move(
     current_user: Annotated[User, Depends(get_current_active_user)],
-    body: MoveRequest
+    body: MoveRequest,
+    overwrite: bool = Query(False, description="是否允许覆盖已存在目标"),
 ):
     src = body.src if body.src.startswith('/') else '/' + body.src
     dst = body.dst if body.dst.startswith('/') else '/' + body.dst
-    await move_path(src, dst)
-    return success({"moved": True, "src": src, "dst": dst})
+    debug_info = await move_path(src, dst, overwrite=overwrite, return_debug=True, allow_cross=True)
+    queued = bool(debug_info.get("queued"))
+    response = {
+        "moved": not queued,
+        "queued": queued,
+        "src": src,
+        "dst": dst,
+        "overwrite": overwrite,
+    }
+    if queued:
+        response["task_id"] = debug_info.get("task_id")
+        response["task_name"] = debug_info.get("task_name")
+    return success(response)
 
 
 @router.post("/rename")
 async def api_rename(
     current_user: Annotated[User, Depends(get_current_active_user)],
     body: MoveRequest,
-    overwrite: bool = Query(False, description="是否允许覆盖已存在目标"),
-    debug: bool = Query(False, description="返回调试信息")
+    overwrite: bool = Query(False, description="是否允许覆盖已存在目标")
 ):
     src = body.src if body.src.startswith('/') else '/' + body.src
     dst = body.dst if body.dst.startswith('/') else '/' + body.dst
     from services.virtual_fs import rename_path
-    debug_info = await rename_path(src, dst, overwrite=overwrite, return_debug=debug)
+    await rename_path(src, dst, overwrite=overwrite, return_debug=False)
     return success({
         "renamed": True,
         "src": src,
         "dst": dst,
         "overwrite": overwrite,
-        **({"debug": debug_info} if debug else {})
     })
 
 
@@ -245,19 +269,23 @@ async def api_copy(
     current_user: Annotated[User, Depends(get_current_active_user)],
     body: MoveRequest,
     overwrite: bool = Query(False, description="是否覆盖已存在目标"),
-    debug: bool = Query(False, description="返回调试信息")
 ):
     from services.virtual_fs import copy_path
     src = body.src if body.src.startswith('/') else '/' + body.src
     dst = body.dst if body.dst.startswith('/') else '/' + body.dst
-    debug_info = await copy_path(src, dst, overwrite=overwrite, return_debug=debug)
-    return success({
-        "copied": True,
+    debug_info = await copy_path(src, dst, overwrite=overwrite, return_debug=True, allow_cross=True)
+    queued = bool(debug_info.get("queued"))
+    response = {
+        "copied": not queued,
+        "queued": queued,
         "src": src,
         "dst": dst,
         "overwrite": overwrite,
-        **({"debug": debug_info} if debug else {})
-    })
+    }
+    if queued:
+        response["task_id"] = debug_info.get("task_id")
+        response["task_name"] = debug_info.get("task_name")
+    return success(response)
 
 
 @router.post("/upload/{full_path:path}")
@@ -299,10 +327,12 @@ async def browse_fs(
     current_user: Annotated[User, Depends(get_current_active_user)],
     full_path: str,
     page_num: int = Query(1, alias="page", ge=1, description="页码"),
-    page_size: int = Query(50, ge=1, le=500, description="每页条数")
+    page_size: int = Query(50, ge=1, le=500, description="每页条数"),
+    sort_by: str = Query("name", description="按字段排序: name, size, mtime"),
+    sort_order: str = Query("asc", description="排序顺序: asc, desc")
 ):
     full_path = '/' + full_path if not full_path.startswith('/') else full_path
-    result = await list_virtual_dir(full_path, page_num, page_size)
+    result = await list_virtual_dir(full_path, page_num, page_size, sort_by, sort_order)
     return success({
         "path": full_path,
         "entries": result["items"],
@@ -329,6 +359,18 @@ async def api_delete(
 async def root_listing(
     current_user: Annotated[User, Depends(get_current_active_user)],
     page_num: int = Query(1, alias="page", ge=1, description="页码"),
-    page_size: int = Query(50, ge=1, le=500, description="每页条数")
+    page_size: int = Query(50, ge=1, le=500, description="每页条数"),
+    sort_by: str = Query("name", description="按字段排序: name, size, mtime"),
+    sort_order: str = Query("asc", description="排序顺序: asc, desc")
 ):
-    return await browse_fs("", page_num, page_size)
+    result = await list_virtual_dir("/", page_num, page_size, sort_by, sort_order)
+    return success({
+        "path": "/",
+        "entries": result["items"],
+        "pagination": {
+            "total": result["total"],
+            "page": result["page"],
+            "page_size": result["page_size"],
+            "pages": result["pages"]
+        }
+    })

api/routes/webdav.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+import base64
+import hashlib
+import mimetypes
+from email.utils import formatdate
+from urllib.parse import urlparse, unquote
+from typing import Optional
+
+from fastapi import APIRouter, Request, Response, HTTPException, Depends
+import xml.etree.ElementTree as ET
+
+from services.auth import authenticate_user_db, User, UserInDB
+from services.virtual_fs import (
+    list_virtual_dir,
+    stat_file,
+    write_file_stream,
+    make_dir,
+    delete_path,
+    move_path,
+    copy_path,
+    stream_file,
+)
+from services.config import ConfigCenter
+
+
+_WEBDAV_ENABLED_KEY = "WEBDAV_MAPPING_ENABLED"
+
+
+async def _ensure_webdav_enabled() -> None:
+    enabled = await ConfigCenter.get(_WEBDAV_ENABLED_KEY, "1")
+    if str(enabled).strip().lower() in ("0", "false", "off", "no"):
+        raise HTTPException(503, detail="WebDAV mapping disabled")
+
+
+router = APIRouter(prefix="/webdav", tags=["webdav"])
+
+
+def _dav_headers(extra: Optional[dict] = None) -> dict:
+    headers = {
+        "DAV": "1",
+        "MS-Author-Via": "DAV",
+        "Accept-Ranges": "bytes",
+        "Allow": ", ".join([
+            "OPTIONS",
+            "PROPFIND",
+            "GET",
+            "HEAD",
+            "PUT",
+            "DELETE",
+            "MKCOL",
+            "MOVE",
+            "COPY",
+        ]),
+    }
+    if extra:
+        headers.update(extra)
+    return headers
+
+
+async def _get_basic_user(request: Request) -> User:
+    auth = request.headers.get("Authorization", "")
+    if not auth:
+        raise HTTPException(401, detail="Unauthorized", headers={"WWW-Authenticate": "Basic realm=webdav"})
+
+    scheme, _, param = auth.partition(" ")
+    scheme_lower = scheme.lower()
+    if scheme_lower == "basic":
+        try:
+            decoded = base64.b64decode(param).decode("utf-8")
+            username, _, password = decoded.partition(":")
+        except Exception:
+            raise HTTPException(401, detail="Invalid Basic auth", headers={"WWW-Authenticate": "Basic realm=webdav"})
+        user_or_false: Optional[UserInDB] = await authenticate_user_db(username, password)
+        if not user_or_false:
+            raise HTTPException(401, detail="Invalid credentials", headers={"WWW-Authenticate": "Basic realm=webdav"})
+        u: UserInDB = user_or_false
+        return User(id=u.id, username=u.username, email=u.email, full_name=u.full_name, disabled=u.disabled)
+    elif scheme_lower == "bearer":
+        if not param:
+            raise HTTPException(401, detail="Invalid Bearer token")
+        return User(id=0, username="bearer", email=None, full_name=None, disabled=False)
+    else:
+        raise HTTPException(401, detail="Unsupported auth", headers={"WWW-Authenticate": "Basic realm=webdav"})
+
+
+def _httpdate(ts: int | float) -> str:
+    return formatdate(ts, usegmt=True)
+
+
+def _etag(path: str, size: int | None, mtime: int | None) -> str:
+    raw = f"{path}|{size or 0}|{mtime or 0}".encode("utf-8")
+    return '"' + hashlib.md5(raw).hexdigest() + '"'
+
+
+def _href_for(path: str, is_dir: bool) -> str:
+    from urllib.parse import quote
+    p = "/webdav" + (path if path.startswith("/") else "/" + path)
+    if is_dir and not p.endswith("/"):
+        p += "/"
+    return quote(p)
+
+
+def _build_prop_response(path: str, name: str, is_dir: bool, size: Optional[int], mtime: Optional[int], content_type: Optional[str]):
+    ns = "{DAV:}"
+    resp = ET.Element(ns + "response")
+    href = ET.SubElement(resp, ns + "href")
+    href.text = _href_for(path, is_dir)
+
+    propstat = ET.SubElement(resp, ns + "propstat")
+    prop = ET.SubElement(propstat, ns + "prop")
+
+    displayname = ET.SubElement(prop, ns + "displayname")
+    displayname.text = name
+
+    resourcetype = ET.SubElement(prop, ns + "resourcetype")
+    if is_dir:
+        ET.SubElement(resourcetype, ns + "collection")
+
+    if not is_dir:
+        if size is not None:
+            gcl = ET.SubElement(prop, ns + "getcontentlength")
+            gcl.text = str(size)
+        if content_type:
+            gct = ET.SubElement(prop, ns + "getcontenttype")
+            gct.text = content_type
+
+    if mtime is not None:
+        glm = ET.SubElement(prop, ns + "getlastmodified")
+        glm.text = _httpdate(mtime)
+
+    etag = ET.SubElement(prop, ns + "getetag")
+    etag.text = _etag(path, size, mtime)
+
+    status = ET.SubElement(propstat, ns + "status")
+    status.text = "HTTP/1.1 200 OK"
+    return resp
+
+
+def _multistatus_xml(responses: list[ET.Element]) -> bytes:
+    ns = "{DAV:}"
+    ms = ET.Element(ns + "multistatus")
+    for r in responses:
+        ms.append(r)
+    return ET.tostring(ms, encoding="utf-8", xml_declaration=True)
+
+
+def _normalize_fs_path(path: str) -> str:
+    full = "/" + path if not path.startswith("/") else path
+    return unquote(full)
+
+
+@router.options("/{path:path}")
+async def options_root(path: str = "", _enabled: None = Depends(_ensure_webdav_enabled)):
+    return Response(status_code=200, headers=_dav_headers())
+
+
+@router.api_route("/{path:path}", methods=["PROPFIND"])
+async def propfind(
+    request: Request,
+    path: str,
+    _enabled: None = Depends(_ensure_webdav_enabled),
+    user: User = Depends(_get_basic_user),
+):
+    full_path = _normalize_fs_path(path)
+    depth = request.headers.get("Depth", "1").lower()
+    if depth not in ("0", "1", "infinity"):
+        depth = "1"
+
+    responses: list[ET.Element] = []
+
+    # 先获取当前路径信息
+    try:
+        st = await stat_file(full_path)
+        is_dir = bool(st.get("is_dir"))
+        name = st.get("name") or full_path.rsplit("/", 1)[-1] or "/"
+        size = None if is_dir else int(st.get("size", 0))
+        mtime = int(st.get("mtime", 0)) if st.get("mtime") is not None else None
+        ctype = None if is_dir else (mimetypes.guess_type(name)[0] or "application/octet-stream")
+        responses.append(_build_prop_response(full_path, name, is_dir, size, mtime, ctype))
+    except FileNotFoundError:
+        raise HTTPException(404, detail="Not found")
+
+    if depth in ("1", "infinity"):
+        try:
+            listing = await list_virtual_dir(full_path, page_num=1, page_size=1000)
+            for ent in listing["items"]:
+                is_dir = bool(ent.get("is_dir"))
+                name = ent.get("name")
+                child_path = full_path.rstrip("/") + "/" + name
+                size = None if is_dir else int(ent.get("size", 0))
+                mtime = int(ent.get("mtime", 0)) if ent.get("mtime") is not None else None
+                ctype = None if is_dir else (mimetypes.guess_type(name)[0] or "application/octet-stream")
+                responses.append(_build_prop_response(child_path, name, is_dir, size, mtime, ctype))
+        except HTTPException as e:
+            if e.status_code == 400:
+                pass
+            else:
+                raise
+
+    xml = _multistatus_xml(responses)
+    return Response(content=xml, status_code=207, media_type='application/xml; charset="utf-8"', headers=_dav_headers())
+
+
+@router.get("/{path:path}")
+async def dav_get(
+    path: str,
+    request: Request,
+    _enabled: None = Depends(_ensure_webdav_enabled),
+    user: User = Depends(_get_basic_user),
+):
+    full_path = _normalize_fs_path(path)
+    range_header = request.headers.get("Range")
+    return await stream_file(full_path, range_header)
+
+
+@router.head("/{path:path}")
+async def dav_head(
+    path: str,
+    _enabled: None = Depends(_ensure_webdav_enabled),
+    user: User = Depends(_get_basic_user),
+):
+    full_path = _normalize_fs_path(path)
+    try:
+        st = await stat_file(full_path)
+    except FileNotFoundError:
+        raise HTTPException(404, detail="Not found")
+    is_dir = bool(st.get("is_dir"))
+    headers = _dav_headers()
+    if not is_dir:
+        size = int(st.get("size", 0))
+        name = st.get("name") or full_path.rsplit("/", 1)[-1]
+        ctype = mimetypes.guess_type(name)[0] or "application/octet-stream"
+        mtime = int(st.get("mtime", 0)) if st.get("mtime") is not None else None
+        headers.update({
+            "Content-Length": str(size),
+            "Content-Type": ctype,
+            "ETag": _etag(full_path, size, mtime),
+        })
+    return Response(status_code=200, headers=headers)
+
+
+@router.api_route("/{path:path}", methods=["PUT"])
+async def dav_put(
+    path: str,
+    request: Request,
+    _enabled: None = Depends(_ensure_webdav_enabled),
+    user: User = Depends(_get_basic_user),
+):
+    full_path = _normalize_fs_path(path)
+    async def body_iter():
+        async for chunk in request.stream():
+            if chunk:
+                yield chunk
+    size = await write_file_stream(full_path, body_iter(), overwrite=True)
+    return Response(status_code=201, headers=_dav_headers({"Content-Length": "0"}))
+
+
+@router.api_route("/{path:path}", methods=["DELETE"])
+async def dav_delete(
+    path: str,
+    _enabled: None = Depends(_ensure_webdav_enabled),
+    user: User = Depends(_get_basic_user),
+):
+    full_path = _normalize_fs_path(path)
+    await delete_path(full_path)
+    return Response(status_code=204, headers=_dav_headers())
+
+
+@router.api_route("/{path:path}", methods=["MKCOL"])
+async def dav_mkcol(
+    path: str,
+    _enabled: None = Depends(_ensure_webdav_enabled),
+    user: User = Depends(_get_basic_user),
+):
+    full_path = _normalize_fs_path(path)
+    await make_dir(full_path)
+    return Response(status_code=201, headers=_dav_headers())
+
+
+def _parse_destination(dest: str) -> str:
+    if not dest:
+        raise HTTPException(400, detail="Missing Destination header")
+    p = urlparse(dest)
+    path = p.path if p.scheme else dest 
+    if path.startswith("/webdav"):
+        rel = path[len("/webdav"):]
+    else:
+        rel = path
+    return _normalize_fs_path(rel)
+
+
+@router.api_route("/{path:path}", methods=["MOVE"])
+async def dav_move(path: str, request: Request, user: User = Depends(_get_basic_user)):
+    full_src = _normalize_fs_path(path)
+    dest_header = request.headers.get("Destination")
+    dst = _parse_destination(dest_header or "")
+    overwrite = request.headers.get("Overwrite", "T").upper() != "F" 
+    await move_path(full_src, dst, overwrite=overwrite)
+    return Response(status_code=204, headers=_dav_headers())
+
+
+@router.api_route("/{path:path}", methods=["COPY"])
+async def dav_copy(path: str, request: Request, user: User = Depends(_get_basic_user)):
+    full_src = _normalize_fs_path(path)
+    dest_header = request.headers.get("Destination")
+    dst = _parse_destination(dest_header or "")
+    overwrite = request.headers.get("Overwrite", "T").upper() != "F"  
+    await copy_path(full_src, dst, overwrite=overwrite)
+    return Response(status_code=201 if not overwrite else 204, headers=_dav_headers())

compose.yaml

@@ -1,7 +1,7 @@
 services:
   foxel:
     image: ghcr.io/drizzletime/foxel:latest
-    #image: ghcr.nju.edu.cn/drizzletime/foxel:latest #国内用户可以用此镜像命令
+    #image: ghcr.nju.edu.cn/drizzletime/foxel:latest  # 国内用户可以用此镜像命令
     container_name: foxel
     restart: unless-stopped
     ports:

entrypoint.sh

@@ -1,4 +1,5 @@
 #!/bin/bash
 set -e
+python migrate/run.py
 nginx -g 'daemon off;' &
-exec gunicorn -k uvicorn.workers.UvicornWorker -w 4 -b 0.0.0.0:8000 main:app
+exec gunicorn -k uvicorn.workers.UvicornWorker -w 1 -b 0.0.0.0:8000 main:app

main.py

@@ -1,31 +1,37 @@
+import os
+from services.config import VERSION, ConfigCenter
+from services.adapters.registry import runtime_registry
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from db.session import close_db, init_db
+from api.routers import include_routers
+from fastapi import FastAPI
+from services.middleware.logging_middleware import LoggingMiddleware
+from services.middleware.exception_handler import global_exception_handler
 from dotenv import load_dotenv
+from services.task_queue import task_queue_service
 
 load_dotenv()
 
-from services.middleware.exception_handler import global_exception_handler
-from services.middleware.logging_middleware import LoggingMiddleware
-from fastapi import FastAPI, Request
-from api.routers import include_routers
-from db.session import close_db, init_db
-from contextlib import asynccontextmanager
-from fastapi.middleware.cors import CORSMiddleware
-from services.adapters.registry import runtime_registry
-
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    os.makedirs("data/db", exist_ok=True)
     await init_db()
     await runtime_registry.refresh()
+    await ConfigCenter.set("APP_VERSION", VERSION)
+    await task_queue_service.start_worker()
     try:
         yield
     finally:
+        await task_queue_service.stop_worker()
         await close_db()
 
 
 def create_app() -> FastAPI:
     app = FastAPI(
         title="Foxel",
-        description="AList-like virtual storage aggregator",
+        description="A highly extensible private cloud storage solution for individuals and teams",
         lifespan=lifespan,
     )
     include_routers(app)

models/__init__.py

@@ -1,3 +1,3 @@
-from .database import StorageAdapter, Mount
+from .database import StorageAdapter
 
-__all__ = ["StorageAdapter", "Mount"]
+__all__ = ["StorageAdapter"]

models/database.py

@@ -8,25 +8,13 @@ class StorageAdapter(Model):
     type = fields.CharField(max_length=30)
     config = fields.JSONField()
     enabled = fields.BooleanField(default=True)
-    mounts: fields.ReverseRelation["Mount"]
+    path = fields.CharField(max_length=255, unique=True)
+    sub_path = fields.CharField(max_length=1024, null=True)
 
     class Meta:
         table = "storage_adapters"
 
 
-class Mount(Model):
-    id = fields.IntField(pk=True)
-    path = fields.CharField(max_length=255, unique=True)
-    sub_path = fields.CharField(max_length=1024, null=True)
-    adapter: fields.ForeignKeyRelation[StorageAdapter] = fields.ForeignKeyField(
-        "models.StorageAdapter", related_name="mounts", on_delete=fields.CASCADE
-    )
-    enabled = fields.BooleanField(default=True)
-
-    class Meta:
-        table = "mounts"
-
-
 class UserAccount(Model):
     id = fields.IntField(pk=True)
     username = fields.CharField(max_length=50, unique=True)
@@ -48,6 +36,81 @@ class Configuration(Model):
         table = "configurations"
 
 
+class AIProvider(Model):
+    id = fields.IntField(pk=True)
+    name = fields.CharField(max_length=100)
+    identifier = fields.CharField(max_length=100, unique=True)
+    provider_type = fields.CharField(max_length=50, null=True)
+    api_format = fields.CharField(max_length=20)
+    base_url = fields.CharField(max_length=512, null=True)
+    api_key = fields.CharField(max_length=512, null=True)
+    logo_url = fields.CharField(max_length=512, null=True)
+    extra_config = fields.JSONField(null=True)
+    created_at = fields.DatetimeField(auto_now_add=True)
+    updated_at = fields.DatetimeField(auto_now=True)
+
+    class Meta:
+        table = "ai_providers"
+
+
+class AIModel(Model):
+    id = fields.IntField(pk=True)
+    provider: fields.ForeignKeyRelation[AIProvider] = fields.ForeignKeyField(
+        "models.AIProvider", related_name="models", on_delete=fields.CASCADE
+    )
+    name = fields.CharField(max_length=255)
+    display_name = fields.CharField(max_length=255, null=True)
+    description = fields.TextField(null=True)
+    capabilities = fields.JSONField(null=True)
+    context_window = fields.IntField(null=True)
+    metadata = fields.JSONField(null=True)
+    created_at = fields.DatetimeField(auto_now_add=True)
+    updated_at = fields.DatetimeField(auto_now=True)
+
+    class Meta:
+        table = "ai_models"
+        unique_together = ("provider", "name")
+
+    @property
+    def embedding_dimensions(self) -> int | None:
+        metadata = self.metadata or {}
+        if not isinstance(metadata, dict):
+            return None
+        value = metadata.get("embedding_dimensions")
+        if value is None:
+            return None
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return None
+
+    @embedding_dimensions.setter
+    def embedding_dimensions(self, value: int | None) -> None:
+        base_metadata = self.metadata if isinstance(self.metadata, dict) else {}
+        metadata = dict(base_metadata or {})
+        if value is None:
+            metadata.pop("embedding_dimensions", None)
+        else:
+            try:
+                metadata["embedding_dimensions"] = int(value)
+            except (TypeError, ValueError):
+                metadata.pop("embedding_dimensions", None)
+        self.metadata = metadata or None
+
+
+class AIDefaultModel(Model):
+    id = fields.IntField(pk=True)
+    ability = fields.CharField(max_length=50, unique=True)
+    model: fields.ForeignKeyRelation[AIModel] = fields.ForeignKeyField(
+        "models.AIModel", related_name="default_for", on_delete=fields.CASCADE
+    )
+    created_at = fields.DatetimeField(auto_now_add=True)
+    updated_at = fields.DatetimeField(auto_now=True)
+
+    class Meta:
+        table = "ai_default_models"
+
+
 class AutomationTask(Model):
     id = fields.IntField(pk=True)
     name = fields.CharField(max_length=100)
@@ -93,3 +156,29 @@ class ShareLink(Model):
 
     class Meta:
         table = "share_links"
+
+
+class Plugin(Model):
+    id = fields.IntField(pk=True)
+    url = fields.CharField(max_length=2048)
+    enabled = fields.BooleanField(default=True)
+
+    key = fields.CharField(max_length=100, null=True)
+    name = fields.CharField(max_length=255, null=True)
+    version = fields.CharField(max_length=50, null=True)
+    supported_exts = fields.JSONField(null=True)
+
+    default_bounds = fields.JSONField(null=True)
+    default_maximized = fields.BooleanField(null=True)
+
+    icon = fields.CharField(max_length=2048, null=True)
+    description = fields.TextField(null=True)
+    author = fields.CharField(max_length=255, null=True)
+    website = fields.CharField(max_length=2048, null=True)
+    github = fields.CharField(max_length=2048, null=True)
+
+    created_at = fields.DatetimeField(auto_now_add=True)
+    updated_at = fields.DatetimeField(auto_now=True)
+
+    class Meta:
+        table = "plugins"

nginx.conf

@@ -28,7 +28,7 @@ http {
         listen 80;
         server_name _;
 
-        location ~ ^/(api|docs) {
+        location ~ ^/(api|webdav|s3|docs|openapi\.json$) {
             proxy_pass http://127.0.0.1:8000;
             proxy_set_header Host $host;
             proxy_set_header X-Real-IP $remote_addr;

pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "foxel"
+version = "1"
+description = "foxel.cc"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "aioboto3>=15.2.0",
+    "aiofiles>=25.1.0",
+    "fastapi>=0.116.1",
+    "passlib[bcrypt]>=1.7.4",
+    "bcrypt>=3.2.2,<4.0",
+    "pillow>=11.3.0",
+    "pyjwt>=2.10.1",
+    "pysocks>=1.7.1",
+    "python-dotenv>=1.1.1",
+    "python-multipart>=0.0.20",
+    "qdrant-client>=1.15.1",
+    "rawpy>=0.25.1",
+    "telethon>=1.41.2",
+    "tortoise-orm>=0.25.1",
+    "uvicorn>=0.37.0",
+    "pymilvus[milvus-lite]>=2.6.2",
+    "paramiko>=4.0.0",
+    "pydantic[email]>=2.11.7",
+]

requirements.txt

@@ -1,67 +0,0 @@
-aiosqlite==0.21.0
-annotated-types==0.7.0
-anyio==4.10.0
-bcrypt==4.3.0
-certifi==2025.8.3
-click==8.2.1
-dnspython==2.7.0
-email_validator==2.2.0
-fastapi==0.116.1
-fastapi-cli==0.0.8
-fastapi-cloud-cli==0.1.5
-grpcio==1.74.0
-h11==0.16.0
-httpcore==1.0.9
-httptools==0.6.4
-httpx==0.28.1
-idna==3.10
-imageio==2.37.0
-iso8601==2.1.0
-Jinja2==3.1.6
-markdown-it-py==4.0.0
-MarkupSafe==3.0.2
-mdurl==0.1.2
-milvus-lite==2.5.1
-numpy==2.3.2
-pandas==2.3.1
-passlib==1.7.4
-pillow==11.3.0
-protobuf==6.32.0
-pyaes==1.6.1
-pyasn1==0.6.1
-pydantic==2.11.7
-pydantic_core==2.33.2
-Pygments==2.19.2
-PyJWT==2.10.1
-pymilvus==2.6.0
-pypika-tortoise==0.6.1
-PySocks==1.7.1
-python-dateutil==2.9.0.post0
-python-dotenv==1.1.1
-python-multipart==0.0.20
-pytz==2025.2
-PyYAML==6.0.2
-rawpy==0.25.1
-rich==14.1.0
-rich-toolkit==0.15.0
-rignore==0.6.4
-rsa==4.9.1
-sentry-sdk==2.35.0
-setuptools==80.9.0
-shellingham==1.5.4
-six==1.17.0
-sniffio==1.3.1
-starlette==0.47.2
-Telethon==1.40.0
-tortoise-orm==0.25.1
-tqdm==4.67.1
-typer==0.16.0
-typing-inspection==0.4.1
-typing_extensions==4.14.1
-tzdata==2025.2
-ujson==5.10.0
-urllib3==2.5.0
-uvicorn==0.35.0
-uvloop==0.21.0
-watchfiles==1.1.0
-websockets==15.0.1

schemas/__init__.py

@@ -1,12 +1,12 @@
+from schemas.plugins import PluginCreate,PluginOut
 from .adapters import AdapterCreate, AdapterOut
-from .mounts import MountCreate, MountOut
 from .fs import MkdirRequest, MoveRequest
 
 __all__ = [
+    "PluginOut"
+    "PluginCreate"
     "AdapterCreate",
     "AdapterOut",
-    "MountCreate",
-    "MountOut",
     "MkdirRequest",
     "MoveRequest",
 ]

schemas/adapters.py

@@ -1,15 +1,17 @@
 from typing import Dict, Optional
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 
 
-class AdapterCreate(BaseModel):
+class AdapterBase(BaseModel):
     name: str
     type: str = Field(pattern=r"^[a-zA-Z0-9_]+$")
     config: Dict = Field(default_factory=dict)
     enabled: bool = True
-    mount_path: str  
-    sub_path: Optional[str] = None  
+    path: str = None
+    sub_path: Optional[str] = None
 
+
+class AdapterCreate(AdapterBase):
     @staticmethod
     def normalize_mount_path(p: str) -> str:
         p = p.strip()
@@ -18,15 +20,17 @@ class AdapterCreate(BaseModel):
         p = p.rstrip('/')
         return p or '/'
 
-    @validator("mount_path")
+    @field_validator("path")
     def _v_mount(cls, v: str):
         if not v:
             raise ValueError("mount_path required")
         return cls.normalize_mount_path(v)
 
 
-class AdapterOut(AdapterCreate):
+class AdapterOut(AdapterBase):
     id: int
+    path: str = None
+    sub_path: Optional[str] = None
 
     class Config:
         from_attributes = True

schemas/ai.py

@@ -0,0 +1,101 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+from services.ai_providers import ABILITIES, normalize_capabilities
+
+
+class AIProviderBase(BaseModel):
+    name: str
+    identifier: str = Field(..., pattern=r"^[a-z0-9_\-\.]+$")
+    provider_type: Optional[str] = None
+    api_format: str
+    base_url: Optional[str] = None
+    api_key: Optional[str] = None
+    logo_url: Optional[str] = None
+    extra_config: Optional[dict] = None
+
+    @field_validator("api_format")
+    def normalize_format(cls, value: str) -> str:
+        fmt = value.lower()
+        if fmt not in {"openai", "gemini"}:
+            raise ValueError("api_format must be 'openai' or 'gemini'")
+        return fmt
+
+
+class AIProviderCreate(AIProviderBase):
+    pass
+
+
+class AIProviderUpdate(BaseModel):
+    name: Optional[str] = None
+    provider_type: Optional[str] = None
+    api_format: Optional[str] = None
+    base_url: Optional[str] = None
+    api_key: Optional[str] = None
+    logo_url: Optional[str] = None
+    extra_config: Optional[dict] = None
+
+    @field_validator("api_format")
+    def normalize_format(cls, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return value
+        fmt = value.lower()
+        if fmt not in {"openai", "gemini"}:
+            raise ValueError("api_format must be 'openai' or 'gemini'")
+        return fmt
+
+
+class AIModelBase(BaseModel):
+    name: str
+    display_name: Optional[str] = None
+    description: Optional[str] = None
+    capabilities: Optional[List[str]] = None
+    context_window: Optional[int] = None
+    embedding_dimensions: Optional[int] = None
+    metadata: Optional[dict] = None
+
+    @field_validator("capabilities")
+    def validate_capabilities(cls, items: Optional[List[str]]) -> Optional[List[str]]:
+        if items is None:
+            return None
+        normalized = normalize_capabilities(items)
+        invalid = set(items) - set(normalized)
+        if invalid:
+            raise ValueError(f"Unsupported capabilities: {', '.join(invalid)}")
+        return normalized
+
+
+class AIModelCreate(AIModelBase):
+    pass
+
+
+class AIModelUpdate(BaseModel):
+    display_name: Optional[str] = None
+    description: Optional[str] = None
+    capabilities: Optional[List[str]] = None
+    context_window: Optional[int] = None
+    embedding_dimensions: Optional[int] = None
+    metadata: Optional[dict] = None
+
+    @field_validator("capabilities")
+    def validate_capabilities(cls, items: Optional[List[str]]) -> Optional[List[str]]:
+        if items is None:
+            return None
+        normalized = normalize_capabilities(items)
+        invalid = set(items) - set(normalized)
+        if invalid:
+            raise ValueError(f"Unsupported capabilities: {', '.join(invalid)}")
+        return normalized
+
+
+class AIDefaultsUpdate(BaseModel):
+    chat: Optional[int] = None
+    vision: Optional[int] = None
+    embedding: Optional[int] = None
+    rerank: Optional[int] = None
+    voice: Optional[int] = None
+    tools: Optional[int] = None
+
+    def as_mapping(self) -> dict:
+        return {ability: getattr(self, ability) for ability in ABILITIES}

schemas/email.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict
+
+from pydantic import BaseModel, EmailStr, Field
+
+
+class EmailTestRequest(BaseModel):
+    to: EmailStr
+    subject: str = Field(..., min_length=1)
+    template: str = Field(default="test", min_length=1)
+    context: Dict[str, Any] = Field(default_factory=dict)
+
+
+class EmailTemplateUpdate(BaseModel):
+    content: str
+
+
+class EmailTemplatePreviewPayload(BaseModel):
+    context: Dict[str, Any] = Field(default_factory=dict)

schemas/fs.py

@@ -8,7 +8,7 @@ class VfsEntry(BaseModel):
     size: int
     mtime: int
     type: Optional[str] = None
-    is_image: Optional[bool] = None
+    has_thumbnail: Optional[bool] = None
 
 
 class DirListing(BaseModel):
@@ -21,6 +21,13 @@ class SearchResultItem(BaseModel):
     id: int | str
     path: str
     score: float
+    chunk_id: Optional[str] = None
+    snippet: Optional[str] = None
+    mime: Optional[str] = None
+    source_type: Optional[str] = None
+    start_offset: Optional[int] = None
+    end_offset: Optional[int] = None
+    metadata: Optional[dict] = None
 
 
 class MkdirRequest(BaseModel):

schemas/mounts.py

@@ -1,23 +0,0 @@
-from typing import Optional
-from pydantic import BaseModel
-
-
-class MountCreate(BaseModel):
-    path: str
-    adapter_id: int
-    sub_path: Optional[str] = None
-    enabled: bool = True
-
-    @staticmethod
-    def normalize(path: str) -> str:
-        return (path if path.startswith('/') else '/' + path).rstrip('/') or '/'
-
-    def model_post_init(self, __context):  
-        self.path = self.normalize(self.path)
-
-
-class MountOut(MountCreate):
-    id: int
-
-    class Config:
-        from_attributes = True

schemas/offline_downloads.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel, HttpUrl, Field
+
+
+class OfflineDownloadCreate(BaseModel):
+    url: HttpUrl
+    dest_dir: str = Field(..., min_length=1)
+    filename: str = Field(..., min_length=1)

schemas/plugins.py

@@ -0,0 +1,27 @@
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class PluginCreate(BaseModel):
+    url: str = Field(min_length=1)
+    enabled: bool = True
+
+
+class PluginOut(BaseModel):
+    id: int
+    url: str
+    enabled: bool
+    key: Optional[str]
+    name: Optional[str]
+    version: Optional[str]
+    supported_exts: Optional[List[str]]
+    default_bounds: Optional[Dict[str, Any]]
+    default_maximized: Optional[bool]
+    icon: Optional[str]
+    description: Optional[str]
+    author: Optional[str]
+    website: Optional[str]
+    github: Optional[str]
+
+    class Config:
+        from_attributes = True

schemas/tasks.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import Optional, Dict, Any
 
 
@@ -29,3 +29,11 @@ class AutomationTaskRead(AutomationTaskBase):
 
     class Config:
         from_attributes = True
+
+
+class TaskQueueSettings(BaseModel):
+    concurrency: int = Field(..., ge=1, description="Desired number of concurrent task workers")
+
+
+class TaskQueueSettingsResponse(TaskQueueSettings):
+    active_workers: int = Field(..., ge=0, description="Currently running worker count")

services/adapters/base.py

@@ -10,7 +10,7 @@ from models import StorageAdapter
 @runtime_checkable
 class BaseAdapter(Protocol):
     record: StorageAdapter
-    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50) -> Tuple[List[Dict], int]: ...
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]: ...
     async def read_file(self, root: str, rel: str) -> bytes: ...
     async def write_file(self, root: str, rel: str, data: bytes): ...
     async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]): ... 

services/adapters/ftp.py

@@ -0,0 +1,628 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import List, Dict, Tuple, AsyncIterator, Optional
+
+from fastapi import HTTPException
+from fastapi.responses import StreamingResponse
+from ftplib import FTP, error_perm
+import mimetypes
+
+from models import StorageAdapter
+from services.logging import LogService
+
+
+def _join_remote(root: str, rel: str) -> str:
+    root = (root or "/").rstrip("/") or "/"
+    rel = (rel or "").lstrip("/")
+    if not rel:
+        return root
+    return f"{root}/{rel}"
+
+
+def _parse_mlst_line(line: str) -> Dict[str, str]:
+    out: Dict[str, str] = {}
+    try:
+        facts, _, name = line.partition(" ")
+        for part in facts.split(";"):
+            if not part or "=" not in part:
+                continue
+            k, v = part.split("=", 1)
+            out[k.strip().lower()] = v.strip()
+        if name:
+            out["name"] = name.strip()
+    except Exception:
+        pass
+    return out
+
+
+def _parse_modify_to_epoch(mod: str) -> int:
+    # Formats we may see: YYYYMMDDHHMMSS or YYYYMMDDHHMMSS(.sss)
+    try:
+        mod = mod.strip()
+        mod = mod.split(".")[0]
+        if len(mod) >= 14:
+            y = int(mod[0:4])
+            m = int(mod[4:6])
+            d = int(mod[6:8])
+            hh = int(mod[8:10])
+            mm = int(mod[10:12])
+            ss = int(mod[12:14])
+            import datetime as _dt
+            return int(_dt.datetime(y, m, d, hh, mm, ss, tzinfo=_dt.timezone.utc).timestamp())
+    except Exception:
+        return 0
+    return 0
+
+
+@dataclass
+class _Range:
+    start: int
+    end: Optional[int]  # inclusive
+
+
+class FTPAdapter:
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        cfg = record.config
+        self.host: str = cfg.get("host")
+        self.port: int = int(cfg.get("port", 21))
+        self.username: Optional[str] = cfg.get("username")
+        self.password: Optional[str] = cfg.get("password")
+        self.passive: bool = bool(cfg.get("passive", True))
+        self.timeout: int = int(cfg.get("timeout", 15))
+        self.root_path: str = cfg.get("root", "/") or "/"
+
+        if not self.host:
+            raise ValueError("FTP adapter requires 'host'")
+
+    def get_effective_root(self, sub_path: str | None) -> str:
+        base = self.root_path.rstrip("/") or "/"
+        if sub_path:
+            return _join_remote(base, sub_path)
+        return base
+
+    def _connect(self) -> FTP:
+        ftp = FTP()
+        ftp.connect(self.host, self.port, timeout=self.timeout)
+        if self.username:
+            ftp.login(self.username, self.password or "")
+        else:
+            ftp.login()
+        ftp.set_pasv(self.passive)
+        return ftp
+
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]:
+        path = _join_remote(root, rel.strip('/'))
+
+        def _do_list() -> List[Dict]:
+            ftp = self._connect()
+            try:
+                ftp.cwd(path)
+            except error_perm as e:
+                # path may be file
+                ftp.quit()
+                raise NotADirectoryError(rel) from e
+
+            entries: List[Dict] = []
+            # Try MLSD first
+            try:
+                for name, facts in ftp.mlsd():
+                    if name in (".", ".."):
+                        continue
+                    is_dir = (facts.get("type") == "dir")
+                    size = int(facts.get("size") or 0)
+                    mtime = _parse_modify_to_epoch(facts.get("modify") or "")
+                    entries.append({
+                        "name": name,
+                        "is_dir": is_dir,
+                        "size": 0 if is_dir else size,
+                        "mtime": mtime,
+                        "type": "dir" if is_dir else "file",
+                    })
+                ftp.quit()
+                return entries
+            except Exception:
+                # Fallback to NLST + probing
+                pass
+
+            names = []
+            try:
+                names = ftp.nlst()
+            except Exception:
+                ftp.quit()
+                return []
+
+            for name in names:
+                if name in (".", ".."):
+                    continue
+                is_dir = False
+                size = 0
+                mtime = 0
+                try:
+                    # If we can CWD, it's a directory
+                    ftp.cwd(_join_remote(path, name))
+                    ftp.cwd(path)
+                    is_dir = True
+                except Exception:
+                    is_dir = False
+                    try:
+                        size = ftp.size(_join_remote(path, name)) or 0
+                    except Exception:
+                        size = 0
+                try:
+                    mdtm = ftp.sendcmd("MDTM " + _join_remote(path, name))
+                    # Example: '213 20241012XXXXXX'
+                    if mdtm.startswith("213 "):
+                        mtime = _parse_modify_to_epoch(mdtm.split(" ", 1)[1])
+                except Exception:
+                    pass
+                entries.append({
+                    "name": name,
+                    "is_dir": is_dir,
+                    "size": 0 if is_dir else int(size or 0),
+                    "mtime": int(mtime or 0),
+                    "type": "dir" if is_dir else "file",
+                })
+            ftp.quit()
+            return entries
+
+        entries = await asyncio.to_thread(_do_list)
+
+        reverse = sort_order.lower() == "desc"
+
+        def get_sort_key(item):
+            key = (not item["is_dir"],)
+            f = sort_by.lower()
+            if f == "name":
+                key += (item["name"].lower(),)
+            elif f == "size":
+                key += (item.get("size", 0),)
+            elif f == "mtime":
+                key += (item.get("mtime", 0),)
+            else:
+                key += (item["name"].lower(),)
+            return key
+
+        entries.sort(key=get_sort_key, reverse=reverse)
+        total = len(entries)
+        start = (page_num - 1) * page_size
+        end = start + page_size
+        return entries[start:end], total
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        path = _join_remote(root, rel)
+
+        def _do_read() -> bytes:
+            ftp = self._connect()
+            try:
+                chunks: List[bytes] = []
+                ftp.retrbinary("RETR " + path, lambda b: chunks.append(b))
+                return b"".join(chunks)
+            except error_perm as e:
+                if str(e).startswith("550"):
+                    raise FileNotFoundError(rel)
+                raise
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        return await asyncio.to_thread(_do_read)
+
+    async def write_file(self, root: str, rel: str, data: bytes):
+        path = _join_remote(root, rel)
+
+        def _ensure_dirs(ftp: FTP, dir_path: str):
+            parts = [p for p in dir_path.strip("/").split("/") if p]
+            cur = "/"
+            for p in parts:
+                cur = _join_remote(cur, p)
+                try:
+                    ftp.mkd(cur)
+                except Exception:
+                    pass
+
+        def _do_write():
+            ftp = self._connect()
+            try:
+                parent = "/" if "/" not in path.strip("/") else path.rsplit("/", 1)[0]
+                _ensure_dirs(ftp, parent)
+                from io import BytesIO
+                bio = BytesIO(data)
+                ftp.storbinary("STOR " + path, bio)
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_write)
+        await LogService.info(
+            "adapter:ftp",
+            f"Wrote file to {rel}",
+            details={"adapter_id": self.record.id, "path": path, "size": len(data)},
+        )
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        # KISS: 聚合后一次性写入
+        buf = bytearray()
+        async for chunk in data_iter:
+            if chunk:
+                buf.extend(chunk)
+        await self.write_file(root, rel, bytes(buf))
+        return len(buf)
+
+    async def mkdir(self, root: str, rel: str):
+        path = _join_remote(root, rel)
+
+        def _do_mkdir():
+            ftp = self._connect()
+            try:
+                parts = [p for p in path.strip("/").split("/") if p]
+                cur = "/"
+                for p in parts:
+                    cur = _join_remote(cur, p)
+                    try:
+                        ftp.mkd(cur)
+                    except Exception:
+                        pass
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_mkdir)
+        await LogService.info("adapter:ftp", f"Created directory {rel}", details={"adapter_id": self.record.id, "path": path})
+
+    async def delete(self, root: str, rel: str):
+        path = _join_remote(root, rel)
+
+        def _do_delete():
+            ftp = self._connect()
+            try:
+                # Try file delete
+                try:
+                    ftp.delete(path)
+                    return
+                except Exception:
+                    pass
+
+                # Recursively delete dir
+                def _rm_tree(dir_path: str):
+                    try:
+                        ftp.cwd(dir_path)
+                    except Exception:
+                        return
+                    items = []
+                    try:
+                        for name, facts in ftp.mlsd():
+                            if name in (".", ".."):
+                                continue
+                            items.append((name, facts.get("type") == "dir"))
+                    except Exception:
+                        try:
+                            names = ftp.nlst()
+                        except Exception:
+                            names = []
+                        for n in names:
+                            if n in (".", ".."):
+                                continue
+                            # Best-effort dir check
+                            try:
+                                ftp.cwd(_join_remote(dir_path, n))
+                                ftp.cwd(dir_path)
+                                items.append((n, True))
+                            except Exception:
+                                items.append((n, False))
+                    for n, is_dir in items:
+                        child = _join_remote(dir_path, n)
+                        if is_dir:
+                            _rm_tree(child)
+                        else:
+                            try:
+                                ftp.delete(child)
+                            except Exception:
+                                pass
+                    try:
+                        ftp.rmd(dir_path)
+                    except Exception:
+                        pass
+
+                _rm_tree(path)
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_delete)
+        await LogService.info("adapter:ftp", f"Deleted {rel}", details={"adapter_id": self.record.id, "path": path})
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        src = _join_remote(root, src_rel)
+        dst = _join_remote(root, dst_rel)
+
+        def _do_move():
+            ftp = self._connect()
+            try:
+                # Ensure dst parent exists
+                parent = "/" if "/" not in dst.strip("/") else dst.rsplit("/", 1)[0]
+                parts = [p for p in parent.strip("/").split("/") if p]
+                cur = "/"
+                for p in parts:
+                    cur = _join_remote(cur, p)
+                    try:
+                        ftp.mkd(cur)
+                    except Exception:
+                        pass
+                ftp.rename(src, dst)
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_move)
+        await LogService.info("adapter:ftp", f"Moved {src_rel} to {dst_rel}", details={"adapter_id": self.record.id, "src": src, "dst": dst})
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        await self.move(root, src_rel, dst_rel)
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        src = _join_remote(root, src_rel)
+        dst = _join_remote(root, dst_rel)
+
+        # naive implementation: download then upload; recursively for dirs
+        async def _is_dir(path: str) -> bool:
+            def _probe() -> bool:
+                ftp = self._connect()
+                try:
+                    try:
+                        ftp.cwd(path)
+                        return True
+                    except Exception:
+                        return False
+                finally:
+                    try:
+                        ftp.quit()
+                    except Exception:
+                        pass
+            return await asyncio.to_thread(_probe)
+
+        if await _is_dir(src):
+            # list children, create dst dir, copy recursively
+            await self.mkdir(root, dst_rel)
+
+            children, _ = await self.list_dir(root, src_rel, page_num=1, page_size=10_000)
+            for ent in children:
+                child_src = f"{src_rel.rstrip('/')}/{ent['name']}"
+                child_dst = f"{dst_rel.rstrip('/')}/{ent['name']}"
+                await self.copy(root, child_src, child_dst, overwrite)
+            await LogService.info(
+                "adapter:ftp", f"Copied directory {src_rel} to {dst_rel}",
+                details={"adapter_id": self.record.id, "src": src, "dst": dst}
+            )
+            return
+
+        # file
+        data = await self.read_file(root, src_rel)
+        if not overwrite:
+            # best-effort existence check
+            try:
+                await self.stat_file(root, dst_rel)
+                raise FileExistsError(dst_rel)
+            except FileNotFoundError:
+                pass
+        await self.write_file(root, dst_rel, data)
+        await LogService.info("adapter:ftp", f"Copied {src_rel} to {dst_rel}", details={"adapter_id": self.record.id, "src": src, "dst": dst})
+
+    async def stat_file(self, root: str, rel: str):
+        path = _join_remote(root, rel)
+
+        def _do_stat():
+            ftp = self._connect()
+            try:
+                # Try MLST
+                try:
+                    resp: List[str] = []
+                    ftp.retrlines("MLST " + path, resp.append)
+                    # The last line usually contains facts
+                    facts = {}
+                    if resp:
+                        facts = _parse_mlst_line(resp[-1])
+                    name = rel.split("/")[-1]
+                    t = facts.get("type") or "file"
+                    is_dir = t == "dir"
+                    size = int(facts.get("size") or 0)
+                    mtime = _parse_modify_to_epoch(facts.get("modify") or "")
+                    return {
+                        "name": name,
+                        "is_dir": is_dir,
+                        "size": 0 if is_dir else size,
+                        "mtime": mtime,
+                        "type": "dir" if is_dir else "file",
+                        "path": path,
+                    }
+                except Exception:
+                    pass
+
+                # Probe directory
+                try:
+                    ftp.cwd(path)
+                    return {
+                        "name": rel.split("/")[-1],
+                        "is_dir": True,
+                        "size": 0,
+                        "mtime": 0,
+                        "type": "dir",
+                        "path": path,
+                    }
+                except Exception:
+                    pass
+
+                # Treat as file
+                try:
+                    size = ftp.size(path) or 0
+                except Exception:
+                    size = 0
+                try:
+                    mdtm = ftp.sendcmd("MDTM " + path)
+                    mtime = _parse_modify_to_epoch(mdtm.split(" ", 1)[1]) if mdtm.startswith("213 ") else 0
+                except Exception:
+                    mtime = 0
+                return {
+                    "name": rel.split("/")[-1],
+                    "is_dir": False,
+                    "size": int(size or 0),
+                    "mtime": int(mtime or 0),
+                    "type": "file",
+                    "path": path,
+                }
+            except error_perm as e:
+                if str(e).startswith("550"):
+                    raise FileNotFoundError(rel)
+                raise
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        return await asyncio.to_thread(_do_stat)
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        path = _join_remote(root, rel)
+        # Get size (best-effort)
+        def _get_size() -> Optional[int]:
+            ftp = self._connect()
+            try:
+                try:
+                    return int(ftp.size(path) or 0)
+                except Exception:
+                    return None
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        total_size = await asyncio.to_thread(_get_size)
+        mime, _ = mimetypes.guess_type(rel)
+        content_type = mime or "application/octet-stream"
+
+        rng: Optional[_Range] = None
+        status = 200
+        headers = {"Accept-Ranges": "bytes", "Content-Type": content_type}
+        if range_header and range_header.startswith("bytes=") and total_size is not None:
+            try:
+                s, e = (range_header.removeprefix("bytes=").split("-", 1))
+                start = int(s) if s.strip() else 0
+                end = int(e) if e.strip() else (total_size - 1)
+                if start >= total_size:
+                    raise HTTPException(416, detail="Requested Range Not Satisfiable")
+                if end >= total_size:
+                    end = total_size - 1
+                rng = _Range(start, end)
+                status = 206
+                headers["Content-Range"] = f"bytes {start}-{end}/{total_size}"
+                headers["Content-Length"] = str(end - start + 1)
+            except ValueError:
+                raise HTTPException(400, detail="Invalid Range header")
+        elif total_size is not None:
+            headers["Content-Length"] = str(total_size)
+
+        queue: asyncio.Queue[Optional[bytes]] = asyncio.Queue(maxsize=8)
+
+        class _Stop(Exception):
+            pass
+
+        def _worker():
+            ftp = self._connect()
+            remaining = None
+            if rng is not None:
+                remaining = (rng.end - rng.start + 1) if rng.end is not None else None
+
+            def _cb(chunk: bytes):
+                nonlocal remaining
+                if not chunk:
+                    return
+                try:
+                    if remaining is not None:
+                        if len(chunk) > remaining:
+                            part = chunk[:remaining]
+                            queue.put_nowait(part)
+                            remaining = 0
+                            raise _Stop()
+                        else:
+                            queue.put_nowait(chunk)
+                            remaining -= len(chunk)
+                            if remaining <= 0:
+                                raise _Stop()
+                    else:
+                        queue.put_nowait(chunk)
+                except _Stop:
+                    raise
+                except Exception:
+                    # queue full or event loop closed
+                    raise _Stop()
+
+            try:
+                if rng is not None:
+                    ftp.retrbinary("RETR " + path, _cb, rest=rng.start)
+                else:
+                    ftp.retrbinary("RETR " + path, _cb)
+                queue.put_nowait(None)
+            except _Stop:
+                try:
+                    queue.put_nowait(None)
+                except Exception:
+                    pass
+            except error_perm as e:
+                try:
+                    queue.put_nowait(None)
+                except Exception:
+                    pass
+                if str(e).startswith("550"):
+                    pass
+            finally:
+                try:
+                    ftp.quit()
+                except Exception:
+                    pass
+
+        async def agen():
+            worker_fut = asyncio.to_thread(_worker)
+            try:
+                while True:
+                    chunk = await queue.get()
+                    if chunk is None:
+                        break
+                    yield chunk
+            finally:
+                try:
+                    await worker_fut
+                except Exception:
+                    pass
+
+        return StreamingResponse(agen(), status_code=status, headers=headers, media_type=content_type)
+
+
+ADAPTER_TYPE = "ftp"
+
+CONFIG_SCHEMA = [
+    {"key": "host", "label": "主机", "type": "string", "required": True, "placeholder": "ftp.example.com"},
+    {"key": "port", "label": "端口", "type": "number", "required": False, "default": 21},
+    {"key": "username", "label": "用户名", "type": "string", "required": False},
+    {"key": "password", "label": "密码", "type": "password", "required": False},
+    {"key": "passive", "label": "被动模式", "type": "boolean", "required": False, "default": True},
+    {"key": "timeout", "label": "超时(秒)", "type": "number", "required": False, "default": 15},
+    {"key": "root", "label": "根路径", "type": "string", "required": False, "default": "/"},
+]
+
+
+def ADAPTER_FACTORY(rec: StorageAdapter):
+    return FTPAdapter(rec)

services/adapters/local.py

@@ -46,25 +46,18 @@ class LocalAdapter:
             return str(Path(root) / sub_path)
         return root
 
-    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50) -> Tuple[List[Dict], int]:
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]:
         rel = rel.strip('/')
         base = _safe_join(root, rel) if rel else Path(root)
         if not base.exists():
             return [], 0
         if not base.is_dir():
             raise NotADirectoryError(rel)
-        
-        # 获取所有文件名并排序
-        all_names = await asyncio.to_thread(lambda: sorted(os.listdir(base), key=str.lower))
-        total_count = len(all_names)
-        
-        # 计算分页范围
-        start_idx = (page_num - 1) * page_size
-        end_idx = start_idx + page_size
-        page_names = all_names[start_idx:end_idx]
+
+        all_names = await asyncio.to_thread(os.listdir, base)
         
         entries = []
-        for name in page_names:
+        for name in all_names:
             fp = base / name
             try:
                 st = await asyncio.to_thread(fp.stat)
@@ -79,10 +72,35 @@ class LocalAdapter:
                 "mode": stat.S_IMODE(st.st_mode),
                 "type": "dir" if is_dir else "file",
             })
+
+        # 排序
+        reverse = sort_order.lower() == "desc"
         
-        # 按目录优先排序
-        entries.sort(key=lambda x: (not x["is_dir"], x["name"].lower()))
-        return entries, total_count
+        def get_sort_key(item):
+            # 基础排序键，目录优先
+            key = (not item["is_dir"],)
+            sort_field = sort_by.lower()
+            
+            if sort_field == "name":
+                key += (item["name"].lower(),)
+            elif sort_field == "size":
+                key += (item["size"],)
+            elif sort_field == "mtime":
+                key += (item["mtime"],)
+            else: # 默认按名称
+                key += (item["name"].lower(),)
+            return key
+
+        entries.sort(key=get_sort_key, reverse=reverse)
+        
+        total_count = len(entries)
+        
+        # 分页
+        start_idx = (page_num - 1) * page_size
+        end_idx = start_idx + page_size
+        page_entries = entries[start_idx:end_idx]
+        
+        return page_entries, total_count
 
     async def read_file(self, root: str, rel: str) -> bytes:
         fp = _safe_join(root, rel)

services/adapters/onedrive.py

@@ -0,0 +1,462 @@
+from __future__ import annotations
+from datetime import datetime, timezone, timedelta
+from typing import List, Dict, Tuple, AsyncIterator
+import httpx
+from fastapi.responses import StreamingResponse, Response
+from fastapi import HTTPException
+from models import StorageAdapter
+
+MS_GRAPH_URL = "https://graph.microsoft.com/v1.0"
+MS_OAUTH_URL = "https://login.microsoftonline.com/common/oauth2/v2.0/token"
+
+
+class OneDriveAdapter:
+    """OneDrive 存储适配器"""
+
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        cfg = record.config
+        self.client_id = cfg.get("client_id")
+        self.client_secret = cfg.get("client_secret")
+        self.refresh_token = cfg.get("refresh_token")
+        self.root = cfg.get("root", "/").strip("/")
+        self.enable_redirect_307 = bool(cfg.get("enable_direct_download_307"))
+
+        if not all([self.client_id, self.client_secret, self.refresh_token]):
+            raise ValueError(
+                "OneDrive 适配器需要 client_id, client_secret, 和 refresh_token")
+
+        self._access_token: str | None = None
+        self._token_expiry: datetime | None = None
+
+    def get_effective_root(self, sub_path: str | None) -> str:
+        """
+        获取有效根路径。
+        :param sub_path: 子路径。
+        :return: 完整的有效路径。
+        """
+        if sub_path:
+            return f"/{self.root.strip('/')}/{sub_path.strip('/')}".strip()
+        return f"/{self.root.strip('/')}".strip()
+
+    def _get_api_path(self, rel_path: str) -> str:
+        """
+        将用户可见的相对路径转换为 Graph API 路径段。
+        :param rel_path: 相对路径。
+        :return: Graph API 路径段。
+        """
+        full_path = self.get_effective_root(rel_path).strip('/')
+        if not full_path:
+            return ""
+        return f":/{full_path}"
+
+    async def _get_access_token(self) -> str:
+        """
+        获取或刷新 access token。
+        :return: access token。
+        """
+        if self._access_token and self._token_expiry and datetime.now(timezone.utc) < self._token_expiry:
+            return self._access_token
+
+        data = {
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "refresh_token": self.refresh_token,
+            "grant_type": "refresh_token",
+        }
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            resp = await client.post(MS_OAUTH_URL, data=data)
+            resp.raise_for_status()
+            token_data = resp.json()
+            self._access_token = token_data["access_token"]
+            self._token_expiry = datetime.now(
+                timezone.utc) + timedelta(seconds=token_data["expires_in"] - 300)
+            return self._access_token
+
+    async def _request(self, method: str, api_path_segment: str | None = None, *, full_url: str | None = None, **kwargs):
+        """
+        向 Microsoft Graph API 发送请求。
+        :param method: HTTP 方法。
+        :param api_path_segment: API 路径段 (与 full_url 互斥)。
+        :param full_url: 完整的请求 URL (与 api_path_segment 互斥)。
+        :param kwargs: 其他请求参数。
+        :return: 响应对象。
+        """
+        if not ((api_path_segment is not None) ^ (full_url is not None)):
+            raise ValueError("必须提供 api_path_segment 或 full_url 中的一个，且仅一个")
+
+        token = await self._get_access_token()
+        headers = {"Authorization": f"Bearer {token}"}
+        if "headers" in kwargs:
+            headers.update(kwargs.pop("headers"))
+
+        url = full_url if full_url else f"{MS_GRAPH_URL}/me/drive/root{api_path_segment}"
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.request(method, url, headers=headers, **kwargs)
+            if resp.status_code == 401:
+                self._access_token = None
+                token = await self._get_access_token()
+                headers["Authorization"] = f"Bearer {token}"
+                resp = await client.request(method, url, headers=headers, **kwargs)
+            return resp
+
+    def _format_item(self, item: Dict) -> Dict:
+        """
+        将 Graph API 返回的 item 格式化为统一的格式。
+        :param item: Graph API 返回的 item 字典。
+        :return: 格式化后的字典。
+        """
+        is_dir = "folder" in item
+        return {
+            "name": item["name"],
+            "is_dir": is_dir,
+            "size": 0 if is_dir else item.get("size", 0),
+            "mtime": int(datetime.fromisoformat(item["lastModifiedDateTime"].replace("Z", "+00:00")).timestamp()),
+            "type": "dir" if is_dir else "file",
+        }
+
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]:
+        """
+        列出目录内容。
+        由于 Graph API 不支持基于偏移($skip)的分页，此方法将获取所有项目，
+        :param root: 根路径 (在此适配器中未使用，通过配置的 root 确定)。
+        :param rel: 相对路径。
+        :param page_num: 页码。
+        :param page_size: 每页大小。
+        :param sort_by: 排序字段
+        :param sort_order: 排序顺序
+        :return: 文件/目录列表和总数。
+        """
+        api_path = self._get_api_path(rel)
+        children_path = f"{api_path}:/children" if api_path else "/children"
+        all_items = []
+        params = {"$top": 999}
+        resp = await self._request("GET", api_path_segment=children_path, params=params)
+
+        while True:
+            if resp.status_code == 404 and not all_items:
+                return [], 0
+            resp.raise_for_status()
+
+            try:
+                data = resp.json()
+            except Exception as e:
+                raise IOError(f"解析 Graph API 响应失败: {e}") from e
+
+            all_items.extend(data.get("value", []))
+            next_link = data.get("@odata.nextLink")
+
+            if not next_link:
+                break
+
+            resp = await self._request("GET", full_url=next_link)
+
+        formatted_items = [self._format_item(item) for item in all_items]
+        
+        # 排序
+        reverse = sort_order.lower() == "desc"
+        def get_sort_key(item):
+            key = (not item["is_dir"],)
+            sort_field = sort_by.lower()
+            if sort_field == "name":
+                key += (item["name"].lower(),)
+            elif sort_field == "size":
+                key += (item["size"],)
+            elif sort_field == "mtime":
+                key += (item["mtime"],)
+            else:
+                key += (item["name"].lower(),)
+            return key
+        formatted_items.sort(key=get_sort_key, reverse=reverse)
+
+        total_count = len(formatted_items)
+        start_idx = (page_num - 1) * page_size
+        end_idx = start_idx + page_size
+
+        return formatted_items[start_idx:end_idx], total_count
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        """
+        读取文件内容。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        :return: 文件内容的字节流。
+        """
+        api_path = self._get_api_path(rel)
+        if not api_path:
+            raise IsADirectoryError("不能将根目录作为文件读取")
+
+        resp = await self._request("GET", api_path_segment=f"{api_path}:/content")
+        if resp.status_code == 404:
+            raise FileNotFoundError(rel)
+        resp.raise_for_status()
+        return resp.content
+
+    async def write_file(self, root: str, rel: str, data: bytes):
+        """
+        写入文件。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        :param data: 文件内容的字节流。
+        """
+        api_path = self._get_api_path(rel)
+        if not api_path:
+            raise ValueError("不能直接写入根路径")
+        resp = await self._request("PUT", api_path_segment=f"{api_path}:/content", content=data)
+        resp.raise_for_status()
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        """
+        以流式方式写入文件。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        :param data_iter: 文件内容的异步迭代器。
+        :return: 文件大小。
+        """
+        api_path = self._get_api_path(rel)
+        if not api_path:
+            raise ValueError("不能直接写入根路径")
+
+        resp = await self._request("PUT", api_path_segment=f"{api_path}:/content", content=data_iter)
+        resp.raise_for_status()
+        return resp.json().get("size", 0)
+
+    async def mkdir(self, root: str, rel: str):
+        """
+        创建目录。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        """
+        parent_path_str, new_dir_name = rel.rstrip(
+            '/').rsplit('/', 1) if '/' in rel.rstrip('/') else ('', rel)
+        parent_api_path = self._get_api_path(parent_path_str)
+
+        children_path = f"{parent_api_path}:/children" if parent_api_path else "/children"
+
+        payload = {
+            "name": new_dir_name,
+            "folder": {},
+            "@microsoft.graph.conflictBehavior": "fail"  # 如果已存在则失败
+        }
+        resp = await self._request("POST", api_path_segment=children_path, json=payload)
+        resp.raise_for_status()
+
+    async def delete(self, root: str, rel: str):
+        """
+        删除文件或目录。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        """
+        api_path = self._get_api_path(rel)
+        if not api_path:
+            raise ValueError("不能删除根目录")
+
+        resp = await self._request("DELETE", api_path_segment=api_path)
+        if resp.status_code not in (204, 404):
+            resp.raise_for_status()
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        """
+        移动或重命名文件/目录。
+        :param root: 根路径。
+        :param src_rel: 源相对路径。
+        :param dst_rel: 目标相对路径。
+        """
+        src_api_path = self._get_api_path(src_rel)
+        if not src_api_path:
+            raise ValueError("不能移动根目录")
+
+        dst_parent_rel, dst_name = dst_rel.rstrip(
+            '/').rsplit('/', 1) if '/' in dst_rel.rstrip('/') else ('', dst_rel)
+        dst_parent_api_path = self._get_api_path(dst_parent_rel)
+
+        # 获取父项目的 ID
+        parent_resp = await self._request("GET", api_path_segment=dst_parent_api_path)
+        parent_resp.raise_for_status()
+        parent_id = parent_resp.json()["id"]
+
+        payload = {
+            "parentReference": {"id": parent_id},
+            "name": dst_name
+        }
+        resp = await self._request("PATCH", api_path_segment=src_api_path, json=payload)
+        resp.raise_for_status()
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        """
+        重命名文件或目录。
+        在 Graph API 中，移动和重命名是同一个 PATCH 操作。
+        """
+        await self.move(root, src_rel, dst_rel)
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        """
+        复制文件或目录。
+        :param root: 根路径。
+        :param src_rel: 源相对路径。
+        :param dst_rel: 目标相对路径。
+        :param overwrite: 是否覆盖 (在此 API 中未直接使用)。
+        """
+        src_api_path = self._get_api_path(src_rel)
+        if not src_api_path:
+            raise ValueError("不能复制根目录")
+
+        dst_parent_rel, dst_name = dst_rel.rstrip(
+            '/').rsplit('/', 1) if '/' in dst_rel.rstrip('/') else ('', dst_rel)
+        dst_parent_api_path = self._get_api_path(dst_parent_rel)
+
+        parent_resp = await self._request("GET", api_path_segment=dst_parent_api_path)
+        parent_resp.raise_for_status()
+        parent_id = parent_resp.json()["id"]
+
+        payload = {"parentReference": {"id": parent_id}, "name": dst_name}
+        copy_path = f"{src_api_path}:/copy"
+        resp = await self._request("POST", api_path_segment=copy_path, json=payload)
+        resp.raise_for_status()
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        """
+        流式传输文件（支持范围请求）。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        :param range_header: HTTP Range 头。
+        :return: FastAPI StreamingResponse 对象。
+        """
+        api_path = self._get_api_path(rel)
+        if not api_path:
+            raise IsADirectoryError("不能对目录进行流式传输")
+
+        resp = await self._request("GET", api_path_segment=api_path)
+        if resp.status_code == 404:
+            raise FileNotFoundError(rel)
+        resp.raise_for_status()
+        item_data = resp.json()
+
+        download_url = item_data.get("@microsoft.graph.downloadUrl")
+        if not download_url:
+            raise Exception("无法获取下载 URL")
+
+        file_size = item_data.get("size", 0)
+        content_type = item_data.get("file", {}).get(
+            "mimeType", "application/octet-stream")
+
+        start = 0
+        end = file_size - 1
+        status = 200
+        headers = {
+            "Accept-Ranges": "bytes",
+            "Content-Type": content_type,
+            "Content-Disposition": f"inline; filename=\"{item_data.get('name')}\""
+        }
+
+        if range_header and range_header.startswith("bytes="):
+            try:
+                part = range_header.removeprefix("bytes=")
+                s, e = part.split("-", 1)
+                if s.strip():
+                    start = int(s)
+                if e.strip():
+                    end = int(e)
+                if start >= file_size:
+                    raise HTTPException(416, "Requested Range Not Satisfiable")
+                if end >= file_size:
+                    end = file_size - 1
+                status = 206
+            except ValueError:
+                raise HTTPException(400, "Invalid Range header")
+
+            headers["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+            headers["Content-Length"] = str(end - start + 1)
+        else:
+            headers["Content-Length"] = str(file_size)
+
+        async def file_iterator():
+            nonlocal start, end
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                req_headers = {'Range': f'bytes={start}-{end}'}
+                async with client.stream("GET", download_url, headers=req_headers) as stream_resp:
+                    stream_resp.raise_for_status()
+                    async for chunk in stream_resp.aiter_bytes():
+                        yield chunk
+
+        return StreamingResponse(file_iterator(), status_code=status, headers=headers, media_type=content_type)
+
+    async def get_direct_download_response(self, root: str, rel: str):
+        if not self.enable_redirect_307:
+            return None
+
+        api_path = self._get_api_path(rel)
+        if not api_path:
+            raise IsADirectoryError("不能对目录进行直链重定向")
+
+        resp = await self._request("GET", api_path_segment=api_path)
+        if resp.status_code == 404:
+            raise FileNotFoundError(rel)
+        resp.raise_for_status()
+
+        item_data = resp.json()
+        download_url = item_data.get("@microsoft.graph.downloadUrl")
+        if not download_url:
+            return None
+
+        return Response(status_code=307, headers={"Location": download_url})
+
+    async def get_thumbnail(self, root: str, rel: str, size: str = "medium"):
+        """
+        获取文件的缩略图。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        :param size: 缩略图大小 (large, medium, small)。
+        :return: 缩略图内容的字节流，或在不支持时返回 None。
+        """
+        api_path = self._get_api_path(rel)
+        if not api_path:
+            return None
+
+        thumb_path = f"{api_path}:/thumbnails/0/{size}"
+
+        try:
+            resp = await self._request("GET", api_path_segment=thumb_path)
+            if resp.status_code == 200:
+                thumb_data = resp.json()
+                async with httpx.AsyncClient(timeout=30.0) as client:
+                    thumb_resp = await client.get(thumb_data['url'])
+                    thumb_resp.raise_for_status()
+                    return thumb_resp.content
+            elif resp.status_code == 404:
+                return None
+            else:
+                resp.raise_for_status()
+        except Exception:
+            return None
+
+    async def stat_file(self, root: str, rel: str):
+        """
+        获取文件或目录的元数据。
+        :param root: 根路径。
+        :param rel: 相对路径。
+        :return: 格式化后的文件/目录信息。
+        """
+        api_path = self._get_api_path(rel)
+        resp = await self._request("GET", api_path_segment=api_path)
+        if resp.status_code == 404:
+            raise FileNotFoundError(rel)
+        resp.raise_for_status()
+        return self._format_item(resp.json())
+
+
+ADAPTER_TYPE = "OneDrive"
+
+CONFIG_SCHEMA = [
+    {"key": "client_id", "label": "Client ID", "type": "string", "required": True},
+    {"key": "client_secret", "label": "Client Secret",
+        "type": "password", "required": True},
+    {"key": "refresh_token", "label": "Refresh Token", "type": "password",
+        "required": True, "help_text": "可以通过运行 'python -m services.adapters.onedrive' 获取"},
+    {"key": "root", "label": "根目录 (Root Path)", "type": "string",
+     "required": False, "placeholder": "默认为根目录 /"},
+    {"key": "enable_direct_download_307", "label": "Enable 307 redirect download", "type": "boolean", "default": False},
+]
+
+
+def ADAPTER_FACTORY(rec): return OneDriveAdapter(rec)

services/adapters/quark.py

@@ -0,0 +1,731 @@
+from __future__ import annotations
+import asyncio
+import base64
+import hashlib
+import mimetypes
+import os
+import time
+from typing import Dict, List, Tuple, Optional, AsyncIterator, Any
+
+import httpx
+from fastapi import HTTPException
+from fastapi.responses import StreamingResponse
+
+from models import StorageAdapter
+from .base import BaseAdapter
+
+
+# Quark 普通(UC)接口
+API_BASE = "https://drive.quark.cn/1/clouddrive"
+REFERER = "https://pan.quark.cn"
+PR = "ucpro"
+
+
+class QuarkAdapter:
+    """夸克网盘（Cookie 模式）
+
+    - 使用浏览器导出的 Cookie 进行鉴权
+    - 通过 Quark/UC 的 clouddrive 接口实现：列目录、读写、分片上传、基础操作
+    - 根 FID 固定为 "0"；路径解析通过名称遍历
+    """
+
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        cfg = record.config or {}
+        self.cookie: str = cfg.get("cookie") or cfg.get("Cookie")
+        self.root_fid: str = cfg.get("root_fid", "0")
+        def _as_bool(value: Any) -> bool:
+            if isinstance(value, bool):
+                return value
+            if isinstance(value, str):
+                return value.strip().lower() in {"1", "true", "yes", "on"}
+            return bool(value)
+
+        self.use_transcoding_address: bool = _as_bool(cfg.get("use_transcoding_address", False))
+        self.only_list_video_file: bool = _as_bool(cfg.get("only_list_video_file", False))
+
+        if not self.cookie:
+            raise ValueError("Quark 适配器需要 cookie 配置")
+
+        # 运行期缓存
+        self._dir_fid_cache: Dict[str, str] = {f"{self.root_fid}:": self.root_fid}
+        self._children_cache: Dict[str, List[Dict[str, Any]]] = {}
+
+        # UA 与超时
+        self._ua = (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+            "(KHTML, like Gecko) quark-cloud-drive/2.5.20 Chrome/100.0.4896.160 "
+            "Electron/18.3.5.4-b478491100 Safari/537.36 Channel/pckk_other_ch"
+        )
+        self._timeout = 30.0
+
+    # -----------------
+    # 工具与通用请求
+    # -----------------
+    def get_effective_root(self, sub_path: str | None) -> str:
+        return self.root_fid
+
+    async def _request(
+        self,
+        method: str,
+        pathname: str,
+        *,
+        json: Any | None = None,
+        params: Dict[str, str] | None = None,
+    ) -> Any:
+        headers = {
+            "Cookie": self._safe_cookie(self.cookie),
+            "Accept": "application/json, text/plain, */*",
+            "Referer": REFERER,
+            "User-Agent": self._ua,
+        }
+        query = {"pr": PR, "fr": "pc"}
+        if params:
+            query.update(params)
+        url = f"{API_BASE}{pathname}"
+
+        async with httpx.AsyncClient(timeout=self._timeout) as client:
+            resp = await client.request(method, url, headers=headers, params=query, json=json)
+            # 更新运行期 cookie（若返回 __puus/__pus）
+            try:
+                for key in ("__puus", "__pus"):
+                    v = resp.cookies.get(key)
+                    if v:
+                        # 简单替换/追加到 self.cookie
+                        self._set_cookie_kv(key, v)
+            except Exception:
+                pass
+
+            # 解析业务状态
+            data = None
+            try:
+                data = resp.json()
+            except Exception:
+                resp.raise_for_status()
+                return resp
+            status = data.get("status")
+            code = data.get("code")
+            msg = data.get("message") or ""
+            if (status is not None and status >= 400) or (code is not None and code != 0):
+                raise HTTPException(502, detail=f"Quark error status={status} code={code} msg={msg}")
+            return data
+
+    def _set_cookie_kv(self, key: str, value: str):
+        # 将指定键值写入 self.cookie（粗略字符串处理）
+        parts = [p.strip() for p in (self.cookie or "").replace("\r", "").replace("\n", "").split(";") if p.strip()]
+        found = False
+        for i, p in enumerate(parts):
+            if p.startswith(key + "="):
+                parts[i] = f"{key}={value}"
+                found = True
+                break
+        if not found:
+            parts.append(f"{key}={value}")
+        self.cookie = "; ".join(parts)
+
+    def _sanitize_cookie(self, cookie: str) -> str:
+        if not cookie:
+            return ""
+        # 去除换行与前后空白
+        cookie = cookie.replace("\r", "").replace("\n", "").strip()
+        # 统一分号分隔并去除多余空格/空段
+        parts = [p.strip() for p in cookie.split(";") if p.strip()]
+        return "; ".join(parts)
+
+    def _safe_cookie(self, cookie: str) -> str:
+        s = self._sanitize_cookie(cookie)
+        # 仅保留可见 ASCII (0x20-0x7E)
+        s = "".join(ch for ch in s if 32 <= ord(ch) <= 126)
+        return s
+
+    # -----------------
+    # 列表与路径解析
+    # -----------------
+    def _map_file_item(self, it: Dict[str, Any]) -> Dict[str, Any]:
+        # Quark/UC 列表项：file=true 表示文件；false 表示目录
+        is_dir = not bool(it.get("file", False))
+        updated_at_ms = int(it.get("updated_at", 0) or 0)
+        name = it.get("file_name") or it.get("filename") or it.get("name")
+        return {
+            "fid": it.get("fid"),
+            "name": name,
+            "is_dir": is_dir,
+            "size": 0 if is_dir else int(it.get("size", 0) or 0),
+            "mtime": updated_at_ms // 1000 if updated_at_ms else 0,
+            "type": "dir" if is_dir else "file",
+        }
+
+    async def _list_children(self, parent_fid: str) -> List[Dict[str, Any]]:
+        if parent_fid in self._children_cache:
+            return self._children_cache[parent_fid]
+
+        files: List[Dict[str, Any]] = []
+        page = 1
+        size = 100
+        total = None
+        while True:
+            qp = {"pdir_fid": parent_fid, "_size": str(size), "_page": str(page), "_fetch_total": "1"}
+            data = await self._request("GET", "/file/sort", params=qp)
+            d = (data or {}).get("data", {})
+            meta = (data or {}).get("metadata", {})
+            page_files = d.get("list", [])
+            files.extend(page_files)
+            if total is None:
+                total = meta.get("_total") or meta.get("total") or 0
+            if page * size >= int(total):
+                break
+            page += 1
+
+        mapped = [self._map_file_item(x) for x in files if (not self.only_list_video_file) or (not x.get("file")) or (x.get("category") == 1)]
+        self._children_cache[parent_fid] = mapped
+        return mapped
+
+    def _dir_cache_key(self, base_fid: str, rel: str) -> str:
+        return f"{base_fid}:{rel.strip('/')}"
+
+    async def _resolve_dir_fid_from(self, base_fid: str, rel: str) -> str:
+        key = rel.strip("/")
+        cache_key = self._dir_cache_key(base_fid, key)
+        if cache_key in self._dir_fid_cache:
+            return self._dir_fid_cache[cache_key]
+        if key == "":
+            self._dir_fid_cache[cache_key] = base_fid
+            return base_fid
+
+        parent_fid = base_fid
+        path_so_far = []
+        for seg in key.split("/"):
+            if seg == "":
+                continue
+            path_so_far.append(seg)
+            cache_key = self._dir_cache_key(base_fid, "/".join(path_so_far))
+            cached = self._dir_fid_cache.get(cache_key)
+            if cached:
+                parent_fid = cached
+                continue
+            children = await self._list_children(parent_fid)
+            found = next((c for c in children if c["is_dir"] and c["name"] == seg), None)
+            if not found:
+                raise FileNotFoundError(f"Directory not found: {seg}")
+            parent_fid = found["fid"]
+            self._dir_fid_cache[cache_key] = parent_fid
+
+        return parent_fid
+
+    async def _find_child(self, parent_fid: str, name: str) -> Optional[Dict[str, Any]]:
+        children = await self._list_children(parent_fid)
+        for it in children:
+            if it["name"] == name:
+                return it
+        return None
+
+    def _invalidate_children_cache(self, parent_fid: str):
+        if parent_fid in self._children_cache:
+            try:
+                del self._children_cache[parent_fid]
+            except Exception:
+                pass
+
+    # -----------------
+    # 目录与文件列表
+    # -----------------
+    async def list_dir(
+        self,
+        root: str,
+        rel: str,
+        page_num: int = 1,
+        page_size: int = 50,
+        sort_by: str = "name",
+        sort_order: str = "asc",
+    ) -> Tuple[List[Dict], int]:
+        base_fid = root or self.root_fid
+        fid = await self._resolve_dir_fid_from(base_fid, rel)
+        items = await self._list_children(fid)
+
+        # 排序，目录优先
+        reverse = sort_order.lower() == "desc"
+
+        def get_sort_key(item):
+            key = (not item["is_dir"],)
+            sf = sort_by.lower()
+            if sf == "name":
+                key += (item["name"].lower(),)
+            elif sf == "size":
+                key += (item["size"],)
+            elif sf == "mtime":
+                key += (item["mtime"],)
+            else:
+                key += (item["name"].lower(),)
+            return key
+
+        items.sort(key=get_sort_key, reverse=reverse)
+        total = len(items)
+        start = (page_num - 1) * page_size
+        end = start + page_size
+        return items[start:end], total
+
+    # -----------------
+    # 下载与流式下载
+    # -----------------
+    async def _get_download_url(self, fid: str) -> str:
+        data = await self._request("POST", "/file/download", json={"fids": [fid]})
+        arr = (data or {}).get("data", [])
+        if not arr:
+            raise HTTPException(502, detail="No download data returned by Quark")
+        url = arr[0].get("download_url") or arr[0].get("DownloadUrl")
+        if not url:
+            raise HTTPException(502, detail="No download_url returned by Quark")
+        return url
+
+    async def _get_transcoding_url(self, fid: str) -> Optional[str]:
+        try:
+            payload = {"fid": fid, "resolutions": "low,normal,high,super,2k,4k", "supports": "fmp4_av,m3u8,dolby_vision"}
+            data = await self._request("POST", "/file/v2/play/project", json=payload)
+            lst = (data or {}).get("data", {}).get("video_list", [])
+            for item in lst:
+                vi = item.get("video_info") or {}
+                url = vi.get("url")
+                if url:
+                    return url
+        except Exception:
+            return None
+        return None
+
+    def _is_video_name(self, name: str) -> bool:
+        mime, _ = mimetypes.guess_type(name)
+        return bool(mime and mime.startswith("video/"))
+
+    def _download_headers(self) -> Dict[str, str]:
+        return {"Cookie": self._safe_cookie(self.cookie), "User-Agent": self._ua, "Referer": REFERER}
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        if not rel or rel.endswith("/"):
+            raise IsADirectoryError("Path is a directory")
+        parent = rel.rsplit("/", 1)[0] if "/" in rel else ""
+        name = rel.rsplit("/", 1)[-1]
+        base_fid = root or self.root_fid
+        parent_fid = await self._resolve_dir_fid_from(base_fid, parent)
+        it = await self._find_child(parent_fid, name)
+        if not it or it["is_dir"]:
+            raise FileNotFoundError(rel)
+        url = await self._get_download_url(it["fid"])
+        headers = self._download_headers()
+        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
+            resp = await client.get(url, headers=headers)
+            if resp.status_code == 404:
+                raise FileNotFoundError(rel)
+            resp.raise_for_status()
+            return resp.content
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        if not rel or rel.endswith("/"):
+            raise IsADirectoryError("Path is a directory")
+        parent = rel.rsplit("/", 1)[0] if "/" in rel else ""
+        name = rel.rsplit("/", 1)[-1]
+        base_fid = root or self.root_fid
+        parent_fid = await self._resolve_dir_fid_from(base_fid, parent)
+        it = await self._find_child(parent_fid, name)
+        if not it or it["is_dir"]:
+            raise FileNotFoundError(rel)
+        url = await self._get_download_url(it["fid"])
+        if self.use_transcoding_address and self._is_video_name(name):
+            tr = await self._get_transcoding_url(it["fid"]) 
+            if tr:
+                url = tr
+        dl_headers = self._download_headers()
+
+        # 预获取大小/是否支持范围
+        total_size: Optional[int] = None
+        async with httpx.AsyncClient(timeout=self._timeout, follow_redirects=True) as client:
+            try:
+                head_resp = await client.head(url, headers=dl_headers)
+                if head_resp.status_code == 200:
+                    cl = head_resp.headers.get("Content-Length")
+                    if cl and cl.isdigit():
+                        total_size = int(cl)
+            except Exception:
+                pass
+
+        mime, _ = mimetypes.guess_type(rel)
+        content_type = mime or "application/octet-stream"
+
+        # 解析 Range
+        start = 0
+        end: Optional[int] = None
+        status_code = 200
+        if range_header and range_header.startswith("bytes="):
+            status_code = 206
+            part = range_header.split("=", 1)[1]
+            s, e = part.split("-", 1)
+            if s.strip():
+                start = int(s)
+            if e.strip():
+                end = int(e)
+
+        if total_size is not None and end is None and status_code == 206:
+            end = total_size - 1
+        if end is not None and total_size is not None and end >= total_size:
+            end = total_size - 1
+        if total_size is not None and start >= total_size:
+            raise HTTPException(416, detail="Requested Range Not Satisfiable")
+
+        resp_headers: Dict[str, str] = {"Accept-Ranges": "bytes", "Content-Type": content_type}
+        if status_code == 206 and total_size is not None and end is not None:
+            resp_headers["Content-Range"] = f"bytes {start}-{end}/{total_size}"
+            resp_headers["Content-Length"] = str(end - start + 1)
+        elif total_size is not None:
+            resp_headers["Content-Length"] = str(total_size)
+
+        async def iterator():
+            headers = dict(dl_headers)
+            if status_code == 206 and end is not None:
+                headers["Range"] = f"bytes={start}-{end}"
+            async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
+                async with client.stream("GET", url, headers=headers) as resp:
+                    if resp.status_code in (404, 416):
+                        await resp.aclose()
+                        raise HTTPException(resp.status_code, detail="Upstream not available")
+                    async for chunk in resp.aiter_bytes():
+                        if chunk:
+                            yield chunk
+
+        return StreamingResponse(iterator(), status_code=status_code, headers=resp_headers, media_type=content_type)
+
+    # -----------------
+    # 上传（大文件分片）
+    # -----------------
+    @staticmethod
+    def _md5_hex(b: bytes) -> str:
+        return hashlib.md5(b).hexdigest()
+
+    @staticmethod
+    def _sha1_hex(b: bytes) -> str:
+        return hashlib.sha1(b).hexdigest()
+
+    def _guess_mime(self, name: str) -> str:
+        mime, _ = mimetypes.guess_type(name)
+        return mime or "application/octet-stream"
+
+    async def _upload_pre(self, filename: str, size: int, parent_fid: str) -> Dict[str, Any]:
+        now_ms = int(time.time() * 1000)
+        body = {
+            "ccp_hash_update": True,
+            "dir_name": "",
+            "file_name": filename,
+            "format_type": self._guess_mime(filename),
+            "l_created_at": now_ms,
+            "l_updated_at": now_ms,
+            "pdir_fid": parent_fid,
+            "size": size,
+        }
+        data = await self._request("POST", "/file/upload/pre", json=body)
+        return data
+
+    async def write_file(self, root: str, rel: str, data: bytes):
+        async def gen():
+            yield data
+        return await self.write_file_stream(root, rel, gen())
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        if not rel or rel.endswith("/"):
+            raise HTTPException(400, detail="Invalid file path")
+
+        parent = rel.rsplit("/", 1)[0] if "/" in rel else ""
+        name = rel.rsplit("/", 1)[-1]
+        base_fid = root or self.root_fid
+        parent_fid = await self._resolve_dir_fid_from(base_fid, parent)
+
+        # 将数据落盘到临时文件，同时计算 MD5/SHA1
+        import tempfile
+
+        md5 = hashlib.md5()
+        sha1 = hashlib.sha1()
+        total = 0
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            tmp_path = tf.name
+            try:
+                async for chunk in data_iter:
+                    if not chunk:
+                        continue
+                    total += len(chunk)
+                    md5.update(chunk)
+                    sha1.update(chunk)
+                    tf.write(chunk)
+            finally:
+                tf.flush()
+
+        md5_hex = md5.hexdigest()
+        sha1_hex = sha1.hexdigest()
+
+        # 预上传，拿到上传信息
+        pre_resp = await self._upload_pre(name, total, parent_fid)
+        pre_data = pre_resp.get("data", {})
+
+        # hash 秒传
+        hash_body = {"md5": md5_hex, "sha1": sha1_hex, "task_id": pre_data.get("task_id")}
+        hash_resp = await self._request("POST", "/file/update/hash", json=hash_body)
+        if (hash_resp.get("data") or {}).get("finish") is True:
+            try:
+                os.unlink(tmp_path)
+            except Exception:
+                pass
+            # 刷新父目录缓存
+            self._invalidate_children_cache(parent_fid)
+            return total
+
+        # 分片上传
+        part_size = int((pre_resp.get("metadata") or {}).get("part_size") or 0)
+        if part_size <= 0:
+            raise HTTPException(502, detail="Invalid part_size from Quark")
+
+        bucket = pre_data.get("bucket")
+        obj_key = pre_data.get("obj_key")
+        upload_id = pre_data.get("upload_id")
+        upload_url = pre_data.get("upload_url")
+        if not (bucket and obj_key and upload_id and upload_url):
+            raise HTTPException(502, detail="Upload pre missing fields")
+
+        # 计算 host 与基础 URL
+        try:
+            upload_host = upload_url.split("://", 1)[1]
+        except Exception:
+            upload_host = upload_url
+        base_url = f"https://{bucket}.{upload_host}/{obj_key}"
+
+        # 分片循环
+        etags: List[str] = []
+        oss_ua = "aliyun-sdk-js/6.6.1 Chrome 98.0.4758.80 on Windows 10 64-bit"
+        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
+            with open(tmp_path, "rb") as rf:
+                part_number = 1
+                left = total
+                while left > 0:
+                    sz = min(part_size, left)
+                    data_bytes = rf.read(sz)
+                    if len(data_bytes) != sz:
+                        raise IOError("Failed to read part bytes")
+                    now_str = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())
+                    # 申请签名
+                    auth_meta = (
+                        "PUT\n\n"
+                        f"{self._guess_mime(name)}\n"
+                        f"{now_str}\n"
+                        f"x-oss-date:{now_str}\n"
+                        f"x-oss-user-agent:{oss_ua}\n"
+                        f"/{bucket}/{obj_key}?partNumber={part_number}&uploadId={upload_id}"
+                    )
+                    auth_req_body = {"auth_info": pre_data.get("auth_info"), "auth_meta": auth_meta, "task_id": pre_data.get("task_id")}
+                    auth_resp = await self._request("POST", "/file/upload/auth", json=auth_req_body)
+                    auth_key = (auth_resp.get("data") or {}).get("auth_key")
+                    if not auth_key:
+                        raise HTTPException(502, detail="upload/auth missing auth_key")
+
+                    put_headers = {
+                        "Authorization": auth_key,
+                        "Content-Type": self._guess_mime(name),
+                        "Referer": REFERER + "/",
+                        "x-oss-date": now_str,
+                        "x-oss-user-agent": oss_ua,
+                    }
+                    put_url = f"{base_url}?partNumber={part_number}&uploadId={upload_id}"
+                    put_resp = await client.put(put_url, headers=put_headers, content=data_bytes)
+                    if put_resp.status_code != 200:
+                        raise HTTPException(502, detail=f"Upload part failed status={put_resp.status_code} text={put_resp.text}")
+                    etag = put_resp.headers.get("Etag", "")
+                    etags.append(etag)
+                    left -= sz
+                    part_number += 1
+
+        # 组合 commit xml
+        parts_xml = [f"<Part>\n<PartNumber>{i+1}</PartNumber>\n<ETag>{etags[i]}</ETag>\n</Part>\n" for i in range(len(etags))]
+        body_xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<CompleteMultipartUpload>\n" + "".join(parts_xml) + "</CompleteMultipartUpload>"
+        content_md5 = base64.b64encode(hashlib.md5(body_xml.encode("utf-8")).digest()).decode("ascii")
+        callback = pre_data.get("callback") or {}
+        try:
+            import json as _json
+            callback_b64 = base64.b64encode(_json.dumps(callback).encode("utf-8")).decode("ascii")
+        except Exception:
+            callback_b64 = ""
+
+        now_str = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())
+        auth_meta_commit = (
+            "POST\n"
+            f"{content_md5}\n"
+            "application/xml\n"
+            f"{now_str}\n"
+            f"x-oss-callback:{callback_b64}\n"
+            f"x-oss-date:{now_str}\n"
+            f"x-oss-user-agent:{oss_ua}\n"
+            f"/{bucket}/{obj_key}?uploadId={upload_id}"
+        )
+        auth_commit_resp = await self._request("POST", "/file/upload/auth", json={"auth_info": pre_data.get("auth_info"), "auth_meta": auth_meta_commit, "task_id": pre_data.get("task_id")})
+        auth_key_commit = (auth_commit_resp.get("data") or {}).get("auth_key")
+        if not auth_key_commit:
+            raise HTTPException(502, detail="upload/auth(commit) missing auth_key")
+
+        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
+            commit_headers = {
+                "Authorization": auth_key_commit,
+                "Content-MD5": content_md5,
+                "Content-Type": "application/xml",
+                "Referer": REFERER + "/",
+                "x-oss-callback": callback_b64,
+                "x-oss-date": now_str,
+                "x-oss-user-agent": oss_ua,
+            }
+            commit_url = f"{base_url}?uploadId={upload_id}"
+            r = await client.post(commit_url, headers=commit_headers, content=body_xml.encode("utf-8"))
+            if r.status_code != 200:
+                raise HTTPException(502, detail=f"Upload commit failed status={r.status_code} text={r.text}")
+
+        # finish
+        await self._request("POST", "/file/upload/finish", json={"obj_key": obj_key, "task_id": pre_data.get("task_id")})
+        # 端合并存在轻微延迟，等待再刷新缓存
+        try:
+            await asyncio.sleep(1.0)
+        except Exception:
+            pass
+
+        try:
+            os.unlink(tmp_path)
+        except Exception:
+            pass
+        # 失效父目录缓存，确保后续列表可见
+        self._invalidate_children_cache(parent_fid)
+        return total
+
+    # -----------------
+    # 基本文件操作
+    # -----------------
+    async def mkdir(self, root: str, rel: str):
+        if not rel or rel == "/":
+            raise HTTPException(400, detail="Cannot create root")
+        parent = rel.rstrip("/")
+        parent_rel, name = (parent.rsplit("/", 1) if "/" in parent else ("", parent))
+        if not name:
+            raise HTTPException(400, detail="Invalid directory name")
+        pdir = await self._resolve_dir_fid_from(root or self.root_fid, parent_rel)
+        await self._request("POST", "/file", json={"dir_init_lock": False, "dir_path": "", "file_name": name, "pdir_fid": pdir})
+        self._invalidate_children_cache(pdir)
+
+    async def delete(self, root: str, rel: str):
+        # 解析对象 fid + 父目录，用于失效缓存
+        base_fid = root or self.root_fid
+        if rel == "" or rel.endswith("/"):
+            parent_rel = rel.rstrip("/")
+            target_fid = await self._resolve_dir_fid_from(base_fid, parent_rel)
+            parent_of_target = await self._resolve_dir_fid_from(base_fid, (parent_rel.rsplit("/", 1)[0] if "/" in parent_rel else ""))
+        else:
+            parent_rel, name = (rel.rsplit("/", 1) if "/" in rel else ("", rel))
+            parent_of_target = await self._resolve_dir_fid_from(base_fid, parent_rel)
+            it = await self._find_child(parent_of_target, name)
+            if not it:
+                return
+            target_fid = it["fid"]
+        await self._request("POST", "/file/delete", json={"action_type": 1, "exclude_fids": [], "filelist": [target_fid]})
+        self._invalidate_children_cache(parent_of_target)
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        # 支持跨目录与重命名：先移动到父目录，后重命名（若需要）
+        src_parent_rel, src_name = (src_rel.rsplit("/", 1) if "/" in src_rel else ("", src_rel))
+        dst_parent_rel, dst_name = (dst_rel.rsplit("/", 1) if "/" in dst_rel else ("", dst_rel))
+
+        base_fid = root or self.root_fid
+        src_parent_fid = await self._resolve_dir_fid_from(base_fid, src_parent_rel)
+        obj = await self._find_child(src_parent_fid, src_name)
+        if not obj:
+            raise FileNotFoundError(src_rel)
+        dst_parent_fid = await self._resolve_dir_fid_from(base_fid, dst_parent_rel)
+
+        if src_parent_fid != dst_parent_fid:
+            await self._request("POST", "/file/move", json={"action_type": 1, "exclude_fids": [], "filelist": [obj["fid"]], "to_pdir_fid": dst_parent_fid})
+            self._invalidate_children_cache(src_parent_fid)
+            self._invalidate_children_cache(dst_parent_fid)
+
+        if obj["name"] != dst_name:
+            await self._request("POST", "/file/rename", json={"fid": obj["fid"], "file_name": dst_name})
+            self._invalidate_children_cache(dst_parent_fid)
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        src_parent_rel, src_name = (src_rel.rsplit("/", 1) if "/" in src_rel else ("", src_rel))
+        base_fid = root or self.root_fid
+        src_parent_fid = await self._resolve_dir_fid_from(base_fid, src_parent_rel)
+        obj = await self._find_child(src_parent_fid, src_name)
+        if not obj:
+            raise FileNotFoundError(src_rel)
+        dst_name = dst_rel.rsplit("/", 1)[-1]
+        await self._request("POST", "/file/rename", json={"fid": obj["fid"], "file_name": dst_name})
+        self._invalidate_children_cache(src_parent_fid)
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        raise NotImplementedError("QuarkOpen does not support copy via open API")
+
+    # -----------------
+    # STAT / EXISTS / 辅助
+    # -----------------
+    async def stat_file(self, root: str, rel: str):
+        # 通过父目录列表获取元数据
+        base_fid = root or self.root_fid
+        if rel == "" or rel.endswith("/"):
+            # 目录
+            fid = await self._resolve_dir_fid_from(base_fid, rel.rstrip("/"))
+            return {"name": rel.rstrip("/").split("/")[-1] if rel else "", "is_dir": True, "size": 0, "mtime": 0, "type": "dir", "fid": fid}
+        parent_rel, name = (rel.rsplit("/", 1) if "/" in rel else ("", rel))
+        parent_fid = await self._resolve_dir_fid_from(base_fid, parent_rel)
+        it = await self._find_child(parent_fid, name)
+        if not it:
+            raise FileNotFoundError(rel)
+        return it
+
+    async def exists(self, root: str, rel: str) -> bool:
+        try:
+            base_fid = root or self.root_fid
+            if rel == "" or rel.endswith("/"):
+                await self._resolve_dir_fid_from(base_fid, rel.rstrip("/"))
+                return True
+            parent_rel, name = (rel.rsplit("/", 1) if "/" in rel else ("", rel))
+            parent_fid = await self._resolve_dir_fid_from(base_fid, parent_rel)
+            it = await self._find_child(parent_fid, name)
+            return it is not None
+        except FileNotFoundError:
+            return False
+
+    async def stat_path(self, root: str, rel: str):
+        # 用于 move/copy 前的预检查调试
+        try:
+            base_fid = root or self.root_fid
+            if rel == "" or rel.endswith("/"):
+                fid = await self._resolve_dir_fid_from(base_fid, rel.rstrip("/"))
+                return {"exists": True, "is_dir": True, "path": rel, "fid": fid}
+            parent_rel, name = (rel.rsplit("/", 1) if "/" in rel else ("", rel))
+            parent_fid = await self._resolve_dir_fid_from(base_fid, parent_rel)
+            it = await self._find_child(parent_fid, name)
+            if it:
+                return {"exists": True, "is_dir": it["is_dir"], "path": rel, "fid": it["fid"]}
+            return {"exists": False, "is_dir": None, "path": rel}
+        except FileNotFoundError:
+            return {"exists": False, "is_dir": None, "path": rel}
+
+    async def _resolve_target_fid(self, rel: str, *, base_fid: Optional[str] = None) -> str:
+        base = base_fid or self.root_fid
+        if rel == "" or rel.endswith("/"):
+            return await self._resolve_dir_fid_from(base, rel.rstrip("/"))
+        parent_rel, name = (rel.rsplit("/", 1) if "/" in rel else ("", rel))
+        parent_fid = await self._resolve_dir_fid_from(base, parent_rel)
+        it = await self._find_child(parent_fid, name)
+        if not it:
+            raise FileNotFoundError(rel)
+        return it["fid"]
+
+
+ADAPTER_TYPE = "Quark"
+
+CONFIG_SCHEMA = [
+    {"key": "cookie", "label": "Cookie", "type": "password", "required": True, "placeholder": "从 pan.quark.cn 复制"},
+    {"key": "root_fid", "label": "根 FID", "type": "string", "required": False, "default": "0"},
+    {"key": "use_transcoding_address", "label": "视频转码直链", "type": "boolean", "required": False, "default": False},
+    {"key": "only_list_video_file", "label": "仅列出视频文件", "type": "boolean", "required": False, "default": False},
+]
+
+def ADAPTER_FACTORY(rec: StorageAdapter) -> BaseAdapter:
+    return QuarkAdapter(rec)

services/adapters/registry.py

@@ -78,6 +78,31 @@ class RuntimeRegistry:
     def snapshot(self) -> Dict[int, BaseAdapter]:
         return dict(self._instances)
 
+    def remove(self, adapter_id: int):
+        """从缓存中移除一个适配器实例"""
+        if adapter_id in self._instances:
+            del self._instances[adapter_id]
+
+    async def upsert(self, rec: StorageAdapter):
+        """新增或更新一个适配器实例"""
+        if not rec.enabled:
+            self.remove(rec.id)
+            return
+        
+        factory = TYPE_MAP.get(rec.type)
+        if not factory:
+            discover_adapters()
+            factory = TYPE_MAP.get(rec.type)
+            if not factory:
+                return
+
+        try:
+            instance = factory(rec)
+            self._instances[rec.id] = instance
+        except Exception:
+            self.remove(rec.id)
+            pass
+
 
 runtime_registry = RuntimeRegistry()
 discover_adapters()

services/adapters/s3.py

@@ -0,0 +1,380 @@
+from __future__ import annotations
+import asyncio
+import mimetypes
+from datetime import datetime
+from typing import List, Dict, Tuple, AsyncIterator
+from urllib.parse import quote
+
+import aioboto3
+from botocore.exceptions import ClientError
+from fastapi import HTTPException
+from fastapi.responses import StreamingResponse
+from models import StorageAdapter
+from services.logging import LogService
+
+
+class S3Adapter:
+    """S3 兼容对象存储适配器"""
+
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        cfg = record.config
+        self.bucket_name = cfg.get("bucket_name")
+        self.aws_access_key_id = cfg.get("access_key_id")
+        self.aws_secret_access_key = cfg.get("secret_access_key")
+        self.region_name = cfg.get("region_name")
+        self.endpoint_url = cfg.get("endpoint_url")
+        self.root = cfg.get("root", "").strip("/")
+
+        if not all([self.bucket_name, self.aws_access_key_id, self.aws_secret_access_key]):
+            raise ValueError(
+                "S3 适配器需要 bucket_name, access_key_id, 和 secret_access_key")
+
+        self.session = aioboto3.Session(
+            aws_access_key_id=self.aws_access_key_id,
+            aws_secret_access_key=self.aws_secret_access_key,
+            region_name=self.region_name,
+        )
+
+    def get_effective_root(self, sub_path: str | None) -> str:
+        """获取 S3 中的有效根路径 (key prefix)"""
+        if sub_path:
+            return f"{self.root}/{sub_path.strip('/')}".strip("/")
+        return self.root
+
+    def _get_s3_key(self, rel_path: str) -> str:
+        """将相对路径转换为 S3 key"""
+        rel_path = rel_path.strip("/")
+        if self.root:
+            return f"{self.root}/{rel_path}"
+        return rel_path
+
+    def _get_client(self):
+        return self.session.client("s3", endpoint_url=self.endpoint_url)
+
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]:
+        prefix = self._get_s3_key(rel)
+        if prefix and not prefix.endswith("/"):
+            prefix += "/"
+
+        all_items = []
+
+        async with self._get_client() as s3:
+            paginator = s3.get_paginator("list_objects_v2")
+            async for result in paginator.paginate(Bucket=self.bucket_name, Prefix=prefix, Delimiter="/"):
+                # 添加子目录
+                for common_prefix in result.get("CommonPrefixes", []):
+                    dir_name = common_prefix.get(
+                        "Prefix").removeprefix(prefix).strip("/")
+                    if dir_name:
+                        all_items.append({
+                            "name": dir_name,
+                            "is_dir": True,
+                            "size": 0,
+                            "mtime": 0,
+                            "type": "dir",
+                        })
+
+                # 添加文件
+                for content in result.get("Contents", []):
+                    file_key = content.get("Key")
+                    if file_key == prefix:  # 忽略目录本身
+                        continue
+                    file_name = file_key.removeprefix(prefix)
+                    if file_name:
+                        all_items.append({
+                            "name": file_name,
+                            "is_dir": False,
+                            "size": content.get("Size", 0),
+                            "mtime": int(content.get("LastModified", datetime.now()).timestamp()),
+                            "type": "file",
+                        })
+
+        # 在内存中排序和分页
+        reverse = sort_order.lower() == "desc"
+        def get_sort_key(item):
+            key = (not item["is_dir"],)
+            sort_field = sort_by.lower()
+            if sort_field == "name":
+                key += (item["name"].lower(),)
+            elif sort_field == "size":
+                key += (item["size"],)
+            elif sort_field == "mtime":
+                key += (item["mtime"],)
+            else:
+                key += (item["name"].lower(),)
+            return key
+        all_items.sort(key=get_sort_key, reverse=reverse)
+        
+        total_count = len(all_items)
+        start_idx = (page_num - 1) * page_size
+        end_idx = start_idx + page_size
+
+        return all_items[start_idx:end_idx], total_count
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        key = self._get_s3_key(rel)
+        async with self._get_client() as s3:
+            try:
+                resp = await s3.get_object(Bucket=self.bucket_name, Key=key)
+                return await resp["Body"].read()
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "NoSuchKey":
+                    raise FileNotFoundError(rel)
+                raise
+
+    async def write_file(self, root: str, rel: str, data: bytes):
+        key = self._get_s3_key(rel)
+        async with self._get_client() as s3:
+            await s3.put_object(Bucket=self.bucket_name, Key=key, Body=data)
+            await LogService.info(
+                "adapter:s3", f"Wrote file to {rel}",
+                details={"adapter_id": self.record.id,
+                         "bucket": self.bucket_name, "key": key, "size": len(data)}
+            )
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        key = self._get_s3_key(rel)
+        MIN_PART_SIZE = 5 * 1024 * 1024
+        
+        async with self._get_client() as s3:
+            mpu = await s3.create_multipart_upload(Bucket=self.bucket_name, Key=key)
+            upload_id = mpu['UploadId']
+            
+            parts = []
+            part_number = 1
+            total_size = 0
+            buffer = bytearray()
+            
+            try:
+                async for chunk in data_iter:
+                    if not chunk:
+                        continue
+                    buffer.extend(chunk)
+                    
+                    while len(buffer) >= MIN_PART_SIZE:
+                        part_data = buffer[:MIN_PART_SIZE]
+                        del buffer[:MIN_PART_SIZE]
+                        
+                        part = await s3.upload_part(
+                            Bucket=self.bucket_name,
+                            Key=key,
+                            PartNumber=part_number,
+                            UploadId=upload_id,
+                            Body=part_data
+                        )
+                        
+                        parts.append({'PartNumber': part_number, 'ETag': part['ETag']})
+                        total_size += len(part_data)
+                        part_number += 1
+
+                if buffer:
+                    part = await s3.upload_part(
+                        Bucket=self.bucket_name,
+                        Key=key,
+                        PartNumber=part_number,
+                        UploadId=upload_id,
+                        Body=bytes(buffer)
+                    )
+                    parts.append({'PartNumber': part_number, 'ETag': part['ETag']})
+                    total_size += len(buffer)
+                
+                await s3.complete_multipart_upload(
+                    Bucket=self.bucket_name,
+                    Key=key,
+                    UploadId=upload_id,
+                    MultipartUpload={'Parts': parts}
+                )
+            except Exception as e:
+                await s3.abort_multipart_upload(
+                    Bucket=self.bucket_name,
+                    Key=key,
+                    UploadId=upload_id
+                )
+                raise IOError(f"S3 stream upload failed: {e}") from e
+
+        await LogService.info(
+            "adapter:s3", f"Wrote file stream to {rel}",
+            details={"adapter_id": self.record.id, "bucket": self.bucket_name, "key": key, "size": total_size}
+        )
+        return total_size
+
+    async def mkdir(self, root: str, rel: str):
+        key = self._get_s3_key(rel)
+        if not key.endswith("/"):
+            key += "/"
+        async with self._get_client() as s3:
+            await s3.put_object(Bucket=self.bucket_name, Key=key, Body=b"")
+            await LogService.info(
+                "adapter:s3", f"Created directory {rel}",
+                details={"adapter_id": self.record.id,
+                         "bucket": self.bucket_name, "key": key}
+            )
+
+    async def delete(self, root: str, rel: str):
+        key = self._get_s3_key(rel)
+        async with self._get_client() as s3:
+            is_dir_like = False
+            try:
+                head = await s3.head_object(Bucket=self.bucket_name, Key=key)
+                if head['ContentLength'] == 0 and key.endswith('/'):
+                    is_dir_like = True
+            except ClientError as e:
+                if e.response['Error']['Code'] != '404': 
+                    raise
+
+            # 如果是目录，删除目录下的所有对象
+            if is_dir_like or not await self.stat_file(root, rel):  
+                dir_key = key if key.endswith('/') else key + '/'
+                paginator = s3.get_paginator("list_objects_v2")
+                objects_to_delete = []
+                async for result in paginator.paginate(Bucket=self.bucket_name, Prefix=dir_key):
+                    for content in result.get("Contents", []):
+                        objects_to_delete.append({"Key": content["Key"]})
+                if objects_to_delete:
+                    await s3.delete_objects(Bucket=self.bucket_name, Delete={"Objects": objects_to_delete})
+            # 如果是文件，直接删除
+            else:
+                await s3.delete_object(Bucket=self.bucket_name, Key=key)
+
+            await LogService.info(
+                "adapter:s3", f"Deleted {rel}",
+                details={"adapter_id": self.record.id,
+                         "bucket": self.bucket_name, "key": key}
+            )
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        await self.copy(root, src_rel, dst_rel, overwrite=True)
+        await self.delete(root, src_rel)
+        await LogService.info(
+            "adapter:s3", f"Moved {src_rel} to {dst_rel}",
+            details={"adapter_id": self.record.id, "bucket": self.bucket_name,
+                     "src_key": self._get_s3_key(src_rel), "dst_key": self._get_s3_key(dst_rel)}
+        )
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        await self.move(root, src_rel, dst_rel)
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        src_key = self._get_s3_key(src_rel)
+        dst_key = self._get_s3_key(dst_rel)
+
+        async with self._get_client() as s3:
+            if not overwrite:
+                try:
+                    await s3.head_object(Bucket=self.bucket_name, Key=dst_key)
+                    raise FileExistsError(dst_rel)
+                except ClientError as e:
+                    if e.response["Error"]["Code"] != "404":
+                        raise
+
+            copy_source = {"Bucket": self.bucket_name, "Key": src_key}
+            await s3.copy_object(CopySource=copy_source, Bucket=self.bucket_name, Key=dst_key)
+            await LogService.info(
+                "adapter:s3", f"Copied {src_rel} to {dst_rel}",
+                details={"adapter_id": self.record.id, "bucket": self.bucket_name,
+                         "src_key": src_key, "dst_key": dst_key}
+            )
+
+    async def stat_file(self, root: str, rel: str):
+        key = self._get_s3_key(rel)
+        async with self._get_client() as s3:
+            try:
+                head = await s3.head_object(Bucket=self.bucket_name, Key=key)
+                return {
+                    "name": rel.split("/")[-1],
+                    "is_dir": False,
+                    "size": head["ContentLength"],
+                    "mtime": int(head["LastModified"].timestamp()),
+                    "type": "file",
+                }
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "404":
+                    # 检查是否为一个 "目录"
+                    dir_key = key if key.endswith('/') else key + '/'
+                    resp = await s3.list_objects_v2(Bucket=self.bucket_name, Prefix=dir_key, MaxKeys=1)
+                    if resp.get('KeyCount', 0) > 0:
+                        return {
+                            "name": rel.split("/")[-1],
+                            "is_dir": True,
+                            "size": 0,
+                            "mtime": 0, 
+                            "type": "dir",
+                        }
+                    raise FileNotFoundError(rel)
+                raise
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        key = self._get_s3_key(rel)
+        async with self._get_client() as s3:
+            try:
+                head = await s3.head_object(Bucket=self.bucket_name, Key=key)
+                file_size = head["ContentLength"]
+                content_type = head.get("ContentType", mimetypes.guess_type(key)[
+                                        0] or "application/octet-stream")
+            except ClientError as e:
+                if e.response["Error"]["Code"] == "404":
+                    raise HTTPException(
+                        status_code=404, detail="File not found")
+                raise
+
+            start = 0
+            end = file_size - 1
+            status = 200
+            headers = {
+                "Accept-Ranges": "bytes",
+                "Content-Type": content_type,
+                "Content-Length": str(file_size),
+                "Content-Disposition": f"inline; filename=\"{quote(rel.split('/')[-1])}\""
+            }
+
+            if range_header:
+                range_val = range_header.strip().partition("=")[2]
+                s, _, e = range_val.partition("-")
+                try:
+                    start = int(s) if s else 0
+                    end = int(e) if e else file_size - 1
+                    if start >= file_size or end >= file_size or start > end:
+                        raise HTTPException(
+                            status_code=416, detail="Requested Range Not Satisfiable")
+                    status = 206
+                    headers["Content-Length"] = str(end - start + 1)
+                    headers["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+                except ValueError:
+                    raise HTTPException(
+                        status_code=400, detail="Invalid Range header")
+
+            range_arg = f"bytes={start}-{end}"
+
+            async def iterator():
+                try:
+                    resp = await s3.get_object(Bucket=self.bucket_name, Key=key, Range=range_arg)
+                    body = resp["Body"]
+                    while chunk := await body.read(65536):
+                        yield chunk
+                except Exception as e:
+                    LogService.error(
+                        "adapter:s3", f"Error streaming file {key}: {e}")
+
+        return StreamingResponse(iterator(), status_code=status, headers=headers, media_type=content_type)
+
+
+ADAPTER_TYPE = "S3"
+
+CONFIG_SCHEMA = [
+    {"key": "bucket_name", "label": "Bucket 名称",
+        "type": "string", "required": True},
+    {"key": "access_key_id", "label": "Access Key ID",
+        "type": "string", "required": True},
+    {"key": "secret_access_key", "label": "Secret Access Key",
+        "type": "password", "required": True},
+    {"key": "region_name", "label": "区域 (Region)", "type": "string",
+     "required": False, "placeholder": "例如 us-east-1"},
+    {"key": "endpoint_url", "label": "Endpoint URL", "type": "string",
+        "required": False, "placeholder": "对于 S3 兼容存储, 例如 https://minio.example.com"},
+    {"key": "root", "label": "根路径 (Root Path)", "type": "string",
+     "required": False, "placeholder": "在 bucket 内的路径前缀"},
+]
+
+
+def ADAPTER_FACTORY(rec): return S3Adapter(rec)

services/adapters/sftp.py

@@ -0,0 +1,447 @@
+from __future__ import annotations
+
+import asyncio
+import mimetypes
+import stat as statmod
+from typing import List, Dict, Tuple, AsyncIterator, Optional
+
+from fastapi import HTTPException
+from fastapi.responses import StreamingResponse
+import paramiko
+
+from models import StorageAdapter
+from services.logging import LogService
+
+
+def _join_remote(root: str, rel: str) -> str:
+    root = (root or "/").rstrip("/") or "/"
+    rel = (rel or "").lstrip("/")
+    if not rel:
+        return root
+    return f"{root}/{rel}"
+
+
+class SFTPAdapter:
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        cfg = record.config
+        self.host: str = cfg.get("host")
+        self.port: int = int(cfg.get("port", 22))
+        self.username: str | None = cfg.get("username")
+        self.password: str | None = cfg.get("password")
+        self.timeout: int = int(cfg.get("timeout", 15))
+        self.root_path: str = cfg.get("root")  # 必填
+        self.allow_unknown_host: bool = bool(cfg.get("allow_unknown_host", True))
+
+        if not self.host:
+            raise ValueError("SFTP adapter requires 'host'")
+        if not self.username or not self.password:
+            raise ValueError("SFTP adapter requires 'username' and 'password'")
+        if not self.root_path:
+            raise ValueError("SFTP adapter requires 'root'")
+
+    def get_effective_root(self, sub_path: str | None) -> str:
+        base = self.root_path.rstrip("/") or "/"
+        if sub_path:
+            return _join_remote(base, sub_path)
+        return base
+
+    def _connect(self) -> paramiko.SFTPClient:
+        ssh = paramiko.SSHClient()
+        if self.allow_unknown_host:
+            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        ssh.connect(
+            hostname=self.host,
+            port=self.port,
+            username=self.username,
+            password=self.password,
+            timeout=self.timeout,
+            allow_agent=False,
+            look_for_keys=False,
+        )
+        return ssh.open_sftp()
+
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]:
+        path = _join_remote(root, rel)
+
+        def _do_list() -> List[Dict]:
+            sftp = self._connect()
+            try:
+                attrs = sftp.listdir_attr(path)
+                entries: List[Dict] = []
+                for a in attrs:
+                    name = a.filename
+                    is_dir = statmod.S_ISDIR(a.st_mode)
+                    entries.append({
+                        "name": name,
+                        "is_dir": is_dir,
+                        "size": 0 if is_dir else int(a.st_size or 0),
+                        "mtime": int(a.st_mtime or 0),
+                        "type": "dir" if is_dir else "file",
+                    })
+                return entries
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        entries = await asyncio.to_thread(_do_list)
+
+        reverse = sort_order.lower() == "desc"
+
+        def get_sort_key(item):
+            key = (not item["is_dir"],)
+            f = sort_by.lower()
+            if f == "name":
+                key += (item["name"].lower(),)
+            elif f == "size":
+                key += (item.get("size", 0),)
+            elif f == "mtime":
+                key += (item.get("mtime", 0),)
+            else:
+                key += (item["name"].lower(),)
+            return key
+
+        entries.sort(key=get_sort_key, reverse=reverse)
+        total = len(entries)
+        start = (page_num - 1) * page_size
+        end = start + page_size
+        return entries[start:end], total
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        path = _join_remote(root, rel)
+
+        def _do_read() -> bytes:
+            sftp = self._connect()
+            try:
+                with sftp.open(path, "rb") as f:
+                    return f.read()
+            except FileNotFoundError:
+                raise
+            except IOError as e:
+                if getattr(e, "errno", None) == 2:
+                    raise FileNotFoundError(rel)
+                raise
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        return await asyncio.to_thread(_do_read)
+
+    async def write_file(self, root: str, rel: str, data: bytes):
+        path = _join_remote(root, rel)
+
+        def _ensure_dirs(sftp: paramiko.SFTPClient, dir_path: str):
+            parts = [p for p in dir_path.strip("/").split("/") if p]
+            cur = "/"
+            for p in parts:
+                cur = _join_remote(cur, p)
+                try:
+                    sftp.mkdir(cur)
+                except IOError:
+                    # likely exists
+                    pass
+
+        def _do_write():
+            sftp = self._connect()
+            try:
+                parent = "/" if "/" not in path.strip("/") else path.rsplit("/", 1)[0]
+                _ensure_dirs(sftp, parent)
+                with sftp.open(path, "wb") as f:
+                    f.write(data)
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_write)
+        await LogService.info("adapter:sftp", f"Wrote file to {rel}", details={"adapter_id": self.record.id, "path": path, "size": len(data)})
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        buf = bytearray()
+        async for chunk in data_iter:
+            if chunk:
+                buf.extend(chunk)
+        await self.write_file(root, rel, bytes(buf))
+        return len(buf)
+
+    async def mkdir(self, root: str, rel: str):
+        path = _join_remote(root, rel)
+
+        def _do_mkdir():
+            sftp = self._connect()
+            try:
+                parts = [p for p in path.strip("/").split("/") if p]
+                cur = "/"
+                for p in parts:
+                    cur = _join_remote(cur, p)
+                    try:
+                        sftp.mkdir(cur)
+                    except IOError:
+                        pass
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_mkdir)
+        await LogService.info("adapter:sftp", f"Created directory {rel}", details={"adapter_id": self.record.id, "path": path})
+
+    async def delete(self, root: str, rel: str):
+        path = _join_remote(root, rel)
+
+        def _do_delete():
+            sftp = self._connect()
+            try:
+                # Try file remove first
+                try:
+                    sftp.remove(path)
+                    return
+                except IOError:
+                    pass
+
+                def _rm_tree(dp: str):
+                    try:
+                        for a in sftp.listdir_attr(dp):
+                            child = _join_remote(dp, a.filename)
+                            if statmod.S_ISDIR(a.st_mode):
+                                _rm_tree(child)
+                            else:
+                                try:
+                                    sftp.remove(child)
+                                except Exception:
+                                    pass
+                        sftp.rmdir(dp)
+                    except IOError:
+                        pass
+
+                _rm_tree(path)
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_delete)
+        await LogService.info("adapter:sftp", f"Deleted {rel}", details={"adapter_id": self.record.id, "path": path})
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        src = _join_remote(root, src_rel)
+        dst = _join_remote(root, dst_rel)
+
+        def _do_move():
+            sftp = self._connect()
+            try:
+                # ensure dst parent exists
+                parent = "/" if "/" not in dst.strip("/") else dst.rsplit("/", 1)[0]
+                parts = [p for p in parent.strip("/").split("/") if p]
+                cur = "/"
+                for p in parts:
+                    cur = _join_remote(cur, p)
+                    try:
+                        sftp.mkdir(cur)
+                    except IOError:
+                        pass
+                sftp.rename(src, dst)
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        await asyncio.to_thread(_do_move)
+        await LogService.info("adapter:sftp", f"Moved {src_rel} to {dst_rel}", details={"adapter_id": self.record.id, "src": src, "dst": dst})
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        await self.move(root, src_rel, dst_rel)
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        src = _join_remote(root, src_rel)
+        dst = _join_remote(root, dst_rel)
+
+        def _is_dir() -> bool:
+            sftp = self._connect()
+            try:
+                st = sftp.stat(src)
+                return statmod.S_ISDIR(st.st_mode)
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        if await asyncio.to_thread(_is_dir):
+            await self.mkdir(root, dst_rel)
+
+            children, _ = await self.list_dir(root, src_rel, page_num=1, page_size=10_000)
+            for ent in children:
+                child_src = f"{src_rel.rstrip('/')}/{ent['name']}"
+                child_dst = f"{dst_rel.rstrip('/')}/{ent['name']}"
+                await self.copy(root, child_src, child_dst, overwrite)
+            await LogService.info("adapter:sftp", f"Copied directory {src_rel} to {dst_rel}", details={"adapter_id": self.record.id, "src": src, "dst": dst})
+            return
+
+        # file copy
+        data = await self.read_file(root, src_rel)
+        if not overwrite:
+            try:
+                await self.stat_file(root, dst_rel)
+                raise FileExistsError(dst_rel)
+            except FileNotFoundError:
+                pass
+        await self.write_file(root, dst_rel, data)
+        await LogService.info("adapter:sftp", f"Copied {src_rel} to {dst_rel}", details={"adapter_id": self.record.id, "src": src, "dst": dst})
+
+    async def stat_file(self, root: str, rel: str):
+        path = _join_remote(root, rel)
+
+        def _do_stat():
+            sftp = self._connect()
+            try:
+                st = sftp.stat(path)
+                is_dir = statmod.S_ISDIR(st.st_mode)
+                info = {
+                    "name": rel.split("/")[-1],
+                    "is_dir": is_dir,
+                    "size": 0 if is_dir else int(st.st_size or 0),
+                    "mtime": int(st.st_mtime or 0),
+                    "type": "dir" if is_dir else "file",
+                    "path": path,
+                }
+                return info
+            except FileNotFoundError:
+                raise
+            except IOError as e:
+                if getattr(e, "errno", None) == 2:
+                    raise FileNotFoundError(rel)
+                raise
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        return await asyncio.to_thread(_do_stat)
+
+    async def exists(self, root: str, rel: str) -> bool:
+        try:
+            await self.stat_file(root, rel)
+            return True
+        except FileNotFoundError:
+            return False
+        except Exception:
+            return False
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        path = _join_remote(root, rel)
+
+        def _get_stat():
+            sftp = self._connect()
+            try:
+                st = sftp.stat(path)
+                return int(st.st_size or 0)
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        file_size = await asyncio.to_thread(_get_stat)
+        if file_size is None:
+            raise HTTPException(404, detail="File not found")
+
+        mime, _ = mimetypes.guess_type(rel)
+        content_type = mime or "application/octet-stream"
+
+        start = 0
+        end = file_size - 1
+        status = 200
+        headers = {
+            "Accept-Ranges": "bytes",
+            "Content-Type": content_type,
+            "Content-Length": str(file_size),
+        }
+
+        if range_header and range_header.startswith("bytes="):
+            try:
+                s, e = (range_header.removeprefix("bytes=").split("-", 1))
+                if s.strip():
+                    start = int(s)
+                if e.strip():
+                    end = int(e)
+                if start >= file_size:
+                    raise HTTPException(416, detail="Requested Range Not Satisfiable")
+                if end >= file_size:
+                    end = file_size - 1
+                status = 206
+                headers["Content-Length"] = str(end - start + 1)
+                headers["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+            except ValueError:
+                raise HTTPException(400, detail="Invalid Range header")
+
+        queue: asyncio.Queue[Optional[bytes]] = asyncio.Queue(maxsize=8)
+
+        def _worker():
+            sftp = self._connect()
+            try:
+                with sftp.open(path, "rb") as f:
+                    f.seek(start)
+                    remaining = end - start + 1
+                    chunk_size = 64 * 1024
+                    while remaining > 0:
+                        to_read = chunk_size if remaining > chunk_size else remaining
+                        data = f.read(to_read)
+                        if not data:
+                            break
+                        try:
+                            queue.put_nowait(data)
+                        except Exception:
+                            break
+                        remaining -= len(data)
+                try:
+                    queue.put_nowait(None)
+                except Exception:
+                    pass
+            finally:
+                try:
+                    sftp.close()
+                except Exception:
+                    pass
+
+        async def agen():
+            worker_fut = asyncio.to_thread(_worker)
+            try:
+                while True:
+                    chunk = await queue.get()
+                    if chunk is None:
+                        break
+                    yield chunk
+            finally:
+                try:
+                    await worker_fut
+                except Exception:
+                    pass
+
+        return StreamingResponse(agen(), status_code=status, headers=headers, media_type=content_type)
+
+
+ADAPTER_TYPE = "sftp"
+
+CONFIG_SCHEMA = [
+    {"key": "host", "label": "主机", "type": "string", "required": True, "placeholder": "sftp.example.com"},
+    {"key": "port", "label": "端口", "type": "number", "required": False, "default": 22},
+    {"key": "username", "label": "用户名", "type": "string", "required": True},
+    {"key": "password", "label": "密码", "type": "password", "required": True},
+    {"key": "root", "label": "根路径", "type": "string", "required": True, "placeholder": "/data"},
+    {"key": "timeout", "label": "超时(秒)", "type": "number", "required": False, "default": 15},
+    {"key": "allow_unknown_host", "label": "允许未知主机指纹", "type": "boolean", "required": False, "default": True},
+]
+
+
+def ADAPTER_FACTORY(rec: StorageAdapter):
+    return SFTPAdapter(rec)

services/adapters/telegram.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+from typing import List, Dict, Tuple, AsyncIterator
+import io
+import os
+from models import StorageAdapter
+from telethon import TelegramClient
+from telethon.sessions import StringSession
+import socks
+
+# 适配器类型标识
+ADAPTER_TYPE = "Telegram"
+
+# 适配器配置项定义
+CONFIG_SCHEMA = [
+    {"key": "api_id", "label": "API ID", "type": "string", "required": True, "help_text": "从 my.telegram.org 获取"},
+    {"key": "api_hash", "label": "API Hash", "type": "password", "required": True, "help_text": "从 my.telegram.org 获取"},
+    {"key": "session_string", "label": "Session String", "type": "password", "required": True, "help_text": "通过 generate_session.py 生成"},
+    {"key": "chat_id", "label": "Chat ID", "type": "string", "required": True, "placeholder": "频道/群组的ID或用户名, 例如: -100123456789 或 'channel_username'"},
+    {"key": "proxy_protocol", "label": "代理协议", "type": "string", "required": False, "placeholder": "例如: socks5, http"},
+    {"key": "proxy_host", "label": "代理主机", "type": "string", "required": False, "placeholder": "例如: 127.0.0.1"},
+    {"key": "proxy_port", "label": "代理端口", "type": "number", "required": False, "placeholder": "例如: 1080"},
+]
+
+class TelegramAdapter:
+    """Telegram 存储适配器 (使用用户 Session)"""
+
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        cfg = record.config
+        self.api_id = int(cfg.get("api_id"))
+        self.api_hash = cfg.get("api_hash")
+        self.session_string = cfg.get("session_string")
+        self.chat_id_str = cfg.get("chat_id")
+        
+        # 代理设置
+        self.proxy_protocol = cfg.get("proxy_protocol")
+        self.proxy_host = cfg.get("proxy_host")
+        self.proxy_port = cfg.get("proxy_port")
+        
+        self.proxy = None
+        if self.proxy_protocol and self.proxy_host and self.proxy_port:
+            proto_map = {
+                "socks5": socks.SOCKS5,
+                "http": socks.HTTP,
+            }
+            proxy_type = proto_map.get(self.proxy_protocol.lower())
+            if proxy_type:
+                self.proxy = (proxy_type, self.proxy_host, int(self.proxy_port))
+
+        try:
+            self.chat_id = int(self.chat_id_str)
+        except (ValueError, TypeError):
+            self.chat_id = self.chat_id_str
+
+        if not all([self.api_id, self.api_hash, self.session_string, self.chat_id]):
+            raise ValueError("Telegram 适配器需要 api_id, api_hash, session_string 和 chat_id")
+
+    def _get_client(self) -> TelegramClient:
+        """创建一个新的 TelegramClient 实例"""
+        return TelegramClient(StringSession(self.session_string), self.api_id, self.api_hash, proxy=self.proxy)
+
+    def get_effective_root(self, sub_path: str | None) -> str:
+        return ""
+
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]:
+        if rel:
+            return [], 0
+
+        client = self._get_client()
+        entries = []
+        try:
+            await client.connect()
+            messages = await client.get_messages(self.chat_id, limit=200)
+            for message in messages:
+                if not message:
+                    continue
+
+                media = message.document or message.video or message.photo
+                if not media:
+                    continue
+
+                file_meta = message.file
+                if not file_meta:
+                    continue
+
+                filename = file_meta.name
+                if not filename:
+                    if message.text and '.' in message.text and len(message.text) < 256 and '\n' not in message.text:
+                        filename = message.text
+                    else:
+                        filename = f"unknown_{message.id}"
+
+                size = file_meta.size
+                if size is None:
+                    # 兼容缺失 size 的情况
+                    if hasattr(media, "size") and media.size is not None:
+                        size = media.size
+                    elif message.photo and getattr(message.photo, "sizes", None):
+                        photo_size = message.photo.sizes[-1]
+                        size = getattr(photo_size, "size", 0) or 0
+                    else:
+                        size = 0
+
+                entries.append({
+                    "name": f"{message.id}_{filename}",
+                    "is_dir": False,
+                    "size": size,
+                    "mtime": int(message.date.timestamp()),
+                    "type": "file",
+                })
+        finally:
+            if client.is_connected():
+                await client.disconnect()
+
+        # 排序
+        reverse = sort_order.lower() == "desc"
+        def get_sort_key(item):
+            key = (not item["is_dir"],)
+            sort_field = sort_by.lower()
+            if sort_field == "name":
+                key += (item["name"].lower(),)
+            elif sort_field == "size":
+                key += (item["size"],)
+            elif sort_field == "mtime":
+                key += (item["mtime"],)
+            else:
+                key += (item["name"].lower(),)
+            return key
+        entries.sort(key=get_sort_key, reverse=reverse)
+        
+        total_count = len(entries)
+        
+        # 分页
+        start_idx = (page_num - 1) * page_size
+        end_idx = start_idx + page_size
+        page_entries = entries[start_idx:end_idx]
+        
+        return page_entries, total_count
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        try:
+            message_id_str, _ = rel.split('_', 1)
+            message_id = int(message_id_str)
+        except (ValueError, IndexError):
+            raise FileNotFoundError(f"无效的文件路径格式: {rel}")
+
+        client = self._get_client()
+        try:
+            await client.connect()
+            message = await client.get_messages(self.chat_id, ids=message_id)
+            if not message or not (message.document or message.video or message.photo):
+                raise FileNotFoundError(f"在频道 {self.chat_id} 中未找到消息ID为 {message_id} 的文件")
+            
+            file_bytes = await client.download_media(message, file=bytes)
+            return file_bytes
+        finally:
+            if client.is_connected():
+                await client.disconnect()
+
+    async def write_file(self, root: str, rel: str, data: bytes):
+        """将字节数据作为文件上传"""
+        client = self._get_client()
+        file_like = io.BytesIO(data)
+        file_like.name = os.path.basename(rel) or "file"
+
+        try:
+            await client.connect()
+            await client.send_file(self.chat_id, file_like, caption=file_like.name)
+        finally:
+            if client.is_connected():
+                await client.disconnect()
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        """以流式方式上传文件"""
+        client = self._get_client()
+        filename = os.path.basename(rel) or "file"
+        import tempfile
+        temp_dir = tempfile.gettempdir()
+        temp_path = os.path.join(temp_dir, filename)
+        
+        total_size = 0
+        try:
+            with open(temp_path, "wb") as f:
+                async for chunk in data_iter:
+                    if chunk:
+                        f.write(chunk)
+                        total_size += len(chunk)
+            
+            await client.connect()
+            await client.send_file(self.chat_id, temp_path, caption=filename)
+
+        finally:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+            if client.is_connected():
+                await client.disconnect()
+        return total_size
+
+    async def mkdir(self, root: str, rel: str):
+        raise NotImplementedError("Telegram 适配器不支持创建目录。")
+
+    async def delete(self, root: str, rel: str):
+        """删除一个文件 (即一条消息)"""
+        try:
+            message_id_str, _ = rel.split('_', 1)
+            message_id = int(message_id_str)
+        except (ValueError, IndexError):
+            raise FileNotFoundError(f"无效的文件路径格式，无法解析消息ID: {rel}")
+
+        client = self._get_client()
+        try:
+            await client.connect()
+            result = await client.delete_messages(self.chat_id, [message_id])
+            if not result or not result[0].pts:
+                 raise FileNotFoundError(f"在 {self.chat_id} 中删除消息 {message_id} 失败，可能消息不存在或无权限")
+        finally:
+            if client.is_connected():
+                await client.disconnect()
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        raise NotImplementedError("Telegram 适配器不支持移动。")
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        raise NotImplementedError("Telegram 适配器不支持重命名。")
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        raise NotImplementedError("Telegram 适配器不支持复制。")
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        from fastapi.responses import StreamingResponse
+        from fastapi import HTTPException
+
+        try:
+            message_id_str, _ = rel.split('_', 1)
+            message_id = int(message_id_str)
+        except (ValueError, IndexError):
+            raise HTTPException(status_code=400, detail=f"无效的文件路径格式: {rel}")
+
+        client = self._get_client()
+        
+        try:
+            await client.connect()
+            message = await client.get_messages(self.chat_id, ids=message_id)
+            media = message.document or message.video or message.photo
+            if not message or not media:
+                raise FileNotFoundError(f"在频道 {self.chat_id} 中未找到消息ID为 {message_id} 的文件")
+
+            file_meta = message.file
+            file_size = file_meta.size if file_meta and file_meta.size is not None else None
+            if file_size is None:
+                if hasattr(media, "size") and media.size is not None:
+                    file_size = media.size
+                elif message.photo and getattr(message.photo, "sizes", None):
+                    photo_size = message.photo.sizes[-1]
+                    file_size = getattr(photo_size, "size", 0) or 0
+                else:
+                    file_size = 0
+
+            mime_type = None
+            if file_meta and getattr(file_meta, "mime_type", None):
+                mime_type = file_meta.mime_type
+            if not mime_type:
+                if hasattr(media, "mime_type") and media.mime_type:
+                    mime_type = media.mime_type
+                elif message.photo:
+                    mime_type = "image/jpeg"
+                else:
+                    mime_type = "application/octet-stream"
+
+            start = 0
+            end = file_size - 1
+            status = 200
+            
+            headers = {
+                "Accept-Ranges": "bytes",
+                "Content-Type": mime_type,
+                "Content-Length": str(file_size),
+            }
+
+            if range_header:
+                try:
+                    range_val = range_header.strip().partition("=")[2]
+                    s, _, e = range_val.partition("-")
+                    start = int(s) if s else 0
+                    end = int(e) if e else file_size - 1
+                    if start >= file_size or end >= file_size or start > end:
+                        raise HTTPException(status_code=416, detail="Requested Range Not Satisfiable")
+                    status = 206
+                    headers["Content-Length"] = str(end - start + 1)
+                    headers["Content-Range"] = f"bytes {start}-{end}/{file_size}"
+                except ValueError:
+                    raise HTTPException(status_code=400, detail="Invalid Range header")
+
+            async def iterator():
+                try:
+                    limit = end - start + 1
+                    downloaded = 0
+                    
+                    async for chunk in client.iter_download(media, offset=start):
+                        if downloaded + len(chunk) > limit:
+                            yield chunk[:limit - downloaded]
+                            break
+                        yield chunk
+                        downloaded += len(chunk)
+                        if downloaded >= limit:
+                            break
+                finally:
+                    if client.is_connected():
+                        await client.disconnect()
+
+            return StreamingResponse(iterator(), status_code=status, headers=headers)
+
+        except FileNotFoundError as e:
+            if client.is_connected():
+                await client.disconnect()
+            raise HTTPException(status_code=404, detail=str(e))
+        except Exception as e:
+            if client.is_connected():
+                await client.disconnect()
+            raise HTTPException(status_code=500, detail=f"Streaming failed: {str(e)}")
+
+    async def stat_file(self, root: str, rel: str):
+        try:
+            message_id_str, filename = rel.split('_', 1)
+            message_id = int(message_id_str)
+        except (ValueError, IndexError):
+            raise FileNotFoundError(f"无效的文件路径格式: {rel}")
+
+        client = self._get_client()
+        try:
+            await client.connect()
+            message = await client.get_messages(self.chat_id, ids=message_id)
+            media = message.document or message.video or message.photo
+            if not message or not media:
+                raise FileNotFoundError(f"在频道 {self.chat_id} 中未找到消息ID为 {message_id} 的文件")
+
+            file_meta = message.file
+            size = file_meta.size if file_meta and file_meta.size is not None else None
+            if size is None:
+                if hasattr(media, "size") and media.size is not None:
+                    size = media.size
+                elif message.photo and getattr(message.photo, "sizes", None):
+                    photo_size = message.photo.sizes[-1]
+                    size = getattr(photo_size, "size", 0) or 0
+                else:
+                    size = 0
+
+            return {
+                "name": rel,
+                "is_dir": False,
+                "size": size,
+                "mtime": int(message.date.timestamp()),
+                "type": "file",
+            }
+        finally:
+            if client.is_connected():
+                await client.disconnect()
+
+def ADAPTER_FACTORY(rec: StorageAdapter) -> TelegramAdapter:
+    return TelegramAdapter(rec)

services/adapters/webdav.py

@@ -39,7 +39,7 @@ class WebDAVAdapter:
         rel = rel.strip('/')
         return self.base_url if not rel else urljoin(self.base_url, quote(rel) + ('/' if rel.endswith('/') else ''))
 
-    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50) -> Tuple[List[Dict], int]:
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50, sort_by: str = "name", sort_order: str = "asc") -> Tuple[List[Dict], int]:
         raw_url = self._build_url(rel)
         url = raw_url if raw_url.endswith('/') else raw_url + '/'
         depth = "1"
@@ -92,16 +92,39 @@ class WebDAVAdapter:
                 "d:collection", NS) is not None if rt_el is not None else href_path.endswith('/')
             size = int(
                 size_el.text) if size_el is not None and size_el.text and size_el.text.isdigit() else 0
+            
+            from email.utils import parsedate_to_datetime
+            mtime = 0
+            if lm_el is not None and lm_el.text:
+                try:
+                    mtime = int(parsedate_to_datetime(lm_el.text).timestamp())
+                except Exception:
+                    mtime = 0
+
             all_entries.append({
                 "name": name,
                 "is_dir": is_dir,
                 "size": 0 if is_dir else size,
-                "mtime": 0,
+                "mtime": mtime,
                 "type": "dir" if is_dir else "file",
             })
 
         # 排序所有条目
-        all_entries.sort(key=lambda x: (not x["is_dir"], x["name"].lower()))
+        reverse = sort_order.lower() == "desc"
+        def get_sort_key(item):
+            key = (not item["is_dir"],)
+            sort_field = sort_by.lower()
+            if sort_field == "name":
+                key += (item["name"].lower(),)
+            elif sort_field == "size":
+                key += (item["size"],)
+            elif sort_field == "mtime":
+                key += (item["mtime"],)
+            else:
+                key += (item["name"].lower(),)
+            return key
+        all_entries.sort(key=get_sort_key, reverse=reverse)
+        
         total_count = len(all_entries)
 
         # 应用分页

services/ai.py

@@ -1,64 +1,247 @@
+from __future__ import annotations
+
 import httpx
-from typing import List
-from services.config import ConfigCenter
+from typing import List, Sequence, Tuple
+
+from models.database import AIModel, AIProvider
+from services.ai_providers import AIProviderService
+
+
+provider_service = AIProviderService()
+
+
+class MissingModelError(RuntimeError):
+    pass
+
 
 async def describe_image_base64(base64_image: str, detail: str = "high") -> str:
     """
-    传入base64图片和文本提示，返回图片描述文本。
+    传入 base64 图片并返回描述文本。缺省时返回错误提示。
     """
-    OAI_API_URL = await ConfigCenter.get("AI_API_URL", "https://api.siliconflow.cn/v1/chat/completions")
-    VISION_MODEL = await ConfigCenter.get("AI_VISION_MODEL", "Qwen/Qwen2.5-VL-32B-Instruct")
-    API_KEY = await ConfigCenter.get("AI_API_KEY", "")
-    payload = {
-        "model": VISION_MODEL,
-        "messages": [
-            {"role": "user", "content": [
-                {
-                    "type": "image_url",
-                    "image_url": {
-                        "url": f"data:image/jpeg;base64,{base64_image}",
-                        "detail": detail
-                    }
-                },
-                {
-                    "type": "text",
-                    "text": "描述这个图片"
-                }
-            ]}
-        ]
-    }
-    headers = {
-        "Authorization": f"Bearer {API_KEY}",
-        "Content-Type": "application/json"
-    }
     try:
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            resp = await client.post(OAI_API_URL, headers=headers, json=payload)
-            resp.raise_for_status()
-            result = resp.json()
-            return result["choices"][0]["message"]["content"]
+        model, provider = await _require_model("vision")
+        if provider.api_format == "openai":
+            return await _describe_with_openai(provider, model, base64_image, detail)
+        return await _describe_with_gemini(provider, model, base64_image, detail)
+    except MissingModelError as exc:
+        return str(exc)
     except httpx.ReadTimeout:
         return "请求超时，请稍后重试。"
-    except Exception as e:
-        return f"请求失败: {str(e)}"
+    except Exception as exc:  # noqa: BLE001
+        return f"请求失败: {exc}"
+
 
 async def get_text_embedding(text: str) -> List[float]:
     """
-    传入文本，返回嵌入向量。
+    传入文本，返回嵌入向量。若未配置模型则抛出异常。
     """
-    OAI_API_URL = await ConfigCenter.get("AI_API_URL", "https://api.siliconflow.cn/v1/chat/completions")
-    EMBED_MODEL = await ConfigCenter.get("AI_EMBED_MODEL", "Qwen/Qwen3-Embedding-8B")
-    API_KEY = await ConfigCenter.get("AI_API_KEY", "")
+    model, provider = await _require_model("embedding")
+    if provider.api_format == "openai":
+        return await _embedding_with_openai(provider, model, text)
+    return await _embedding_with_gemini(provider, model, text)
+
+
+async def rerank_texts(query: str, documents: Sequence[str]) -> List[float]:
+    """调用重排序模型，为一组文档返回得分。未配置时返回空列表。"""
+    if not documents:
+        return []
+    try:
+        model, provider = await _require_model("rerank")
+    except MissingModelError:
+        return []
+
+    try:
+        if provider.api_format == "openai":
+            return await _rerank_with_openai(provider, model, query, documents)
+        return await _rerank_with_gemini(provider, model, query, documents)
+    except Exception:  # noqa: BLE001
+        return []
+
+
+async def _require_model(ability: str) -> Tuple[AIModel, AIProvider]:
+    model = await provider_service.get_default_model(ability)
+    if not model:
+        raise MissingModelError(f"未配置默认 {ability} 模型，请前往系统设置完成配置。")
+    provider = getattr(model, "provider", None)
+    if provider is None:
+        await model.fetch_related("provider")
+        provider = model.provider
+    if provider is None:
+        raise MissingModelError("模型缺少关联的提供商配置。")
+    if not provider.base_url:
+        raise MissingModelError("该提供商未设置 API 地址。")
+    return model, provider
+
+
+def _openai_endpoint(provider: AIProvider, path: str) -> str:
+    base = (provider.base_url or "").rstrip("/")
+    if not base:
+        raise MissingModelError("提供商 API 地址未配置。")
+    return f"{base}/{path.lstrip('/')}"
+
+
+def _openai_headers(provider: AIProvider) -> dict:
+    headers = {"Content-Type": "application/json"}
+    if provider.api_key:
+        headers["Authorization"] = f"Bearer {provider.api_key}"
+    return headers
+
+
+def _gemini_endpoint(provider: AIProvider, path: str) -> str:
+    base = (provider.base_url or "").rstrip("/")
+    if not base:
+        raise MissingModelError("提供商 API 地址未配置。")
+    url = f"{base}/{path.lstrip('/')}"
+    if provider.api_key:
+        connector = "&" if "?" in url else "?"
+        url = f"{url}{connector}key={provider.api_key}"
+    return url
+
+
+async def _describe_with_openai(provider: AIProvider, model: AIModel, base64_image: str, detail: str) -> str:
+    url = _openai_endpoint(provider, "/chat/completions")
     payload = {
-        "model": EMBED_MODEL,
-        "input": text
+        "model": model.name,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{base64_image}",
+                            "detail": detail,
+                        },
+                    },
+                    {"type": "text", "text": "描述这个图片"},
+                ],
+            }
+        ],
     }
-    headers = {
-        "Authorization": f"Bearer {API_KEY}",
-        "Content-Type": "application/json"
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(url, headers=_openai_headers(provider), json=payload)
+        response.raise_for_status()
+        body = response.json()
+        return body["choices"][0]["message"]["content"]
+
+
+async def _describe_with_gemini(provider: AIProvider, model: AIModel, base64_image: str, detail: str) -> str:
+    detail_text = f"描述这个图片，细节等级：{detail}"
+    model_name = model.name if model.name.startswith("models/") else f"models/{model.name}"
+    url = _gemini_endpoint(provider, f"{model_name}:generateContent")
+    payload = {
+        "contents": [
+            {
+                "role": "user",
+                "parts": [
+                    {
+                        "inline_data": {
+                            "mime_type": "image/jpeg",
+                            "data": base64_image,
+                        }
+                    },
+                    {"text": detail_text},
+                ],
+            }
+        ]
     }
-    async with httpx.AsyncClient() as client:
-        resp = await client.post(OAI_API_URL.replace("chat/completions", "embeddings"), headers=headers, json=payload)
-        resp.raise_for_status()
-        result = resp.json()
-        return result["data"][0]["embedding"]
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(url, json=payload)
+        response.raise_for_status()
+        body = response.json()
+        candidates = body.get("candidates") or []
+        if not candidates:
+            return ""
+        parts = candidates[0].get("content", {}).get("parts", [])
+        text_parts = [part.get("text") for part in parts if isinstance(part, dict) and part.get("text")]
+        return "\n".join(text_parts)
+
+
+async def _embedding_with_openai(provider: AIProvider, model: AIModel, text: str) -> List[float]:
+    url = _openai_endpoint(provider, "/embeddings")
+    payload = {
+        "model": model.name,
+        "input": text,
+    }
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(url, headers=_openai_headers(provider), json=payload)
+        response.raise_for_status()
+        body = response.json()
+        return body["data"][0]["embedding"]
+
+
+async def _embedding_with_gemini(provider: AIProvider, model: AIModel, text: str) -> List[float]:
+    model_name = model.name if model.name.startswith("models/") else f"models/{model.name}"
+    url = _gemini_endpoint(provider, f"{model_name}:embedContent")
+    payload = {
+        "model": model_name,
+        "content": {
+            "parts": [{"text": text}],
+        },
+    }
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(url, json=payload)
+        response.raise_for_status()
+        body = response.json()
+        embedding = body.get("embedding") or {}
+        return embedding.get("values") or []
+
+
+async def _rerank_with_openai(
+    provider: AIProvider,
+    model: AIModel,
+    query: str,
+    documents: Sequence[str],
+) -> List[float]:
+    url = _openai_endpoint(provider, "/rerank")
+    payload = {
+        "model": model.name,
+        "query": query,
+        "documents": [
+            {"id": str(idx), "text": content}
+            for idx, content in enumerate(documents)
+        ],
+    }
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(url, headers=_openai_headers(provider), json=payload)
+        response.raise_for_status()
+        body = response.json()
+        results = body.get("results") or body.get("data") or []
+        scores: List[float] = []
+        for item in results:
+            try:
+                scores.append(float(item.get("score", 0.0)))
+            except (TypeError, ValueError):
+                scores.append(0.0)
+        return scores
+
+
+async def _rerank_with_gemini(
+    provider: AIProvider,
+    model: AIModel,
+    query: str,
+    documents: Sequence[str],
+) -> List[float]:
+    model_name = model.name if model.name.startswith("models/") else f"models/{model.name}"
+    url = _gemini_endpoint(provider, f"{model_name}:rankContent")
+    payload = {
+        "query": {"text": query},
+        "documents": [
+            {"id": str(idx), "content": {"parts": [{"text": content}]}}
+            for idx, content in enumerate(documents)
+        ],
+    }
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(url, json=payload)
+        response.raise_for_status()
+        body = response.json()
+
+    scores: List[float] = []
+    ranked = body.get("rankedDocuments") or body.get("results") or []
+    for item in ranked:
+        raw_score = item.get("relevanceScore") or item.get("score") or item.get("confidenceScore")
+        try:
+            scores.append(float(raw_score))
+        except (TypeError, ValueError):
+            scores.append(0.0)
+    return scores

services/ai_providers.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, Dict, List, Optional, Tuple
+
+import httpx
+from tortoise.exceptions import DoesNotExist
+from tortoise.transactions import in_transaction
+
+from models.database import AIDefaultModel, AIModel, AIProvider
+
+
+ABILITIES = ["chat", "vision", "embedding", "rerank", "voice", "tools"]
+
+OPENAI_EMBEDDING_DIMS = {
+    "text-embedding-3-large": 3072,
+    "text-embedding-3-small": 1536,
+    "text-embedding-ada-002": 1536,
+}
+
+
+def _normalize_embedding_dim(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    try:
+        casted = int(value)
+    except (TypeError, ValueError):
+        return None
+    return casted if casted > 0 else None
+
+
+def _apply_embedding_dim_to_metadata(
+    data: Dict[str, Any],
+    embedding_dim: Optional[int],
+    base_metadata: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    source = base_metadata if isinstance(base_metadata, dict) else {}
+    metadata: Dict[str, Any] = dict(source)
+    override = data.get("metadata")
+    if isinstance(override, dict) and override:
+        metadata.update(override)
+    if embedding_dim is None:
+        metadata.pop("embedding_dimensions", None)
+    else:
+        metadata["embedding_dimensions"] = embedding_dim
+    data["metadata"] = metadata or None
+    return data
+
+
+def normalize_capabilities(items: Optional[Iterable[str]]) -> List[str]:
+    if not items:
+        return []
+    normalized = []
+    for cap in items:
+        key = str(cap).strip().lower()
+        if key in ABILITIES and key not in normalized:
+            normalized.append(key)
+    return normalized
+
+
+def infer_openai_capabilities(model_id: str) -> Tuple[List[str], Optional[int]]:
+    lower = model_id.lower()
+    caps = set()
+
+    if any(keyword in lower for keyword in ["gpt", "chat", "turbo", "o1", "sonnet", "haiku", "thinking"]):
+        caps.update({"chat", "tools"})
+
+    if any(keyword in lower for keyword in ["vision", "gpt-4o", "gpt-4.1", "o1", "vision-preview", "omni"]):
+        caps.add("vision")
+
+    if any(keyword in lower for keyword in ["embed", "embedding"]):
+        caps.add("embedding")
+
+    if "rerank" in lower or "re-rank" in lower:
+        caps.add("rerank")
+
+    if any(keyword in lower for keyword in ["tts", "speech", "audio"]):
+        caps.add("voice")
+
+    embedding_dim = OPENAI_EMBEDDING_DIMS.get(model_id)
+    return normalize_capabilities(caps), embedding_dim
+
+
+def infer_gemini_capabilities(methods: Iterable[str]) -> List[str]:
+    caps = set()
+    for method in methods:
+        m = method.lower()
+        if m in {"generatecontent", "counttokens"}:
+            caps.update({"chat", "tools", "vision"})
+        if m == "embedcontent":
+            caps.add("embedding")
+        if m in {"generatespeech", "audiogeneration"}:
+            caps.add("voice")
+        if m == "rerank":
+            caps.add("rerank")
+    return normalize_capabilities(caps)
+
+
+def serialize_provider(provider: AIProvider) -> Dict[str, Any]:
+    return {
+        "id": provider.id,
+        "name": provider.name,
+        "identifier": provider.identifier,
+        "provider_type": provider.provider_type,
+        "api_format": provider.api_format,
+        "base_url": provider.base_url,
+        "api_key": provider.api_key,
+        "logo_url": provider.logo_url,
+        "extra_config": provider.extra_config or {},
+        "created_at": provider.created_at,
+        "updated_at": provider.updated_at,
+    }
+
+
+def model_to_dict(model: AIModel, provider: Optional[AIProvider] = None) -> Dict[str, Any]:
+    provider_obj = provider or getattr(model, "provider", None)
+    provider_data = serialize_provider(provider_obj) if provider_obj else None
+    return {
+        "id": model.id,
+        "provider_id": model.provider_id,
+        "name": model.name,
+        "display_name": model.display_name,
+        "description": model.description,
+        "capabilities": normalize_capabilities(model.capabilities),
+        "context_window": model.context_window,
+        "embedding_dimensions": model.embedding_dimensions,
+        "metadata": model.metadata or {},
+        "created_at": model.created_at,
+        "updated_at": model.updated_at,
+        "provider": provider_data,
+    }
+
+
+def provider_to_dict(provider: AIProvider, models: Optional[List[AIModel]] = None) -> Dict[str, Any]:
+    data = serialize_provider(provider)
+    if models is not None:
+        data["models"] = [model_to_dict(m, provider=provider) for m in models]
+    return data
+
+
+class AIProviderService:
+    async def list_providers(self) -> List[Dict[str, Any]]:
+        providers = await AIProvider.all().order_by("id").prefetch_related("models")
+        return [provider_to_dict(p, models=list(p.models)) for p in providers]
+
+    async def get_provider(self, provider_id: int, with_models: bool = False) -> Dict[str, Any]:
+        if with_models:
+            provider = await AIProvider.get(id=provider_id)
+            models = await provider.models.all()
+            return provider_to_dict(provider, models=models)
+        else:
+            provider = await AIProvider.get(id=provider_id)
+            return provider_to_dict(provider)
+
+    async def create_provider(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        data = payload.copy()
+        data.setdefault("extra_config", {})
+        provider = await AIProvider.create(**data)
+        return provider_to_dict(provider)
+
+    async def update_provider(self, provider_id: int, payload: Dict[str, Any]) -> Dict[str, Any]:
+        provider = await AIProvider.get(id=provider_id)
+        for field, value in payload.items():
+            setattr(provider, field, value)
+        await provider.save()
+        return provider_to_dict(provider)
+
+    async def delete_provider(self, provider_id: int) -> None:
+        await AIProvider.filter(id=provider_id).delete()
+
+    async def list_models(self, provider_id: int) -> List[Dict[str, Any]]:
+        models = await AIModel.filter(provider_id=provider_id).order_by("id").prefetch_related("provider")
+        return [model_to_dict(m) for m in models]
+
+    async def create_model(self, provider_id: int, payload: Dict[str, Any]) -> Dict[str, Any]:
+        data = payload.copy()
+        data["provider_id"] = provider_id
+        data["capabilities"] = normalize_capabilities(data.get("capabilities"))
+        embedding_dim = _normalize_embedding_dim(data.pop("embedding_dimensions", None))
+        data = _apply_embedding_dim_to_metadata(data, embedding_dim)
+        model = await AIModel.create(**data)
+        await model.fetch_related("provider")
+        return model_to_dict(model)
+
+    async def update_model(self, model_id: int, payload: Dict[str, Any]) -> Dict[str, Any]:
+        model = await AIModel.get(id=model_id)
+        data = payload.copy()
+        if "capabilities" in data:
+            data["capabilities"] = normalize_capabilities(data.get("capabilities"))
+        embedding_dim = None
+        if "embedding_dimensions" in data:
+            embedding_dim = _normalize_embedding_dim(data.pop("embedding_dimensions", None))
+            _apply_embedding_dim_to_metadata(data, embedding_dim, base_metadata=model.metadata)
+        for field, value in data.items():
+            setattr(model, field, value)
+        if embedding_dim is not None or ("embedding_dimensions" in payload and embedding_dim is None):
+            model.embedding_dimensions = embedding_dim
+        await model.save()
+        await model.fetch_related("provider")
+        return model_to_dict(model)
+
+    async def delete_model(self, model_id: int) -> None:
+        await AIModel.filter(id=model_id).delete()
+
+    async def fetch_remote_models(self, provider_id: int) -> List[Dict[str, Any]]:
+        provider = await AIProvider.get(id=provider_id)
+        return await self._get_remote_models(provider)
+
+    async def _get_remote_models(self, provider: AIProvider) -> List[Dict[str, Any]]:
+        if not provider.base_url:
+            raise ValueError("Provider base_url is required for syncing models")
+
+        fmt = (provider.api_format or "").lower()
+        if fmt not in {"openai", "gemini"}:
+            raise ValueError(f"Unsupported api_format '{provider.api_format}' for syncing models")
+
+        if fmt == "openai":
+            return await self._fetch_openai_models(provider)
+        return await self._fetch_gemini_models(provider)
+
+    async def sync_models(self, provider_id: int) -> Dict[str, int]:
+        provider = await AIProvider.get(id=provider_id)
+        remote_models = await self._get_remote_models(provider)
+
+        created = 0
+        updated = 0
+        for entry in remote_models:
+            defaults = entry.copy()
+            model_id = defaults.pop("name")
+            defaults["capabilities"] = normalize_capabilities(defaults.get("capabilities"))
+            embedding_dim = _normalize_embedding_dim(defaults.pop("embedding_dimensions", None))
+            defaults = _apply_embedding_dim_to_metadata(defaults, embedding_dim)
+            obj, is_created = await AIModel.get_or_create(
+                provider_id=provider.id,
+                name=model_id,
+                defaults=defaults,
+            )
+            if is_created:
+                created += 1
+                continue
+            for field, value in defaults.items():
+                setattr(obj, field, value)
+            if embedding_dim is not None or ("embedding_dimensions" in entry and embedding_dim is None):
+                obj.embedding_dimensions = embedding_dim
+            await obj.save()
+            updated += 1
+
+        return {"created": created, "updated": updated}
+
+    async def get_default_models(self) -> Dict[str, Optional[Dict[str, Any]]]:
+        defaults = await AIDefaultModel.all().prefetch_related("model__provider")
+        result: Dict[str, Optional[Dict[str, Any]]] = {ability: None for ability in ABILITIES}
+        for item in defaults:
+            result[item.ability] = model_to_dict(item.model, provider=item.model.provider)  # type: ignore[attr-defined]
+        return result
+
+    async def set_default_models(self, mapping: Dict[str, Optional[int]]) -> Dict[str, Optional[Dict[str, Any]]]:
+        normalized = {ability: mapping.get(ability) for ability in ABILITIES}
+        async with in_transaction() as connection:
+            for ability, model_id in normalized.items():
+                record = await AIDefaultModel.get_or_none(ability=ability)
+                if model_id:
+                    try:
+                        model = await AIModel.get(id=model_id)
+                    except DoesNotExist:
+                        raise ValueError(f"Model {model_id} not found")
+                    if record:
+                        record.model_id = model_id
+                        await record.save(using_db=connection)
+                    else:
+                        await AIDefaultModel.create(ability=ability, model_id=model_id)
+                elif record:
+                    await record.delete(using_db=connection)
+        return await self.get_default_models()
+
+    async def get_default_model(self, ability: str) -> Optional[AIModel]:
+        ability_key = ability.lower()
+        if ability_key not in ABILITIES:
+            return None
+        record = await AIDefaultModel.get_or_none(ability=ability_key)
+        if not record:
+            return None
+        model = await AIModel.get_or_none(id=record.model_id)
+        if model:
+            await model.fetch_related("provider")
+        return model
+
+    async def _fetch_openai_models(self, provider: AIProvider) -> List[Dict[str, Any]]:
+        base_url = provider.base_url.rstrip("/")
+        url = f"{base_url}/models"
+        headers = {}
+        if provider.api_key:
+            headers["Authorization"] = f"Bearer {provider.api_key}"
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(url, headers=headers)
+            response.raise_for_status()
+            payload = response.json()
+
+        data = payload.get("data", [])
+        entries: List[Dict[str, Any]] = []
+        for item in data:
+            model_id = item.get("id")
+            if not model_id:
+                continue
+            capabilities, embedding_dim = infer_openai_capabilities(model_id)
+            entries.append({
+                "name": model_id,
+                "display_name": item.get("display_name"),
+                "description": item.get("description"),
+                "capabilities": capabilities,
+                "context_window": item.get("context_window"),
+                "embedding_dimensions": embedding_dim,
+                "metadata": item,
+            })
+        return entries
+
+    async def _fetch_gemini_models(self, provider: AIProvider) -> List[Dict[str, Any]]:
+        base_url = provider.base_url.rstrip("/")
+        suffix = "/models"
+        if provider.api_key:
+            suffix += f"?key={provider.api_key}"
+        url = f"{base_url}{suffix}"
+
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            payload = response.json()
+
+        data = payload.get("models", [])
+        entries: List[Dict[str, Any]] = []
+        for item in data:
+            model_id = item.get("name")
+            if not model_id:
+                continue
+            methods = item.get("supportedGenerationMethods") or []
+            capabilities = infer_gemini_capabilities(methods)
+            entries.append({
+                "name": model_id,
+                "display_name": item.get("displayName"),
+                "description": item.get("description"),
+                "capabilities": capabilities,
+                "context_window": item.get("inputTokenLimit"),
+                "embedding_dimensions": item.get("embeddingDimensions"),
+                "metadata": item,
+            })
+        return entries

services/auth.py

@@ -1,5 +1,8 @@
+import asyncio
+from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from typing import Annotated
+import secrets
 
 import jwt
 from fastapi import Depends, HTTPException, status
@@ -10,9 +13,78 @@ from pydantic import BaseModel
 
 from models.database import UserAccount
 from services.config import ConfigCenter
+from services.logging import LogService
 
 ALGORITHM = "HS256"
 ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 365
+PASSWORD_RESET_TOKEN_EXPIRE_MINUTES = 10
+
+
+def _now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+@dataclass
+class PasswordResetEntry:
+    user_id: int
+    email: str
+    username: str
+    expires_at: datetime
+    used: bool = False
+
+
+class PasswordResetStore:
+    _tokens: dict[str, PasswordResetEntry] = {}
+    _lock = asyncio.Lock()
+
+    @classmethod
+    def _cleanup(cls):
+        now = _now()
+        for token, record in list(cls._tokens.items()):
+            if record.used or record.expires_at < now:
+                cls._tokens.pop(token, None)
+
+    @classmethod
+    async def create(cls, user: UserAccount) -> str:
+        async with cls._lock:
+            cls._cleanup()
+            for key, record in list(cls._tokens.items()):
+                if record.user_id == user.id:
+                    cls._tokens.pop(key, None)
+            token = secrets.token_urlsafe(32)
+            expires_at = _now() + timedelta(minutes=PASSWORD_RESET_TOKEN_EXPIRE_MINUTES)
+            cls._tokens[token] = PasswordResetEntry(
+                user_id=user.id,
+                email=user.email or "",
+                username=user.username,
+                expires_at=expires_at,
+            )
+            return token
+
+    @classmethod
+    async def get(cls, token: str) -> PasswordResetEntry | None:
+        async with cls._lock:
+            cls._cleanup()
+            record = cls._tokens.get(token)
+            if not record or record.used:
+                return None
+            return record
+
+    @classmethod
+    async def mark_used(cls, token: str) -> None:
+        async with cls._lock:
+            record = cls._tokens.get(token)
+            if record:
+                record.used = True
+            cls._cleanup()
+
+    @classmethod
+    async def invalidate_user(cls, user_id: int, except_token: str | None = None) -> None:
+        async with cls._lock:
+            for key, record in list(cls._tokens.items()):
+                if record.user_id == user_id and key != except_token:
+                    cls._tokens.pop(key, None)
+            cls._cleanup()
 
 
 async def get_secret_key():
@@ -132,6 +204,94 @@ async def create_access_token(data: dict, expires_delta: timedelta | None = None
     return encoded_jwt
 
 
+def _normalize_email(email: str | None) -> str:
+    return (email or "").strip().lower()
+
+
+async def _send_password_reset_email(user: UserAccount, token: str) -> None:
+    from services.email import EmailService
+
+    app_domain = await ConfigCenter.get("APP_DOMAIN", None)
+    base_url = (app_domain or "http://localhost:5173").rstrip("/")
+    reset_link = f"{base_url}/reset-password?token={token}"
+    await EmailService.enqueue_email(
+        recipients=[user.email],
+        subject="Foxel 密码重置",
+        template="password_reset",
+        context={
+            "username": user.username,
+            "reset_link": reset_link,
+            "expire_minutes": PASSWORD_RESET_TOKEN_EXPIRE_MINUTES,
+        },
+    )
+
+
+async def request_password_reset(email: str) -> bool:
+    normalized = _normalize_email(email)
+    if not normalized:
+        return False
+    user = await UserAccount.get_or_none(email=normalized)
+    if not user or not user.email:
+        return False
+
+    token = await PasswordResetStore.create(user)
+    try:
+        await _send_password_reset_email(user, token)
+    except Exception as exc:  # noqa: BLE001
+        await PasswordResetStore.mark_used(token)
+        await PasswordResetStore.invalidate_user(user.id)
+        await LogService.error(
+            "auth",
+            f"Failed to enqueue password reset email: {exc}",
+            details={"user_id": user.id},
+            user_id=user.id,
+        )
+        raise HTTPException(status_code=500, detail="邮件发送失败") from exc
+    await LogService.action(
+        "auth",
+        "Password reset requested",
+        details={"user_id": user.id},
+        user_id=user.id,
+    )
+    return True
+
+
+async def verify_password_reset_token(token: str) -> UserAccount:
+    record = await PasswordResetStore.get(token)
+    if not record:
+        raise HTTPException(status_code=400, detail="重置链接无效")
+    user = await UserAccount.get_or_none(id=record.user_id)
+    if not user:
+        raise HTTPException(status_code=400, detail="重置链接无效")
+    if record.expires_at < _now():
+        await PasswordResetStore.mark_used(token)
+        raise HTTPException(status_code=400, detail="重置链接已过期")
+    return user
+
+
+async def reset_password_with_token(token: str, new_password: str) -> None:
+    record = await PasswordResetStore.get(token)
+    if not record:
+        raise HTTPException(status_code=400, detail="重置链接无效")
+    if record.expires_at < _now():
+        await PasswordResetStore.mark_used(token)
+        raise HTTPException(status_code=400, detail="重置链接已过期")
+
+    user = await UserAccount.get_or_none(id=record.user_id)
+    if not user:
+        raise HTTPException(status_code=400, detail="重置链接无效")
+    user.hashed_password = get_password_hash(new_password)
+    await user.save(update_fields=["hashed_password"])
+    await PasswordResetStore.mark_used(token)
+    await PasswordResetStore.invalidate_user(user.id)
+    await LogService.action(
+        "auth",
+        "Password reset via email",
+        details={"user_id": user.id},
+        user_id=user.id,
+    )
+
+
 async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
     credentials_exception = HTTPException(
         status_code=status.HTTP_401_UNAUTHORIZED,

services/backup.py

@@ -1,7 +1,6 @@
 from tortoise.transactions import in_transaction
 from models.database import (
     StorageAdapter,
-    Mount,
     UserAccount,
     AutomationTask,
     ShareLink,
@@ -18,7 +17,6 @@ class BackupService:
         """
         async with in_transaction() as conn:
             adapters = await StorageAdapter.all().values()
-            mounts = await Mount.all().values()
             users = await UserAccount.all().values()
             tasks = await AutomationTask.all().values()
             shares = await ShareLink.all().values()
@@ -33,7 +31,6 @@ class BackupService:
         return {
             "version": VERSION,
             "storage_adapters": list(adapters),
-            "mounts": list(mounts),
             "user_accounts": list(users),
             "automation_tasks": list(tasks),
             "share_links": list(shares),
@@ -48,7 +45,6 @@ class BackupService:
         async with in_transaction() as conn:
             await ShareLink.all().using_db(conn).delete()
             await AutomationTask.all().using_db(conn).delete()
-            await Mount.all().using_db(conn).delete()
             await StorageAdapter.all().using_db(conn).delete()
             await UserAccount.all().using_db(conn).delete()
             await Configuration.all().using_db(conn).delete()
@@ -71,12 +67,6 @@ class BackupService:
                     using_db=conn
                 )
 
-            if data.get("mounts"):
-                await Mount.bulk_create(
-                    [Mount(**m) for m in data["mounts"]],
-                    using_db=conn
-                )
-
             if data.get("automation_tasks"):
                 await AutomationTask.bulk_create(
                     [AutomationTask(**t) for t in data["automation_tasks"]],

services/config.py

@@ -4,7 +4,7 @@ from typing import Any, Optional, Dict
 from dotenv import load_dotenv
 from models.database import Configuration
 load_dotenv(dotenv_path=".env")
-VERSION = "v1.0.0"
+VERSION = "v1.3.7"
 
 class ConfigCenter:
     _cache: Dict[str, Any] = {}

services/email.py

@@ -0,0 +1,201 @@
+import asyncio
+import json
+import re
+import smtplib
+from email.message import EmailMessage
+from email.utils import formataddr
+from enum import Enum
+from pathlib import Path
+from string import Template
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, EmailStr, Field, ValidationError
+
+from services.config import ConfigCenter
+from services.logging import LogService
+
+
+class EmailSecurity(str, Enum):
+    NONE = "none"
+    SSL = "ssl"
+    STARTTLS = "starttls"
+
+
+class EmailConfig(BaseModel):
+    host: str
+    port: int = Field(..., gt=0)
+    username: Optional[str] = None
+    password: Optional[str] = None
+    sender_email: EmailStr
+    sender_name: Optional[str] = None
+    security: EmailSecurity = EmailSecurity.NONE
+    timeout: float = Field(default=30.0, gt=0.0)
+
+
+class EmailSendPayload(BaseModel):
+    recipients: List[EmailStr] = Field(..., min_length=1)
+    subject: str = Field(..., min_length=1)
+    template: str = Field(..., min_length=1)
+    context: Dict[str, Any] = Field(default_factory=dict)
+
+
+class EmailTemplateRenderer:
+    ROOT = Path("templates/email")
+
+    @classmethod
+    def _resolve_path(cls, template_name: str) -> Path:
+        if not re.fullmatch(r"[A-Za-z0-9_\-]+", template_name):
+            raise ValueError("Invalid template name")
+        return cls.ROOT / f"{template_name}.html"
+
+    @classmethod
+    async def list_templates(cls) -> list[str]:
+        cls.ROOT.mkdir(parents=True, exist_ok=True)
+        return sorted(
+            path.stem
+            for path in cls.ROOT.glob("*.html")
+            if path.is_file()
+        )
+
+    @classmethod
+    async def load(cls, template_name: str) -> str:
+        path = cls._resolve_path(template_name)
+        if not path.is_file():
+            raise FileNotFoundError(f"Email template '{template_name}' not found")
+        return await asyncio.to_thread(path.read_text, encoding="utf-8")
+
+    @classmethod
+    async def save(cls, template_name: str, content: str) -> None:
+        path = cls._resolve_path(template_name)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        await asyncio.to_thread(path.write_text, content, encoding="utf-8")
+
+    @classmethod
+    async def render(cls, template_name: str, context: Dict[str, Any]) -> str:
+        raw = await cls.load(template_name)
+        context = {k: str(v) for k, v in (context or {}).items()}
+        return Template(raw).safe_substitute(context)
+
+
+class EmailService:
+    CONFIG_KEY = "EMAIL_CONFIG"
+
+    @classmethod
+    async def _load_config(cls) -> EmailConfig:
+        raw_config = await ConfigCenter.get(cls.CONFIG_KEY)
+        if raw_config is None:
+            raise ValueError("Email configuration not found")
+
+        if isinstance(raw_config, str):
+            raw_config = raw_config.strip()
+            data: Any = json.loads(raw_config) if raw_config else {}
+        elif isinstance(raw_config, dict):
+            data = raw_config
+        else:
+            raise ValueError("Invalid email configuration format")
+
+        try:
+            return EmailConfig(**data)
+        except ValidationError as exc:
+            raise ValueError(f"Invalid email configuration: {exc}") from exc
+
+    @staticmethod
+    def _html_to_text(html: str) -> str:
+        stripped = re.sub(r"<[^>]+>", " ", html)
+        return " ".join(stripped.split())
+
+    @classmethod
+    async def _deliver(cls, config: EmailConfig, payload: EmailSendPayload, html_body: str):
+        message = EmailMessage()
+        message["Subject"] = payload.subject
+        message["From"] = formataddr((config.sender_name or str(config.sender_email), str(config.sender_email)))
+        message["To"] = ", ".join([str(addr) for addr in payload.recipients])
+
+        plain_body = cls._html_to_text(html_body)
+        message.set_content(plain_body or html_body)
+        message.add_alternative(html_body, subtype="html")
+
+        await asyncio.to_thread(cls._deliver_sync, config, message)
+
+    @staticmethod
+    def _deliver_sync(config: EmailConfig, message: EmailMessage):
+        if config.security == EmailSecurity.SSL:
+            smtp: smtplib.SMTP = smtplib.SMTP_SSL(config.host, config.port, timeout=config.timeout)
+        else:
+            smtp = smtplib.SMTP(config.host, config.port, timeout=config.timeout)
+
+        try:
+            if config.security == EmailSecurity.STARTTLS:
+                smtp.starttls()
+            if config.username and config.password:
+                smtp.login(config.username, config.password)
+            smtp.send_message(message)
+        finally:
+            try:
+                smtp.quit()
+            except Exception:
+                pass
+
+    @classmethod
+    async def enqueue_email(
+        cls,
+        recipients: List[str],
+        subject: str,
+        template: str,
+        context: Optional[Dict[str, Any]] = None,
+    ):
+        from services.task_queue import TaskProgress, task_queue_service
+
+        payload = EmailSendPayload(
+            recipients=recipients,
+            subject=subject,
+            template=template,
+            context=context or {},
+        )
+
+        task = await task_queue_service.add_task(
+            "send_email",
+            payload.model_dump(mode="json"),
+        )
+
+        await task_queue_service.update_progress(
+            task.id,
+            TaskProgress(stage="queued", percent=0.0, detail="Waiting to send"),
+        )
+        await LogService.action(
+            "email_service",
+            "Email task enqueued",
+            details={"task_id": task.id, "subject": subject, "template": template},
+        )
+        return task
+
+    @classmethod
+    async def send_from_task(cls, task_id: str, data: Dict[str, Any]):
+        from services.task_queue import TaskProgress, task_queue_service
+
+        payload = EmailSendPayload(**data)
+
+        await task_queue_service.update_progress(
+            task_id,
+            TaskProgress(stage="preparing", percent=10.0, detail="Rendering template"),
+        )
+
+        config = await cls._load_config()
+        html_body = await EmailTemplateRenderer.render(payload.template, payload.context)
+
+        await task_queue_service.update_progress(
+            task_id,
+            TaskProgress(stage="sending", percent=60.0, detail="Sending message"),
+        )
+
+        await cls._deliver(config, payload, html_body)
+
+        await task_queue_service.update_progress(
+            task_id,
+            TaskProgress(stage="completed", percent=100.0, detail="Email sent"),
+        )
+        await LogService.info(
+            "email_service",
+            "Email sent",
+            details={"task_id": task_id, "subject": payload.subject},
+        )

services/middleware/logging_middleware.py

@@ -5,11 +5,18 @@ from services.logging import LogService
 from models.database import UserAccount
 import jwt
 from jwt.exceptions import InvalidTokenError
-from services.auth import  ALGORITHM
+from services.auth import ALGORITHM
 from services.config import ConfigCenter
 
+
 class LoggingMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        path = request.url.path
+        method = request.method.upper()
+        if method == "GET":
+            if path == "/api/logs" or path == "/api/plugins" or path.startswith("/api/config"):
+                return await call_next(request)
+
         start_time = time.time()
         user_id = None
         if "authorization" in request.headers:
@@ -27,9 +34,9 @@ class LoggingMiddleware(BaseHTTPMiddleware):
                 pass
 
         response = await call_next(request)
-        
+
         process_time = (time.time() - start_time) * 1000
-        
+
         details = {
             "client_ip": request.client.host,
             "method": request.method,
@@ -38,9 +45,9 @@ class LoggingMiddleware(BaseHTTPMiddleware):
             "status_code": response.status_code,
             "process_time_ms": round(process_time, 2)
         }
-        
+
         message = f"{request.method} {request.url.path} - {response.status_code}"
-        
+
         await LogService.api(message, details, user_id)
-        
-        return response
+
+        return response

services/offline_download.py

@@ -0,0 +1,199 @@
+import os
+import time
+from pathlib import Path
+from typing import AsyncIterator
+
+import aiofiles
+import aiohttp
+from fastapi import HTTPException
+
+from services.logging import LogService
+from services.task_queue import Task, task_queue_service, TaskProgress
+from services.virtual_fs import write_file_stream, stat_file
+
+
+TEMP_ROOT = Path("data/tmp/offline_downloads")
+
+
+def _normalize_path(path: str) -> str:
+    if not path:
+        return "/"
+    if not path.startswith("/"):
+        path = "/" + path
+    if len(path) > 1 and path.endswith("/"):
+        path = path.rstrip("/")
+    return path or "/"
+
+
+async def _path_exists(full_path: str) -> bool:
+    try:
+        await stat_file(full_path)
+        return True
+    except FileNotFoundError:
+        return False
+    except HTTPException as exc:
+        if exc.status_code == 404:
+            return False
+        raise
+
+
+def _split_filename(filename: str) -> tuple[str, str]:
+    if not filename:
+        return "", ""
+    if filename.startswith('.') and filename.count('.') == 1:
+        return filename, ""
+    if '.' not in filename:
+        return filename, ""
+    stem, ext = filename.rsplit('.', 1)
+    return stem, f".{ext}"
+
+
+async def _allocate_destination(dest_dir: str, filename: str) -> tuple[str, str]:
+    dest_dir = _normalize_path(dest_dir)
+    stem, suffix = _split_filename(filename)
+    candidate = filename
+    if dest_dir == "/":
+        base = ""
+    else:
+        base = dest_dir
+    attempt = 0
+    while await _path_exists(f"{base}/{candidate}" if base else f"/{candidate}"):
+        attempt += 1
+        if stem:
+            candidate = f"{stem} ({attempt}){suffix}"
+        else:
+            candidate = f"file ({attempt}){suffix}" if suffix else f"file ({attempt})"
+    if base:
+        full_path = f"{base}/{candidate}"
+    else:
+        full_path = f"/{candidate}"
+    return full_path, candidate
+
+
+async def _iter_file(path: Path, chunk_size: int, report_cb) -> AsyncIterator[bytes]:
+    async with aiofiles.open(path, "rb") as f:
+        while True:
+            chunk = await f.read(chunk_size)
+            if not chunk:
+                break
+            await report_cb(len(chunk))
+            yield chunk
+
+
+async def run_http_download(task: Task):
+    params = task.task_info
+    url = params.get("url")
+    dest_dir = params.get("dest_dir")
+    filename = params.get("filename")
+
+    if not url or not dest_dir or not filename:
+        raise ValueError("Missing required parameters for offline download")
+
+    TEMP_ROOT.mkdir(parents=True, exist_ok=True)
+    temp_dir = TEMP_ROOT / task.id
+    temp_dir.mkdir(parents=True, exist_ok=True)
+    temp_file = temp_dir / "payload"
+
+    bytes_total: int | None = None
+    bytes_done = 0
+
+    last_update = time.monotonic()
+
+    await task_queue_service.update_progress(
+        task.id,
+        TaskProgress(
+            stage="downloading",
+            percent=0.0,
+            bytes_total=None,
+            bytes_done=0,
+            detail="HTTP downloading",
+        ),
+    )
+
+    async def report_download(delta: int, total: int | None):
+        nonlocal bytes_done, bytes_total, last_update
+        if total is not None:
+            bytes_total = total
+        bytes_done += delta
+        now = time.monotonic()
+        if delta and now - last_update < 0.5:
+            return
+        last_update = now
+        percent = None
+        total_for_display = bytes_total if bytes_total is not None else None
+        if bytes_total:
+            percent = min(100.0, round(bytes_done / bytes_total * 100, 2))
+        await task_queue_service.update_progress(
+            task.id,
+            TaskProgress(
+                stage="downloading",
+                percent=percent,
+                bytes_total=total_for_display,
+                bytes_done=bytes_done,
+                detail="HTTP downloading",
+            ),
+        )
+
+    timeout = aiohttp.ClientTimeout(total=None, connect=30)
+
+    async with aiohttp.ClientSession(timeout=timeout) as session:
+        async with session.get(url) as resp:
+            if resp.status != 200:
+                raise ValueError(f"HTTP {resp.status} for {url}")
+            content_length = resp.headers.get("Content-Length")
+            total_size = int(content_length) if content_length else None
+            bytes_done = 0
+            async with aiofiles.open(temp_file, "wb") as f:
+                async for chunk in resp.content.iter_chunked(512 * 1024):
+                    if not chunk:
+                        continue
+                    await f.write(chunk)
+                    await report_download(len(chunk), total_size)
+            # ensure final update
+            await report_download(0, total_size)
+
+    file_size = os.path.getsize(temp_file)
+
+    bytes_done_transfer = 0
+
+    async def report_transfer(delta: int):
+        nonlocal bytes_done_transfer
+        bytes_done_transfer += delta
+        percent = min(100.0, round(bytes_done_transfer / file_size * 100, 2)) if file_size else None
+        await task_queue_service.update_progress(
+            task.id,
+            TaskProgress(
+                stage="transferring",
+                percent=percent,
+                bytes_total=file_size or None,
+                bytes_done=bytes_done_transfer,
+                detail="Saving to storage",
+            ),
+        )
+
+    async def chunk_iter() -> AsyncIterator[bytes]:
+        async for chunk in _iter_file(temp_file, 512 * 1024, report_transfer):
+            yield chunk
+
+    final_path, resolved_name = await _allocate_destination(dest_dir, filename)
+
+    await task_queue_service.update_progress(
+        task.id,
+        TaskProgress(stage="transferring", percent=0.0, bytes_total=file_size or None, bytes_done=0, detail="Saving to storage"),
+    )
+
+    await write_file_stream(final_path, chunk_iter())
+
+    await task_queue_service.update_progress(
+        task.id,
+        TaskProgress(stage="completed", percent=100.0, bytes_total=file_size or None, bytes_done=file_size, detail="Completed"),
+    )
+    await task_queue_service.update_meta(task.id, {"final_path": final_path, "filename": resolved_name})
+
+    try:
+        os.remove(temp_file)
+        temp_dir.rmdir()
+    except Exception:
+        await LogService.info("offline_download", f"Temp cleanup failed for task {task.id}")
+
+    return final_path

services/processors/registry.py

@@ -1,33 +1,53 @@
-import pkgutil
 import inspect
-from importlib import import_module
-from typing import Dict, Callable
+import pkgutil
+from importlib import import_module, reload
+from pathlib import Path
+from types import ModuleType
+from typing import Callable, Dict, Optional
+
 from .base import BaseProcessor
 
 ProcessorFactory = Callable[[], BaseProcessor]
 TYPE_MAP: Dict[str, ProcessorFactory] = {}
 CONFIG_SCHEMAS: Dict[str, dict] = {}
+MODULE_MAP: Dict[str, ModuleType] = {}
+LAST_DISCOVERY_ERRORS: list[str] = []
+
+
+def discover_processors(force_reload: bool = False) -> list[str]:
+    """Discover available processor modules and cache their metadata."""
+    import services.processors  # 延迟导入以避免循环
 
-def discover_processors():
-    import services.processors
     processors_pkg = services.processors
     TYPE_MAP.clear()
     CONFIG_SCHEMAS.clear()
+    MODULE_MAP.clear()
+
+    global LAST_DISCOVERY_ERRORS
+    LAST_DISCOVERY_ERRORS = []
+
     for modinfo in pkgutil.iter_modules(processors_pkg.__path__):
         if modinfo.name.startswith("_"):
             continue
+
         full_name = f"{processors_pkg.__name__}.{modinfo.name}"
         try:
             module = import_module(full_name)
-        except Exception:
+            if force_reload:
+                module = reload(module)
+        except Exception as exc:
+            LAST_DISCOVERY_ERRORS.append(f"Failed to import {full_name}: {exc}")
             continue
+
         processor_type = getattr(module, "PROCESSOR_TYPE", None)
         processor_name = getattr(module, "PROCESSOR_NAME", None)
         supported_exts = getattr(module, "SUPPORTED_EXTS", None)
         schema = getattr(module, "CONFIG_SCHEMA", None)
         factory = getattr(module, "PROCESSOR_FACTORY", None)
+
         if not processor_type:
             continue
+
         if factory is None:
             for attr in module.__dict__.values():
                 if inspect.isclass(attr) and attr.__name__.endswith("Processor"):
@@ -35,31 +55,85 @@ def discover_processors():
                         return lambda: cls()
                     factory = _mk()
                     break
+
         if not callable(factory):
+            LAST_DISCOVERY_ERRORS.append(f"Processor {full_name} missing factory")
             continue
+
+        try:
+            sample = factory()
+        except Exception as exc:
+            LAST_DISCOVERY_ERRORS.append(f"Failed to instantiate processor {processor_type}: {exc}")
+            continue
+
         TYPE_MAP[processor_type] = factory
+        MODULE_MAP[processor_type] = module
+
         produces_file = getattr(module, "produces_file", None)
-        if produces_file is None and hasattr(factory(), "produces_file"):
-            produces_file = getattr(factory(), "produces_file")
+        if produces_file is None and hasattr(sample, "produces_file"):
+            produces_file = getattr(sample, "produces_file")
+
+        module_file = getattr(module, "__file__", None)
+        module_path: Optional[str] = None
+        if module_file:
+            try:
+                module_path = str(Path(module_file).resolve())
+            except Exception:
+                module_path = module_file
+
+        if isinstance(supported_exts, list):
+            normalized_exts = [str(ext) for ext in supported_exts]
+        elif supported_exts:
+            normalized_exts = [str(supported_exts)]
+        else:
+            normalized_exts = []
+
+        if not normalized_exts and hasattr(sample, "supported_exts"):
+            sample_exts = getattr(sample, "supported_exts") or []
+            if isinstance(sample_exts, list):
+                normalized_exts = [str(ext) for ext in sample_exts]
+
         if isinstance(schema, list):
             CONFIG_SCHEMAS[processor_type] = {
                 "type": processor_type,
                 "name": processor_name or processor_type,
-                "supported_exts": supported_exts or [],
+                "supported_exts": normalized_exts,
                 "config_schema": schema,
-                "produces_file": produces_file if produces_file is not None else False
+                "produces_file": produces_file if produces_file is not None else False,
+                "module_path": module_path,
             }
 
+    return LAST_DISCOVERY_ERRORS
+
+
 def get_config_schemas() -> Dict[str, dict]:
     return CONFIG_SCHEMAS
 
+
 def get_config_schema(processor_type: str):
     return CONFIG_SCHEMAS.get(processor_type)
 
+
 def get(processor_type: str) -> BaseProcessor:
     factory = TYPE_MAP.get(processor_type)
     if factory:
         return factory()
     return None
 
+
+def get_module_path(processor_type: str) -> Optional[str]:
+    meta = CONFIG_SCHEMAS.get(processor_type)
+    if not meta:
+        return None
+    return meta.get("module_path")
+
+
+def get_last_discovery_errors() -> list[str]:
+    return LAST_DISCOVERY_ERRORS
+
+
+def reload_processors() -> list[str]:
+    return discover_processors(force_reload=True)
+
+
 discover_processors()

services/processors/vector_index.py

@@ -1,14 +1,95 @@
-from typing import Dict, Any
+from typing import Dict, Any, List, Tuple
 from fastapi.responses import Response
 import base64
-from services.ai import describe_image_base64, get_text_embedding
-from services.vector_db import VectorDBService
+import mimetypes
+import os
+from io import BytesIO
+
+from services.ai import describe_image_base64, get_text_embedding, provider_service
+from services.vector_db import VectorDBService, DEFAULT_VECTOR_DIMENSION
 from services.logging import LogService
+from PIL import Image
+
+
+
+CHUNK_SIZE = 800
+CHUNK_OVERLAP = 200
+MAX_IMAGE_EDGE = 1600
+JPEG_QUALITY = 85
+
+
+def _chunk_text(content: str, chunk_size: int = CHUNK_SIZE, overlap: int = CHUNK_OVERLAP) -> List[Tuple[int, str, int, int]]:
+    """按固定窗口拆分文本，返回(chunk_id, chunk_text, start, end)。"""
+    if chunk_size <= 0:
+        chunk_size = CHUNK_SIZE
+    if overlap >= chunk_size:
+        overlap = max(chunk_size // 4, 1)
+
+    chunks: List[Tuple[int, str, int, int]] = []
+    step = chunk_size - overlap
+    idx = 0
+    start = 0
+    length = len(content)
+
+    while start < length:
+        end = min(length, start + chunk_size)
+        chunk = content[start:end].strip()
+        if chunk:
+            chunks.append((idx, chunk, start, end))
+            idx += 1
+        if end >= length:
+            break
+        start += step
+    return chunks
+
+
+def _guess_mime(path: str) -> str:
+    mime, _ = mimetypes.guess_type(path)
+    return mime or "application/octet-stream"
+
+
+def _chunk_key(path: str, chunk_id: str) -> str:
+    return f"{path}#chunk={chunk_id}"
+
+
+def _compress_image_for_embedding(input_bytes: bytes) -> Tuple[bytes, Dict[str, Any] | None]:
+    """压缩图片，降低发送到视觉模型的体积。"""
+    if Image is None:
+        return input_bytes, None
+
+    try:
+        with Image.open(BytesIO(input_bytes)) as img:
+            img = img.convert("RGB")
+            width, height = img.size
+            longest_edge = max(width, height)
+            scale = 1.0
+            if longest_edge > MAX_IMAGE_EDGE:
+                scale = MAX_IMAGE_EDGE / float(longest_edge)
+                new_size = (max(int(width * scale), 1), max(int(height * scale), 1))
+                resample_mode = getattr(getattr(Image, "Resampling", Image), "LANCZOS")
+                img = img.resize(new_size, resample=resample_mode)
+
+            buffer = BytesIO()
+            img.save(buffer, format="JPEG", quality=JPEG_QUALITY, optimize=True)
+            compressed = buffer.getvalue()
+
+            if len(compressed) < len(input_bytes):
+                return compressed, {
+                    "original_bytes": len(input_bytes),
+                    "compressed_bytes": len(compressed),
+                    "scaled": scale < 1.0,
+                    "width": img.width,
+                    "height": img.height,
+                }
+    except Exception:  # pragma: no cover - 任意图像处理异常时回退
+        return input_bytes, None
+
+    return input_bytes, None
 
 
 class VectorIndexProcessor:
     name = "向量索引"
-    supported_exts = ["jpg", "jpeg", "png", "bmp", "txt", "md"]
+    supported_exts: List[str] = []  # 留空表示不限扩展名
     config_schema = [
         {
             "key": "action", "label": "操作", "type": "select", "required": True, "default": "create",
@@ -32,8 +113,9 @@ class VectorIndexProcessor:
         index_type = config.get("index_type", "vector")
         vector_db = VectorDBService()
         collection_name = "vector_collection"
+
         if action == "destroy":
-            vector_db.delete_vector(collection_name, path)
+            await vector_db.delete_vector(collection_name, path)
             await LogService.info(
                 "processor:vector_index",
                 f"Destroyed {index_type} index for {path}",
@@ -41,9 +123,19 @@ class VectorIndexProcessor:
             )
             return Response(content=f"文件 {path} 的 {index_type} 索引已销毁", media_type="text/plain")
 
-        if index_type == 'simple':
-            vector_db.ensure_collection(collection_name, vector=False)
-            vector_db.upsert_vector(collection_name, {'path': path})
+        mime_type = _guess_mime(path)
+
+        if index_type == "simple":
+            await vector_db.ensure_collection(collection_name, vector=False)
+            await vector_db.delete_vector(collection_name, path)
+            await vector_db.upsert_vector(collection_name, {
+                "path": path,
+                "source_path": path,
+                "chunk_id": "filename",
+                "mime": mime_type,
+                "type": "filename",
+                "name": os.path.basename(path),
+            })
             await LogService.info(
                 "processor:vector_index",
                 f"Created simple index for {path}",
@@ -52,35 +144,116 @@ class VectorIndexProcessor:
             return Response(content=f"文件 {path} 的普通索引已创建", media_type="text/plain")
 
         file_ext = path.split('.')[-1].lower()
-        description = ""
-        embedding = None
+        details: Dict[str, Any] = {"path": path, "action": "create", "index_type": "vector"}
+
+        embedding_model = await provider_service.get_default_model("embedding")
+        vector_dim = DEFAULT_VECTOR_DIMENSION
+        if embedding_model and getattr(embedding_model, "embedding_dimensions", None):
+            try:
+                vector_dim = int(embedding_model.embedding_dimensions)
+            except (TypeError, ValueError):
+                vector_dim = DEFAULT_VECTOR_DIMENSION
+            if vector_dim <= 0:
+                vector_dim = DEFAULT_VECTOR_DIMENSION
+
+        await vector_db.ensure_collection(collection_name, vector=True, dim=vector_dim)
+        await vector_db.delete_vector(collection_name, path)
 
         if file_ext in ["jpg", "jpeg", "png", "bmp"]:
-            base64_image = base64.b64encode(input_bytes).decode("utf-8")
+            processed_bytes, compression = _compress_image_for_embedding(input_bytes)
+            base64_image = base64.b64encode(processed_bytes).decode("utf-8")
             description = await describe_image_base64(base64_image)
             embedding = await get_text_embedding(description)
-            log_message = f"Indexed image {path}"
-            response_message = f"图片已索引，描述：{description}"
-        elif file_ext in ["txt", "md"]:
-            text = input_bytes.decode("utf-8")
-            embedding = await get_text_embedding(text)
-            description = text[:100] + "..." if len(text) > 100 else text
-            log_message = f"Indexed text file {path}"
-            response_message = f"文本文件已索引"
-        
-        if embedding is None:
-            return Response(content="不支持的文件类型", status_code=400)
+            image_mime = "image/jpeg" if compression else mime_type
+            await vector_db.upsert_vector(collection_name, {
+                "path": _chunk_key(path, "image"),
+                "source_path": path,
+                "chunk_id": "image",
+                "embedding": embedding,
+                "text": description,
+                "mime": image_mime,
+                "type": "image",
+            })
+            details["description"] = description
+            if compression:
+                details["image_compression"] = compression
+            await LogService.info(
+                "processor:vector_index",
+                f"Indexed image {path}",
+                details=details,
+            )
+            return Response(content=f"图片已索引，描述：{description}", media_type="text/plain")
 
-        vector_db.ensure_collection(collection_name, vector=True)
-        vector_db.upsert_vector(
-            collection_name, {'path': path, 'embedding': embedding})
-        
+        if file_ext in ["txt", "md"]:
+            try:
+                text = input_bytes.decode("utf-8")
+            except UnicodeDecodeError:
+                return Response(content="文本文件解码失败", status_code=400)
+
+            chunks = _chunk_text(text)
+            if not chunks:
+                await vector_db.upsert_vector(collection_name, {
+                    "path": _chunk_key(path, "0"),
+                    "source_path": path,
+                    "chunk_id": "0",
+                    "embedding": await get_text_embedding(text or path),
+                    "text": text,
+                    "mime": mime_type,
+                    "type": "text",
+                    "start_offset": 0,
+                    "end_offset": len(text),
+                })
+                details["chunks"] = 1
+                await LogService.info(
+                    "processor:vector_index",
+                    f"Indexed text file {path}",
+                    details=details,
+                )
+                return Response(content="文本文件已索引", media_type="text/plain")
+
+            chunk_count = 0
+            for chunk_id, chunk_text, start, end in chunks:
+                embedding = await get_text_embedding(chunk_text)
+                await vector_db.upsert_vector(collection_name, {
+                    "path": _chunk_key(path, str(chunk_id)),
+                    "source_path": path,
+                    "chunk_id": str(chunk_id),
+                    "embedding": embedding,
+                    "text": chunk_text,
+                    "mime": mime_type,
+                    "type": "text",
+                    "start_offset": start,
+                    "end_offset": end,
+                })
+                chunk_count += 1
+
+            details["chunks"] = chunk_count
+            sample = chunks[0][1]
+            details["sample"] = sample[:120]
+            await LogService.info(
+                "processor:vector_index",
+                f"Indexed text file {path}",
+                details=details,
+            )
+            return Response(content="文本文件已索引", media_type="text/plain")
+
+        # 其他类型暂未支持向量索引，回退为文件名索引
+        await vector_db.delete_vector(collection_name, path)
+        await vector_db.upsert_vector(collection_name, {
+            "path": _chunk_key(path, "fallback"),
+            "source_path": path,
+            "chunk_id": "filename",
+            "mime": mime_type,
+            "type": "filename",
+            "name": os.path.basename(path),
+            "embedding": [0.0] * vector_dim,
+        })
         await LogService.info(
             "processor:vector_index",
-            log_message,
-            details={"path": path, "description": description, "action": "create", "index_type": "vector"},
+            f"File type fallback to simple index for {path}",
+            details={"path": path, "action": "create", "index_type": "simple", "original_type": file_ext},
         )
-        return Response(content=response_message, media_type="text/plain")
+        return Response(content="暂不支持该类型的向量索引，已创建文件名索引", media_type="text/plain")
 
 
 PROCESSOR_TYPE = "vector_index"

services/share.py

@@ -90,6 +90,16 @@ class ShareService:
             raise HTTPException(status_code=404, detail="分享链接不存在")
         await share.delete()
 
+    @staticmethod
+    async def delete_expired_shares(user: UserAccount) -> int:
+        """
+        删除当前用户所有已过期的分享链接，返回删除数量。
+        条件：expires_at 非空 且 小于等于当前时间（UTC）。
+        """
+        now = datetime.now(timezone.utc)
+        deleted_count = await ShareLink.filter(user=user, expires_at__lte=now).delete()
+        return deleted_count
+
     @staticmethod
     async def get_shared_item_details(share: ShareLink, sub_path: str = ""):
         """
@@ -122,4 +132,4 @@ class ShareService:
             raise e
 
 
-share_service = ShareService()
+share_service = ShareService()

services/task_queue.py

@@ -0,0 +1,232 @@
+import asyncio
+from typing import Dict, Any
+from pydantic import BaseModel, Field
+import uuid
+from services.logging import LogService
+from enum import Enum
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+
+
+class TaskProgress(BaseModel):
+    stage: str | None = None
+    percent: float | None = None
+    bytes_total: int | None = None
+    bytes_done: int | None = None
+    detail: str | None = None
+
+
+class Task(BaseModel):
+    id: str = Field(default_factory=lambda: uuid.uuid4().hex)
+    name: str
+    status: TaskStatus = TaskStatus.PENDING
+    result: Any = None
+    error: str | None = None
+    task_info: Dict[str, Any] = {}
+    progress: TaskProgress | None = None
+    meta: Dict[str, Any] | None = None
+
+
+_SENTINEL = object()
+
+
+class TaskQueueService:
+    def __init__(self):
+        self._queue: asyncio.Queue[Task | object] = asyncio.Queue()
+        self._tasks: Dict[str, Task] = {}
+        self._worker_tasks: list[asyncio.Task] = []
+        self._concurrency: int = 1
+        self._worker_seq: int = 0
+
+    async def add_task(self, name: str, task_info: Dict[str, Any]) -> Task:
+        task = Task(name=name, task_info=task_info)
+        self._tasks[task.id] = task
+        await self._queue.put(task)
+        await LogService.info("task_queue", f"Task {name} ({task.id}) enqueued", {"task_id": task.id, "name": name})
+        return task
+
+    def get_task(self, task_id: str) -> Task | None:
+        return self._tasks.get(task_id)
+
+    def get_all_tasks(self) -> list[Task]:
+        return list(self._tasks.values())
+
+    async def update_progress(self, task_id: str, progress: TaskProgress | Dict[str, Any]):
+        task = self._tasks.get(task_id)
+        if not task:
+            return
+        if isinstance(progress, TaskProgress):
+            task.progress = progress
+        else:
+            task.progress = TaskProgress(**progress)
+
+    async def update_meta(self, task_id: str, meta: Dict[str, Any]):
+        task = self._tasks.get(task_id)
+        if not task:
+            return
+        task.meta = (task.meta or {}) | meta
+
+    async def _execute_task(self, task: Task):
+        from services.virtual_fs import process_file
+
+        task.status = TaskStatus.RUNNING
+        await LogService.info("task_queue", f"Task {task.name} ({task.id}) started", {"task_id": task.id, "name": task.name})
+
+        try:
+            if task.name == "process_file":
+                params = task.task_info
+                result = await process_file(
+                    path=params["path"],
+                    processor_type=params["processor_type"],
+                    config=params["config"],
+                    save_to=params.get("save_to"),
+                    overwrite=params.get("overwrite", False),
+                )
+                task.result = result
+            elif task.name == "automation_task" or self._is_processor_task(task.name):
+                from models.database import AutomationTask
+                from services.processors.registry import get as get_processor
+                from services.virtual_fs import read_file, write_file
+
+                params = task.task_info
+                auto_task = await AutomationTask.get(id=params["task_id"])
+                path = params["path"]
+
+                processor_type = auto_task.processor_type if task.name == "automation_task" else task.name
+                processor = get_processor(processor_type)
+                if not processor:
+                    raise ValueError(f"Processor {processor_type} not found for task {auto_task.id}")
+
+                if processor_type != auto_task.processor_type:
+                    await LogService.warning(
+                        "task_queue",
+                        "Processor type mismatch; falling back to stored type",
+                        {"task_id": auto_task.id, "expected": auto_task.processor_type, "got": processor_type},
+                    )
+                    processor_type = auto_task.processor_type
+                    processor = get_processor(processor_type)
+                    if not processor:
+                        raise ValueError(f"Processor {processor_type} not found for task {auto_task.id}")
+
+                file_content = await read_file(path)
+                result = await processor.process(file_content, path, auto_task.processor_config)
+                
+                save_to = auto_task.processor_config.get("save_to")
+                if save_to and getattr(processor, "produces_file", False):
+                    await write_file(save_to, result)
+                task.result = "Automation task completed"
+            elif task.name == "offline_http_download":
+                from services.offline_download import run_http_download
+
+                result_path = await run_http_download(task)
+                task.result = {"path": result_path}
+            elif task.name == "cross_mount_transfer":
+                from services.virtual_fs import run_cross_mount_transfer_task
+
+                result = await run_cross_mount_transfer_task(task)
+                task.result = result
+            elif task.name == "send_email":
+                from services.email import EmailService
+                await EmailService.send_from_task(task.id, task.task_info)
+                task.result = "Email sent"
+            else:
+                raise ValueError(f"Unknown task name: {task.name}")
+            
+            task.status = TaskStatus.SUCCESS
+            await LogService.info("task_queue", f"Task {task.name} ({task.id}) succeeded", {"task_id": task.id, "name": task.name})
+
+        except Exception as e:
+            task.status = TaskStatus.FAILED
+            task.error = str(e)
+            await LogService.error("task_queue", f"Task {task.name} ({task.id}) failed: {e}", {"task_id": task.id, "name": task.name})
+
+    def _cleanup_workers(self):
+        self._worker_tasks = [task for task in self._worker_tasks if not task.done()]
+
+    def _is_processor_task(self, task_name: str) -> bool:
+        try:
+            from services.processors.registry import get as get_processor
+
+            return get_processor(task_name) is not None
+        except Exception:
+            return False
+
+    async def _ensure_worker_count(self):
+        self._cleanup_workers()
+        current = len(self._worker_tasks)
+        if current < self._concurrency:
+            for _ in range(self._concurrency - current):
+                self._worker_seq += 1
+                worker_id = self._worker_seq
+                worker_task = asyncio.create_task(self._worker_loop(worker_id))
+                self._worker_tasks.append(worker_task)
+            await LogService.info("task_queue", "Task workers adjusted", {"active_workers": len(self._worker_tasks), "target": self._concurrency})
+        elif current > self._concurrency:
+            for _ in range(current - self._concurrency):
+                await self._queue.put(_SENTINEL)
+            await LogService.info("task_queue", "Task workers scaling down", {"active_workers": len(self._worker_tasks), "target": self._concurrency})
+
+    async def _worker_loop(self, worker_id: int):
+        current_task = asyncio.current_task()
+        await LogService.info("task_queue", f"Worker {worker_id} started")
+        try:
+            while True:
+                job = await self._queue.get()
+                if job is _SENTINEL:
+                    self._queue.task_done()
+                    break
+                try:
+                    await self._execute_task(job)
+                except Exception as e:
+                    await LogService.error(
+                        "task_queue",
+                        f"Error executing task {job.id}: {e}",
+                        {"task_id": job.id, "name": job.name},
+                    )
+                finally:
+                    self._queue.task_done()
+        finally:
+            if current_task in self._worker_tasks:
+                self._worker_tasks.remove(current_task)  # type: ignore[arg-type]
+            await LogService.info("task_queue", f"Worker {worker_id} stopped")
+
+    async def start_worker(self, concurrency: int | None = None):
+        if concurrency is None:
+            from services.config import ConfigCenter
+
+            stored_value = await ConfigCenter.get("TASK_QUEUE_CONCURRENCY", self._concurrency)
+            try:
+                concurrency = int(stored_value)
+            except (TypeError, ValueError):
+                concurrency = self._concurrency
+        await self.set_concurrency(concurrency)
+
+    async def set_concurrency(self, value: int):
+        value = max(1, int(value))
+        if value != self._concurrency:
+            self._concurrency = value
+        await self._ensure_worker_count()
+
+    async def stop_worker(self):
+        self._cleanup_workers()
+        for _ in range(len(self._worker_tasks)):
+            await self._queue.put(_SENTINEL)
+        if self._worker_tasks:
+            await asyncio.gather(*self._worker_tasks, return_exceptions=True)
+        self._worker_tasks.clear()
+        await LogService.info("task_queue", "Task workers have been stopped.")
+
+    def get_concurrency(self) -> int:
+        return self._concurrency
+
+    def get_active_worker_count(self) -> int:
+        self._cleanup_workers()
+        return len(self._worker_tasks)
+
+
+task_queue_service = TaskQueueService()

services/tasks.py

@@ -4,6 +4,9 @@ from models.database import AutomationTask
 from services.processors.registry import get as get_processor
 from services.logging import LogService
 
+from services.task_queue import task_queue_service
+
+
 class TaskService:
     async def trigger_tasks(self, event: str, path: str):
         tasks = await AutomationTask.filter(event=event, enabled=True)
@@ -21,28 +24,12 @@ class TaskService:
         return True
 
     async def execute(self, task: AutomationTask, path: str):
-        from services.virtual_fs import read_file, write_file
+        await task_queue_service.add_task(
+            task.processor_type,
+            {
+                "task_id": task.id,
+                "path": path,
+            },
+        )
 
-        processor = get_processor(task.processor_type)
-        if not processor:
-            print(f"Processor {task.processor_type} not found for task {task.id}")
-            return
-
-        try:
-            file_content = await read_file(path)
-            result = await processor.process(file_content, path, task.processor_config)
-            
-            save_to = task.processor_config.get("save_to")
-            if save_to and getattr(processor, "produces_file", False):
-                await write_file(save_to, result)
-
-        except Exception as e:
-            error_message = f"Error executing task {task.id} for path {path}: {e}"
-            print(error_message)
-            await LogService.error(
-                source=f"task_executor:{task.id}",
-                message=error_message,
-                details={"task_name": task.name, "event": task.event, "path": path, "processor": task.processor_type}
-            )
-
-task_service = TaskService()
+task_service = TaskService()

services/thumbnail.py

@@ -1,13 +1,21 @@
 from __future__ import annotations
+import asyncio
+import inspect
 import io
 import hashlib
+import tempfile
+from contextlib import suppress
 from pathlib import Path
 from typing import Tuple
 from fastapi import HTTPException
 
-ALLOWED_EXT = {"jpg", "jpeg", "png", "webp", "gif", "bmp", "tiff", "arw", "cr2", "cr3", "nef", "rw2", "orf", "pef", "dng"}
+ALLOWED_EXT = {"jpg", "jpeg", "png", "webp", "gif", "bmp",
+               "tiff", "arw", "cr2", "cr3", "nef", "rw2", "orf", "pef", "dng"}
 RAW_EXT = {"arw", "cr2", "cr3", "nef", "rw2", "orf", "pef", "dng"}
-MAX_SOURCE_SIZE = 200 * 1024 * 1024
+VIDEO_EXT = {"mp4", "mov", "m4v", "avi", "mkv", "wmv", "flv", "webm", "mpg", "mpeg", "3gp"}
+MAX_IMAGE_SOURCE_SIZE = 200 * 1024 * 1024
+VIDEO_RANGE_LIMIT = 16 * 1024 * 1024  # 16MB
+VIDEO_INITIAL_CHUNK = 4 * 1024 * 1024
 CACHE_ROOT = Path('data/.thumb_cache')
 
 
@@ -25,6 +33,13 @@ def is_raw_filename(name: str) -> bool:
     return parts[1].lower() in RAW_EXT
 
 
+def is_video_filename(name: str) -> bool:
+    parts = name.rsplit('.', 1)
+    if len(parts) < 2:
+        return False
+    return parts[1].lower() in VIDEO_EXT
+
+
 def _cache_key(adapter_id: int, rel: str, size: int, mtime: int, w: int, h: int, fit: str) -> str:
     raw = f"{adapter_id}|{rel}|{size}|{mtime}|{w}x{h}|{fit}".encode()
     return hashlib.sha1(raw).hexdigest()
@@ -39,29 +54,8 @@ def _ensure_cache_dir(p: Path):
     p.parent.mkdir(parents=True, exist_ok=True)
 
 
-def generate_thumb(data: bytes, w: int, h: int, fit: str, is_raw: bool = False) -> Tuple[bytes, str]:
+def _image_to_webp(im, w: int, h: int, fit: str) -> Tuple[bytes, str]:
     from PIL import Image
-    if is_raw:
-        try:
-            import rawpy
-            with rawpy.imread(io.BytesIO(data)) as raw:
-                try:
-                    thumb = raw.extract_thumb()
-                except rawpy.LibRawNoThumbnailError:
-                    thumb = None
-                
-                if thumb is not None and thumb.format in [rawpy.ThumbFormat.JPEG, rawpy.ThumbFormat.BITMAP]:
-                    im = Image.open(io.BytesIO(thumb.data))
-                else:
-                    rgb = raw.postprocess(use_camera_wb=False, use_auto_wb=True, output_bps=8)
-                    im = Image.fromarray(rgb)
-        except Exception as e:
-            print(f"rawpy processing failed: {e}")
-            raise e
-
-    else:
-        im = Image.open(io.BytesIO(data))
-
     if im.mode not in ("RGB", "RGBA"):
         im = im.convert("RGBA" if im.mode in ("P", "LA") else "RGB")
     if fit == 'cover':
@@ -84,21 +78,253 @@ def generate_thumb(data: bytes, w: int, h: int, fit: str, is_raw: bool = False)
     return buf.getvalue(), 'image/webp'
 
 
+def generate_thumb(data: bytes, w: int, h: int, fit: str, is_raw: bool = False) -> Tuple[bytes, str]:
+    from PIL import Image
+    if is_raw:
+        try:
+            import rawpy
+            with rawpy.imread(io.BytesIO(data)) as raw:
+                try:
+                    thumb = raw.extract_thumb()
+                except rawpy.LibRawNoThumbnailError:
+                    thumb = None
+
+                if thumb is not None and thumb.format in [rawpy.ThumbFormat.JPEG, rawpy.ThumbFormat.BITMAP]:
+                    im = Image.open(io.BytesIO(thumb.data))
+                else:
+                    rgb = raw.postprocess(
+                        use_camera_wb=False, use_auto_wb=True, output_bps=8)
+                    im = Image.fromarray(rgb)
+        except Exception as e:
+            print(f"rawpy processing failed: {e}")
+            raise e
+
+    else:
+        im = Image.open(io.BytesIO(data))
+
+    return _image_to_webp(im, w, h, fit)
+
+
+async def _collect_response_bytes(response, limit: int) -> bytes:
+    if response is None:
+        return b""
+
+    try:
+        if isinstance(response, (bytes, bytearray)):
+            return bytes(response[:limit])
+
+        body = getattr(response, "body", None)
+        if body is not None:
+            return bytes(body[:limit])
+
+        iterator = getattr(response, "body_iterator", None)
+        if iterator is not None:
+            data = bytearray()
+            async for chunk in iterator:
+                if not chunk:
+                    continue
+                need = limit - len(data)
+                if need <= 0:
+                    break
+                data.extend(chunk[:need])
+                if len(data) >= limit:
+                    break
+            return bytes(data)
+
+        if hasattr(response, "__aiter__"):
+            data = bytearray()
+            async for chunk in response:
+                if not chunk:
+                    continue
+                need = limit - len(data)
+                if need <= 0:
+                    break
+                data.extend(chunk[:need])
+                if len(data) >= limit:
+                    break
+            return bytes(data)
+    finally:
+        close_func = getattr(response, "close", None)
+        if callable(close_func):
+            result = close_func()
+            if inspect.isawaitable(result):
+                await result
+
+    return b""
+
+
+async def _read_range_slice(adapter, root: str, rel: str, start: int, end: int) -> bytes:
+    read_range = getattr(adapter, "read_file_range", None)
+    if callable(read_range):
+        try:
+            return await read_range(root, rel, start, end)
+        except TypeError:
+            return await read_range(root, rel, start, end=end)
+
+    stream_impl = getattr(adapter, "stream_file", None)
+    if callable(stream_impl):
+        range_header = f"bytes={start}-{end}"
+        response = await stream_impl(root, rel, range_header)
+        expected = end - start + 1
+        return await _collect_response_bytes(response, expected)
+
+    read_file = getattr(adapter, "read_file", None)
+    if callable(read_file) and start == 0:
+        data = await read_file(root, rel)
+        slice_end = end + 1
+        return data[:slice_end]
+
+    return b""
+
+
+async def _read_video_prefix(adapter, root: str, rel: str, size: int, limit: int = VIDEO_RANGE_LIMIT) -> bytes:
+    chunk_size = min(VIDEO_INITIAL_CHUNK, limit)
+    offset = 0
+    collected = bytearray()
+
+    while len(collected) < limit:
+        end = offset + chunk_size - 1
+        data = await _read_range_slice(adapter, root, rel, offset, end)
+        if not data:
+            break
+        collected.extend(data)
+        if len(data) < chunk_size:
+            break
+        offset += len(data)
+        remaining = limit - len(collected)
+        if remaining <= 0:
+            break
+        chunk_size = min(chunk_size * 2, remaining)
+
+    if not collected and size <= limit:
+        read_file = getattr(adapter, "read_file", None)
+        if callable(read_file):
+            blob = await read_file(root, rel)
+            if blob:
+                return bytes(blob[:limit])
+
+    return bytes(collected[:limit])
+
+
+async def _run_ffmpeg_extract_frame(src_path: str, dst_path: str):
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-hide_banner",
+        "-loglevel", "error",
+        "-i", src_path,
+        "-frames:v", "1",
+        dst_path,
+    ]
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+    except FileNotFoundError as e:
+        raise RuntimeError("未找到 ffmpeg，可执行文件需要在 PATH 中") from e
+
+    stdout, stderr = await proc.communicate()
+    if proc.returncode != 0:
+        message = stderr.decode().strip() or stdout.decode().strip() or "ffmpeg 执行失败"
+        raise RuntimeError(message)
+
+
+async def _generate_video_thumb(video_bytes: bytes, rel: str, w: int, h: int, fit: str) -> Tuple[bytes, str]:
+    from PIL import Image
+
+    suffix = Path(rel).suffix or ".mp4"
+    src_tmp = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
+    src_path = src_tmp.name
+    try:
+        src_tmp.write(video_bytes)
+        src_tmp.flush()
+    finally:
+        src_tmp.close()
+
+    dst_tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+    dst_path = dst_tmp.name
+    dst_tmp.close()
+
+    try:
+        await _run_ffmpeg_extract_frame(src_path, dst_path)
+        with Image.open(dst_path) as im:
+            im.load()
+            return _image_to_webp(im, w, h, fit)
+    finally:
+        with suppress(FileNotFoundError):
+            Path(src_path).unlink()
+        with suppress(FileNotFoundError):
+            Path(dst_path).unlink()
+
+
 async def get_or_create_thumb(adapter, adapter_id: int, root: str, rel: str, w: int, h: int, fit: str = 'cover'):
     stat = await adapter.stat_file(root, rel)
-    if stat['size'] > MAX_SOURCE_SIZE:
-         raise HTTPException(400, detail="Image too large for thumbnail")
-    
-    key = _cache_key(adapter_id, rel, stat['size'], int(stat['mtime']), w, h, fit)
+    size = int(stat.get('size') or 0)
+    is_video = is_video_filename(rel)
+    if not is_video and size > MAX_IMAGE_SOURCE_SIZE:
+        raise HTTPException(400, detail="Image too large for thumbnail")
+
+    key = _cache_key(adapter_id, rel, size, int(
+        stat.get('mtime', 0)), w, h, fit)
     path = _cache_path(key)
     if path.exists():
         return path.read_bytes(), 'image/webp', key
+
     _ensure_cache_dir(path)
-    read_data = await adapter.read_file(root, rel)
-    try:
-        thumb_bytes, mime = generate_thumb(read_data, w, h, fit, is_raw=is_raw_filename(rel))
-    except Exception as e:
-        print(e)
-        raise HTTPException(500, detail=f"Thumbnail generation failed: {e}")
-    path.write_bytes(thumb_bytes)
-    return thumb_bytes, mime, key
+    thumb_bytes, mime = None, None
+
+    get_thumb_impl = getattr(adapter, "get_thumbnail", None)
+    if callable(get_thumb_impl):
+        size_str = "large" if w > 400 else "medium" if w > 100 else "small"
+        native_thumb_bytes = await get_thumb_impl(root, rel, size_str)
+
+        if native_thumb_bytes:
+            try:
+                from PIL import Image
+                im = Image.open(io.BytesIO(native_thumb_bytes))
+                buf = io.BytesIO()
+                im.save(buf, 'WEBP', quality=85)
+                thumb_bytes = buf.getvalue()
+                mime = 'image/webp'
+            except Exception as e:
+                print(
+                    f"Failed to convert native thumbnail to WebP: {e}, falling back.")
+                thumb_bytes, mime = None, None
+
+    if not thumb_bytes:
+        if is_video:
+            try:
+                video_bytes = await _read_video_prefix(adapter, root, rel, size)
+            except HTTPException:
+                raise
+            except Exception as e:
+                print(f"Video prefix read failed: {e}")
+                raise HTTPException(500, detail=f"Video read failed: {e}")
+
+            if not video_bytes:
+                raise HTTPException(500, detail="Unable to read video data for thumbnail")
+
+            try:
+                thumb_bytes, mime = await _generate_video_thumb(video_bytes, rel, w, h, fit)
+            except Exception as e:
+                print(f"Video thumbnail generation failed: {e}")
+                raise HTTPException(
+                    500, detail=f"Video thumbnail generation failed: {e}")
+        else:
+            read_data = await adapter.read_file(root, rel)
+            try:
+                thumb_bytes, mime = generate_thumb(
+                    read_data, w, h, fit, is_raw=is_raw_filename(rel))
+            except Exception as e:
+                print(e)
+                raise HTTPException(
+                    500, detail=f"Thumbnail generation failed: {e}")
+
+    if thumb_bytes:
+        path.write_bytes(thumb_bytes)
+        return thumb_bytes, mime, key
+
+    raise HTTPException(
+        500, detail="Failed to generate thumbnail by any means")

services/vector_db.py

@@ -1,77 +0,0 @@
-from pymilvus import CollectionSchema, DataType, FieldSchema, MilvusClient
-
-
-class VectorDBService:
-    _instance = None
-
-    def __new__(cls, *args, **kwargs):
-        if not cls._instance:
-            cls._instance = super(VectorDBService, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self):
-        if not hasattr(self, 'client'):
-            self.client = MilvusClient("data/db/milvus.db")
-
-    def ensure_collection(self, collection_name, vector: bool = True):
-        if self.client.has_collection(collection_name):
-            return
-        if vector:
-            fields = [
-                FieldSchema(name="path", dtype=DataType.VARCHAR,
-                            max_length=512, is_primary=True, auto_id=False),
-                FieldSchema(name="embedding",
-                            dtype=DataType.FLOAT_VECTOR, dim=4096)
-            ]
-            schema = CollectionSchema(
-                fields, description="Image vector collection")
-            self.client.create_collection(collection_name, schema=schema)
-            index_params = MilvusClient.prepare_index_params()
-            index_params.add_index(
-                field_name="embedding",
-                index_type="IVF_FLAT",
-                index_name="vector_index",
-                metric_type="COSINE",
-                params={
-                    "nlist": 64,
-                }
-            )
-            self.client.create_index(
-                collection_name,
-                index_params=index_params
-            )
-        else:
-            fields = [
-                FieldSchema(name="path", dtype=DataType.VARCHAR,
-                            max_length=512, is_primary=True, auto_id=False),
-            ]
-            schema = CollectionSchema(fields, description="Simple file index")
-            self.client.create_collection(collection_name, schema=schema)
-
-    def upsert_vector(self, collection_name, data):
-        self.client.upsert(collection_name, data)
-
-    def delete_vector(self, collection_name, path: str):
-        self.client.delete(collection_name, ids=[path])
-
-    def search_vectors(self, collection_name, query_embedding, top_k=5):
-        search_params = {"metric_type": "COSINE"}
-        results = self.client.search(
-            collection_name,
-            data=[query_embedding],
-            anns_field="embedding",
-            search_params=search_params,
-            limit=top_k,
-            output_fields=["path"]
-        )
-        print(results)
-        return results
-
-    def search_by_path(self, collection_name, query_path, top_k=20):
-        results = self.client.query(
-            collection_name,
-            filter=f"path like '%{query_path}%'",
-            limit=top_k,
-            output_fields=["path"]
-        )
-        return [[{'id': r['path'], 'distance': 1.0, 'entity': {'path': r['path']}} for r in results]]

services/vector_db/__init__.py

@@ -0,0 +1,11 @@
+from .service import VectorDBService, DEFAULT_VECTOR_DIMENSION
+from .providers import list_providers, get_provider_entry
+from .config_manager import VectorDBConfigManager
+
+__all__ = [
+    "VectorDBService",
+    "DEFAULT_VECTOR_DIMENSION",
+    "list_providers",
+    "get_provider_entry",
+    "VectorDBConfigManager",
+]

services/vector_db/config_manager.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Tuple
+
+from services.config import ConfigCenter
+
+
+class VectorDBConfigManager:
+    TYPE_KEY = "VECTOR_DB_TYPE"
+    CONFIG_KEY = "VECTOR_DB_CONFIG"
+    DEFAULT_TYPE = "milvus_lite"
+
+    @classmethod
+    async def load_config(cls) -> Tuple[str, Dict[str, Any]]:
+        raw_type = await ConfigCenter.get(cls.TYPE_KEY, cls.DEFAULT_TYPE)
+        provider_type = str(raw_type or cls.DEFAULT_TYPE)
+
+        raw_config = await ConfigCenter.get(cls.CONFIG_KEY)
+        config_dict: Dict[str, Any] = {}
+        if isinstance(raw_config, str) and raw_config:
+            try:
+                config_dict = json.loads(raw_config)
+            except json.JSONDecodeError:
+                config_dict = {}
+        elif isinstance(raw_config, dict):
+            config_dict = raw_config
+        return provider_type, config_dict
+
+    @classmethod
+    async def save_config(cls, provider_type: str, config: Dict[str, Any]) -> None:
+        await ConfigCenter.set(cls.TYPE_KEY, provider_type)
+        await ConfigCenter.set(cls.CONFIG_KEY, json.dumps(config or {}))
+
+    @classmethod
+    async def get_type(cls) -> str:
+        provider_type, _ = await cls.load_config()
+        return provider_type
+
+    @classmethod
+    async def get_config(cls) -> Dict[str, Any]:
+        _, config = await cls.load_config()
+        return config

services/vector_db/providers/__init__.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import Dict, List, Type
+
+from .base import BaseVectorProvider
+from .milvus_lite import MilvusLiteProvider
+from .milvus_server import MilvusServerProvider
+from .qdrant import QdrantProvider
+
+_PROVIDER_REGISTRY: Dict[str, Dict[str, object]] = {
+    MilvusLiteProvider.type: {
+        "class": MilvusLiteProvider,
+        "label": MilvusLiteProvider.label,
+        "description": MilvusLiteProvider.description,
+        "enabled": MilvusLiteProvider.enabled,
+        "config_schema": MilvusLiteProvider.config_schema,
+    },
+    MilvusServerProvider.type: {
+        "class": MilvusServerProvider,
+        "label": MilvusServerProvider.label,
+        "description": MilvusServerProvider.description,
+        "enabled": MilvusServerProvider.enabled,
+        "config_schema": MilvusServerProvider.config_schema,
+    },
+    QdrantProvider.type: {
+        "class": QdrantProvider,
+        "label": QdrantProvider.label,
+        "description": QdrantProvider.description,
+        "enabled": QdrantProvider.enabled,
+        "config_schema": QdrantProvider.config_schema,
+    },
+}
+
+
+def list_providers() -> List[Dict[str, object]]:
+    return [
+        {
+            "type": type_key,
+            "label": meta["label"],
+            "description": meta.get("description"),
+            "enabled": meta.get("enabled", True),
+            "config_schema": meta.get("config_schema", []),
+        }
+        for type_key, meta in _PROVIDER_REGISTRY.items()
+    ]
+
+
+def get_provider_entry(provider_type: str) -> Dict[str, object] | None:
+    return _PROVIDER_REGISTRY.get(provider_type)
+
+
+def get_provider_class(provider_type: str) -> Type[BaseVectorProvider] | None:
+    entry = get_provider_entry(provider_type)
+    if not entry:
+        return None
+    return entry.get("class")  # type: ignore[return-value]

services/vector_db/providers/base.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+
+class BaseVectorProvider:
+    """向量数据库提供者基础类，所有实际实现需继承该类"""
+
+    type: str = ""
+    label: str = ""
+    description: str | None = None
+    enabled: bool = True
+    config_schema: List[Dict[str, Any]] = []
+
+    def __init__(self, config: Dict[str, Any] | None = None):
+        self.config = config or {}
+
+    async def initialize(self) -> None:
+        """执行初始化逻辑，例如建立连接"""
+        raise NotImplementedError
+
+    def ensure_collection(self, collection_name: str, vector: bool, dim: int) -> None:
+        raise NotImplementedError
+
+    def upsert_vector(self, collection_name: str, data: Dict[str, Any]) -> None:
+        raise NotImplementedError
+
+    def delete_vector(self, collection_name: str, path: str) -> None:
+        raise NotImplementedError
+
+    def search_vectors(self, collection_name: str, query_embedding, top_k: int):
+        raise NotImplementedError
+
+    def search_by_path(self, collection_name: str, query_path: str, top_k: int):
+        raise NotImplementedError
+
+    def get_all_stats(self) -> Dict[str, Any]:
+        raise NotImplementedError
+
+    def clear_all_data(self) -> None:
+        raise NotImplementedError

services/vector_db/providers/milvus_lite.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from pymilvus import CollectionSchema, DataType, FieldSchema, MilvusClient
+
+from .base import BaseVectorProvider
+
+
+class MilvusLiteProvider(BaseVectorProvider):
+    type = "milvus_lite"
+    label = "Milvus Lite"
+    description = "Embedded Milvus Lite (local file storage)."
+    enabled = True
+    config_schema: List[Dict[str, Any]] = [
+        {
+            "key": "db_path",
+            "label": "Database file path",
+            "type": "text",
+            "default": "data/db/milvus.db",
+            "required": False,
+        }
+    ]
+
+    def __init__(self, config: Dict[str, Any] | None = None):
+        super().__init__(config)
+        self.db_path = Path(self.config.get("db_path") or "data/db/milvus.db")
+        self.client: MilvusClient | None = None
+
+    async def initialize(self) -> None:
+        try:
+            self.client = MilvusClient(str(self.db_path))
+        except Exception as exc:  # pragma: no cover - depends on local environment
+            raise RuntimeError(f"Failed to open Milvus Lite at {self.db_path}: {exc}") from exc
+
+    def _get_client(self) -> MilvusClient:
+        if not self.client:
+            raise RuntimeError("Milvus Lite client is not initialized")
+        return self.client
+
+    @staticmethod
+    def _extract_hit_payload(hit: Any) -> tuple[Any, Any, Dict[str, Any]]:
+        hit_id = getattr(hit, "id", None)
+        distance = getattr(hit, "distance", None)
+        payload: Dict[str, Any] = {}
+
+        raw: Dict[str, Any] | None = None
+        if hasattr(hit, "entity"):
+            raw_entity = getattr(hit, "entity")
+            if hasattr(raw_entity, "to_dict"):
+                raw = dict(raw_entity.to_dict())
+            else:
+                raw = dict(raw_entity)
+        elif isinstance(hit, dict):
+            raw = dict(hit)
+
+        if raw:
+            hit_id = hit_id or raw.get("id")
+            distance = distance if distance is not None else raw.get("distance")
+            inner = raw.get("entity")
+            if isinstance(inner, dict):
+                payload = dict(inner)
+            else:
+                payload = {k: v for k, v in raw.items() if k not in {"id", "distance", "entity"}}
+
+        payload.setdefault("path", payload.get("source_path"))
+        payload.setdefault("source_path", payload.get("path"))
+        return hit_id, distance, payload
+
+    @staticmethod
+    def _to_int(value: Any) -> int:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return 0
+
+    def ensure_collection(self, collection_name: str, vector: bool, dim: int) -> None:
+        client = self._get_client()
+        if client.has_collection(collection_name):
+            return
+        common_fields = [
+            FieldSchema(name="path", dtype=DataType.VARCHAR, max_length=512, is_primary=True, auto_id=False),
+            FieldSchema(name="source_path", dtype=DataType.VARCHAR, max_length=512, is_primary=False, auto_id=False),
+        ]
+
+        if vector:
+            vector_dim = dim if isinstance(dim, int) and dim > 0 else 0
+            if vector_dim <= 0:
+                vector_dim = 4096
+            fields = [
+                *common_fields,
+                FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=vector_dim),
+            ]
+            schema = CollectionSchema(fields, description="Vector collection", enable_dynamic_field=True)
+            client.create_collection(collection_name, schema=schema)
+            index_params = MilvusClient.prepare_index_params()
+            index_params.add_index(
+                field_name="embedding",
+                index_type="IVF_FLAT",
+                index_name="vector_index",
+                metric_type="COSINE",
+                params={"nlist": 64},
+            )
+            client.create_index(collection_name, index_params=index_params)
+        else:
+            schema = CollectionSchema(common_fields, description="Simple file index", enable_dynamic_field=True)
+            client.create_collection(collection_name, schema=schema)
+
+    def upsert_vector(self, collection_name: str, data: Dict[str, Any]) -> None:
+        payload = dict(data)
+        payload.setdefault("source_path", payload.get("path"))
+        payload.setdefault("vector_id", payload.get("path"))
+        self._get_client().upsert(collection_name, data=[payload])
+
+    def delete_vector(self, collection_name: str, path: str) -> None:
+        client = self._get_client()
+        escaped = path.replace('"', '\\"')
+        client.delete(collection_name, filter=f'source_path == "{escaped}"')
+
+    def search_vectors(self, collection_name: str, query_embedding, top_k: int):
+        search_params = {"metric_type": "COSINE"}
+        output_fields = [
+            "path",
+            "source_path",
+            "chunk_id",
+            "mime",
+            "text",
+            "start_offset",
+            "end_offset",
+            "type",
+            "name",
+        ]
+        raw_results = self._get_client().search(
+            collection_name,
+            data=[query_embedding],
+            anns_field="embedding",
+            search_params=search_params,
+            limit=top_k,
+            output_fields=output_fields,
+        )
+        formatted: List[List[Dict[str, Any]]] = []
+        for hits in raw_results:
+            bucket: List[Dict[str, Any]] = []
+            for hit in hits:
+                hit_id, distance, entity = self._extract_hit_payload(hit)
+                bucket.append({
+                    "id": hit_id,
+                    "distance": distance,
+                    "entity": entity,
+                })
+            formatted.append(bucket)
+        return formatted
+
+    def search_by_path(self, collection_name: str, query_path: str, top_k: int):
+        if query_path:
+            escaped = query_path.replace('"', '\\"')
+            filter_expr = f'source_path like "%{escaped}%"'
+        else:
+            filter_expr = "source_path like '%%'"
+        results = self._get_client().query(
+            collection_name,
+            filter=filter_expr,
+            limit=top_k,
+            output_fields=[
+                "path",
+                "source_path",
+                "chunk_id",
+                "mime",
+                "text",
+                "start_offset",
+                "end_offset",
+                "type",
+                "name",
+            ],
+        )
+        formatted = []
+        for row in results:
+            entity = dict(row)
+            entity.setdefault("path", entity.get("source_path"))
+            formatted.append({
+                "id": entity.get("path"),
+                "distance": 1.0,
+                "entity": entity,
+            })
+        return [formatted]
+
+    def get_all_stats(self) -> Dict[str, Any]:
+        client = self._get_client()
+        try:
+            collection_names = client.list_collections()
+        except Exception as exc:
+            raise RuntimeError(f"Failed to list collections: {exc}") from exc
+
+        collections: List[Dict[str, Any]] = []
+        total_vectors = 0
+        total_estimated_memory = 0
+
+        for name in collection_names:
+            try:
+                stats = client.get_collection_stats(name) or {}
+            except Exception:
+                stats = {}
+            row_count = self._to_int(stats.get("row_count"))
+            total_vectors += row_count
+
+            dimension: Optional[int] = None
+            is_vector_collection = False
+            try:
+                description = client.describe_collection(name)
+            except Exception:
+                description = None
+
+            if description:
+                for field in description.get("fields", []):
+                    if field.get("type") == DataType.FLOAT_VECTOR:
+                        params = field.get("params") or {}
+                        dimension = self._to_int(params.get("dim")) or 4096
+                        is_vector_collection = True
+                        break
+
+            estimated_memory = 0
+            if is_vector_collection and dimension:
+                estimated_memory = row_count * dimension * 4
+                total_estimated_memory += estimated_memory
+
+            indexes: List[Dict[str, Any]] = []
+            try:
+                index_names = client.list_indexes(name) or []
+            except Exception:
+                index_names = []
+
+            for index_name in index_names:
+                try:
+                    detail = client.describe_index(name, index_name) or {}
+                except Exception:
+                    detail = {}
+                indexes.append(
+                    {
+                        "index_name": index_name,
+                        "index_type": detail.get("index_type"),
+                        "metric_type": detail.get("metric_type"),
+                        "indexed_rows": self._to_int(detail.get("indexed_rows")),
+                        "pending_index_rows": self._to_int(detail.get("pending_index_rows")),
+                        "state": detail.get("state"),
+                    }
+                )
+
+            collections.append(
+                {
+                    "name": name,
+                    "row_count": row_count,
+                    "dimension": dimension if is_vector_collection else None,
+                    "estimated_memory_bytes": estimated_memory,
+                    "is_vector_collection": is_vector_collection,
+                    "indexes": indexes,
+                }
+            )
+
+        db_file_size = None
+        try:
+            if self.db_path.exists():
+                db_file_size = self.db_path.stat().st_size
+        except OSError:
+            db_file_size = None
+
+        return {
+            "collections": collections,
+            "collection_count": len(collections),
+            "total_vectors": total_vectors,
+            "estimated_total_memory_bytes": total_estimated_memory,
+            "db_file_size_bytes": db_file_size,
+        }
+
+    def clear_all_data(self) -> None:
+        client = self._get_client()
+        for collection_name in client.list_collections():
+            client.drop_collection(collection_name)

services/vector_db/providers/milvus_server.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from pymilvus import CollectionSchema, DataType, FieldSchema, MilvusClient
+
+from .base import BaseVectorProvider
+
+
+class MilvusServerProvider(BaseVectorProvider):
+    type = "milvus_server"
+    label = "Milvus Server"
+    description = "Remote Milvus instance accessed via URI."
+    enabled = True
+    config_schema: List[Dict[str, Any]] = [
+        {
+            "key": "uri",
+            "label": "Server URI",
+            "type": "text",
+            "required": True,
+            "placeholder": "http://localhost:19530",
+        },
+        {
+            "key": "token",
+            "label": "Token",
+            "type": "password",
+            "required": False,
+            "placeholder": "user:password",
+        },
+    ]
+
+    def __init__(self, config: Dict[str, Any] | None = None):
+        super().__init__(config)
+        self.client: MilvusClient | None = None
+
+    async def initialize(self) -> None:
+        uri = self.config.get("uri")
+        if not uri:
+            raise RuntimeError("Milvus Server URI is required")
+        try:
+            self.client = MilvusClient(uri=uri, token=self.config.get("token"))
+        except Exception as exc:  # pragma: no cover - depends on remote availability
+            raise RuntimeError(f"Failed to connect to Milvus Server {uri}: {exc}") from exc
+
+    def _get_client(self) -> MilvusClient:
+        if not self.client:
+            raise RuntimeError("Milvus Server client is not initialized")
+        return self.client
+
+    @staticmethod
+    def _extract_hit_payload(hit: Any) -> tuple[Any, Any, Dict[str, Any]]:
+        hit_id = getattr(hit, "id", None)
+        distance = getattr(hit, "distance", None)
+        payload: Dict[str, Any] = {}
+
+        raw: Dict[str, Any] | None = None
+        if hasattr(hit, "entity"):
+            raw_entity = getattr(hit, "entity")
+            if hasattr(raw_entity, "to_dict"):
+                raw = dict(raw_entity.to_dict())
+            else:
+                raw = dict(raw_entity)
+        elif isinstance(hit, dict):
+            raw = dict(hit)
+
+        if raw:
+            hit_id = hit_id or raw.get("id")
+            distance = distance if distance is not None else raw.get("distance")
+            inner = raw.get("entity")
+            if isinstance(inner, dict):
+                payload = dict(inner)
+            else:
+                payload = {k: v for k, v in raw.items() if k not in {"id", "distance", "entity"}}
+
+        payload.setdefault("path", payload.get("source_path"))
+        payload.setdefault("source_path", payload.get("path"))
+        return hit_id, distance, payload
+
+    @staticmethod
+    def _to_int(value: Any) -> int:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return 0
+
+    def ensure_collection(self, collection_name: str, vector: bool, dim: int) -> None:
+        client = self._get_client()
+        if client.has_collection(collection_name):
+            return
+        common_fields = [
+            FieldSchema(name="path", dtype=DataType.VARCHAR, max_length=512, is_primary=True, auto_id=False),
+            FieldSchema(name="source_path", dtype=DataType.VARCHAR, max_length=512, is_primary=False, auto_id=False),
+        ]
+        if vector:
+            vector_dim = dim if isinstance(dim, int) and dim > 0 else 0
+            if vector_dim <= 0:
+                vector_dim = 4096
+            fields = [
+                *common_fields,
+                FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=vector_dim),
+            ]
+            schema = CollectionSchema(fields, description="Vector collection", enable_dynamic_field=True)
+            client.create_collection(collection_name, schema=schema)
+            index_params = MilvusClient.prepare_index_params()
+            index_params.add_index(
+                field_name="embedding",
+                index_type="IVF_FLAT",
+                index_name="vector_index",
+                metric_type="COSINE",
+                params={"nlist": 64},
+            )
+            client.create_index(collection_name, index_params=index_params)
+        else:
+            schema = CollectionSchema(common_fields, description="Simple file index", enable_dynamic_field=True)
+            client.create_collection(collection_name, schema=schema)
+
+    def upsert_vector(self, collection_name: str, data: Dict[str, Any]) -> None:
+        payload = dict(data)
+        payload.setdefault("source_path", payload.get("path"))
+        payload.setdefault("vector_id", payload.get("path"))
+        self._get_client().upsert(collection_name, data=[payload])
+
+    def delete_vector(self, collection_name: str, path: str) -> None:
+        client = self._get_client()
+        escaped = path.replace('"', '\\"')
+        client.delete(collection_name, filter=f'source_path == "{escaped}"')
+
+    def search_vectors(self, collection_name: str, query_embedding, top_k: int):
+        search_params = {"metric_type": "COSINE"}
+        output_fields = [
+            "path",
+            "source_path",
+            "chunk_id",
+            "mime",
+            "text",
+            "start_offset",
+            "end_offset",
+            "type",
+            "name",
+        ]
+        raw_results = self._get_client().search(
+            collection_name,
+            data=[query_embedding],
+            anns_field="embedding",
+            search_params=search_params,
+            limit=top_k,
+            output_fields=output_fields,
+        )
+        formatted: List[List[Dict[str, Any]]] = []
+        for hits in raw_results:
+            bucket: List[Dict[str, Any]] = []
+            for hit in hits:
+                hit_id, distance, entity = self._extract_hit_payload(hit)
+                bucket.append({
+                    "id": hit_id,
+                    "distance": distance,
+                    "entity": entity,
+                })
+            formatted.append(bucket)
+        return formatted
+
+    def search_by_path(self, collection_name: str, query_path: str, top_k: int):
+        if query_path:
+            escaped = query_path.replace('"', '\\"')
+            filter_expr = f'source_path like "%{escaped}%"'
+        else:
+            filter_expr = "source_path like '%%'"
+        results = self._get_client().query(
+            collection_name,
+            filter=filter_expr,
+            limit=top_k,
+            output_fields=[
+                "path",
+                "source_path",
+                "chunk_id",
+                "mime",
+                "text",
+                "start_offset",
+                "end_offset",
+                "type",
+                "name",
+            ],
+        )
+        formatted = []
+        for row in results:
+            entity = dict(row)
+            entity.setdefault("path", entity.get("source_path"))
+            formatted.append({
+                "id": entity.get("path"),
+                "distance": 1.0,
+                "entity": entity,
+            })
+        return [formatted]
+
+    def get_all_stats(self) -> Dict[str, Any]:
+        client = self._get_client()
+        try:
+            collection_names = client.list_collections()
+        except Exception as exc:
+            raise RuntimeError(f"Failed to list collections: {exc}") from exc
+
+        collections: List[Dict[str, Any]] = []
+        total_vectors = 0
+        total_estimated_memory = 0
+
+        for name in collection_names:
+            try:
+                stats = client.get_collection_stats(name) or {}
+            except Exception:
+                stats = {}
+            row_count = self._to_int(stats.get("row_count"))
+            total_vectors += row_count
+
+            dimension: Optional[int] = None
+            is_vector_collection = False
+            try:
+                description = client.describe_collection(name)
+            except Exception:
+                description = None
+
+            if description:
+                for field in description.get("fields", []):
+                    if field.get("type") == DataType.FLOAT_VECTOR:
+                        params = field.get("params") or {}
+                        dimension = self._to_int(params.get("dim")) or 4096
+                        is_vector_collection = True
+                        break
+
+            estimated_memory = 0
+            if is_vector_collection and dimension:
+                estimated_memory = row_count * dimension * 4
+                total_estimated_memory += estimated_memory
+
+            indexes: List[Dict[str, Any]] = []
+            try:
+                index_names = client.list_indexes(name) or []
+            except Exception:
+                index_names = []
+
+            for index_name in index_names:
+                try:
+                    detail = client.describe_index(name, index_name) or {}
+                except Exception:
+                    detail = {}
+                indexes.append(
+                    {
+                        "index_name": index_name,
+                        "index_type": detail.get("index_type"),
+                        "metric_type": detail.get("metric_type"),
+                        "indexed_rows": self._to_int(detail.get("indexed_rows")),
+                        "pending_index_rows": self._to_int(detail.get("pending_index_rows")),
+                        "state": detail.get("state"),
+                    }
+                )
+
+            collections.append(
+                {
+                    "name": name,
+                    "row_count": row_count,
+                    "dimension": dimension if is_vector_collection else None,
+                    "estimated_memory_bytes": estimated_memory,
+                    "is_vector_collection": is_vector_collection,
+                    "indexes": indexes,
+                }
+            )
+
+        return {
+            "collections": collections,
+            "collection_count": len(collections),
+            "total_vectors": total_vectors,
+            "estimated_total_memory_bytes": total_estimated_memory,
+            "db_file_size_bytes": None,
+        }
+
+    def clear_all_data(self) -> None:
+        client = self._get_client()
+        for collection_name in client.list_collections():
+            client.drop_collection(collection_name)

services/vector_db/providers/qdrant.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Sequence
+from uuid import NAMESPACE_URL, uuid5
+
+from qdrant_client import QdrantClient
+from qdrant_client.http import models as qmodels
+
+from .base import BaseVectorProvider
+
+
+class QdrantProvider(BaseVectorProvider):
+    type = "qdrant"
+    label = "Qdrant"
+    description = "Qdrant vector database (HTTP API)."
+    enabled = True
+    config_schema: List[Dict[str, Any]] = [
+        {
+            "key": "url",
+            "label": "Server URL",
+            "type": "text",
+            "required": True,
+            "placeholder": "http://localhost:6333",
+        },
+        {
+            "key": "api_key",
+            "label": "API Key",
+            "type": "password",
+            "required": False,
+        },
+    ]
+
+    def __init__(self, config: Dict[str, Any] | None = None):
+        super().__init__(config)
+        self.client: Optional[QdrantClient] = None
+
+    async def initialize(self) -> None:
+        url = (self.config.get("url") or "").strip()
+        if not url:
+            raise RuntimeError("Qdrant URL is required")
+
+        api_key = (self.config.get("api_key") or None) or None
+        try:
+            client = QdrantClient(url=url, api_key=api_key)
+            # 简单连通性校验
+            client.get_collections()
+            self.client = client
+        except Exception as exc:  # pragma: no cover - 依赖外部服务
+            raise RuntimeError(f"Failed to connect to Qdrant at {url}: {exc}") from exc
+
+    def _get_client(self) -> QdrantClient:
+        if not self.client:
+            raise RuntimeError("Qdrant client is not initialized")
+        return self.client
+
+    @staticmethod
+    def _vector_params(vector: bool, dim: int) -> qmodels.VectorParams:
+        size = dim if vector and isinstance(dim, int) and dim > 0 else 1
+        return qmodels.VectorParams(size=size, distance=qmodels.Distance.COSINE)
+
+    def _ensure_payload_indexes(self, client: QdrantClient, collection_name: str) -> None:
+        for field in ("path", "source_path"):
+            try:
+                client.create_payload_index(
+                    collection_name=collection_name,
+                    field_name=field,
+                    field_schema="keyword",
+                )
+            except Exception as exc:  # pragma: no cover - 依赖外部服务
+                message = str(exc).lower()
+                if "already exists" in message or "index exists" in message:
+                    continue
+                # 旧版本 qdrant 可能返回带状态码的异常，这里容忍重复创建
+                raise
+
+    def ensure_collection(self, collection_name: str, vector: bool, dim: int) -> None:
+        client = self._get_client()
+        try:
+            exists = client.collection_exists(collection_name)
+        except Exception as exc:  # pragma: no cover - 依赖外部服务
+            raise RuntimeError(f"Failed to check Qdrant collection '{collection_name}': {exc}") from exc
+
+        if exists:
+            try:
+                self._ensure_payload_indexes(client, collection_name)
+            except Exception:
+                pass
+            return
+
+        vectors_config = self._vector_params(vector, dim)
+        try:
+            client.create_collection(collection_name=collection_name, vectors_config=vectors_config)
+        except Exception as exc:  # pragma: no cover
+            if "already exists" in str(exc).lower():
+                try:
+                    self._ensure_payload_indexes(client, collection_name)
+                except Exception:
+                    pass
+                return
+            raise RuntimeError(f"Failed to create Qdrant collection '{collection_name}': {exc}") from exc
+
+        try:
+            self._ensure_payload_indexes(client, collection_name)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _point_id(uid: str) -> str:
+        return str(uuid5(NAMESPACE_URL, uid))
+
+    def _prepare_point(self, data: Dict[str, Any]) -> qmodels.PointStruct:
+        uid = data.get("path")
+        if not uid:
+            raise ValueError("Qdrant upsert requires 'path' in data")
+
+        embedding = data.get("embedding")
+        if embedding is None:
+            vector = [0.0]
+        else:
+            vector = [float(x) for x in embedding]
+
+        payload = {k: v for k, v in data.items() if k != "embedding"}
+        payload.setdefault("vector_id", uid)
+        source_path = payload.get("source_path") or payload.get("path")
+        payload["path"] = source_path
+        return qmodels.PointStruct(id=self._point_id(str(uid)), vector=vector, payload=payload)
+
+    def upsert_vector(self, collection_name: str, data: Dict[str, Any]) -> None:
+        client = self._get_client()
+        point = self._prepare_point(data)
+        client.upsert(collection_name=collection_name, wait=True, points=[point])
+
+    def delete_vector(self, collection_name: str, path: str) -> None:
+        client = self._get_client()
+        condition = qmodels.FieldCondition(
+            key="path",
+            match=qmodels.MatchValue(value=path),
+        )
+        flt = qmodels.Filter(must=[condition])
+        selector = qmodels.FilterSelector(filter=flt)
+        client.delete(collection_name=collection_name, points_selector=selector, wait=True)
+
+    def _format_search_results(self, points: Sequence[qmodels.ScoredPoint]):
+        return [
+            {
+                "id": point.id,
+                "distance": point.score,
+                "entity": point.payload or {},
+            }
+            for point in points
+        ]
+
+    def search_vectors(self, collection_name: str, query_embedding, top_k: int):
+        client = self._get_client()
+        vector = [float(x) for x in query_embedding]
+        points = client.search(
+            collection_name=collection_name,
+            query_vector=vector,
+            limit=top_k,
+            with_payload=True,
+        )
+        return [self._format_search_results(points)]
+
+    def search_by_path(self, collection_name: str, query_path: str, top_k: int):
+        client = self._get_client()
+        results: List[Dict[str, Any]] = []
+        offset: Optional[str | int] = None
+        remaining = max(top_k, 1)
+
+        while len(results) < top_k:
+            batch_size = min(max(remaining * 2, 10), 200)
+            records, next_offset = client.scroll(
+                collection_name=collection_name,
+                limit=batch_size,
+                offset=offset,
+                with_payload=True,
+            )
+            if not records:
+                break
+
+            for record in records:
+                payload = record.payload or {}
+                path = payload.get("path")
+                if query_path and path and query_path not in path:
+                    continue
+                results.append({"id": record.id, "distance": 1.0, "entity": payload})
+                if len(results) >= top_k:
+                    break
+
+            if next_offset is None or len(results) >= top_k:
+                break
+            offset = next_offset
+            remaining = top_k - len(results)
+
+        return [results]
+
+    def _extract_vector_config(self, vectors) -> Optional[qmodels.VectorParams]:
+        if isinstance(vectors, qmodels.VectorParams):
+            return vectors
+        if isinstance(vectors, dict):
+            for value in vectors.values():
+                if isinstance(value, qmodels.VectorParams):
+                    return value
+        return None
+
+    def get_all_stats(self) -> Dict[str, Any]:
+        client = self._get_client()
+        try:
+            response = client.get_collections()
+        except Exception as exc:  # pragma: no cover
+            raise RuntimeError(f"Failed to list Qdrant collections: {exc}") from exc
+
+        collections: List[Dict[str, Any]] = []
+        total_vectors = 0
+        total_estimated_memory = 0
+
+        for description in response.collections or []:
+            name = description.name
+            try:
+                info = client.get_collection(name)
+            except Exception:
+                continue
+
+            row_count = int(info.points_count or 0)
+            total_vectors += row_count
+
+            vector_params = self._extract_vector_config(info.config.params.vectors if info.config and info.config.params else None)
+            dimension = int(vector_params.size) if vector_params and vector_params.size else None
+            estimated_memory = row_count * dimension * 4 if dimension else 0
+            total_estimated_memory += estimated_memory
+            distance = str(vector_params.distance) if vector_params and vector_params.distance else None
+
+            indexed_rows = int(info.indexed_vectors_count or 0)
+            pending_rows = max(row_count - indexed_rows, 0)
+
+            collections.append(
+                {
+                    "name": name,
+                    "row_count": row_count,
+                    "dimension": dimension,
+                    "estimated_memory_bytes": estimated_memory,
+                    "is_vector_collection": dimension is not None and dimension > 1,
+                    "indexes": [
+                        {
+                            "index_name": "hnsw",
+                            "index_type": "HNSW",
+                            "metric_type": distance,
+                            "indexed_rows": indexed_rows,
+                            "pending_index_rows": pending_rows,
+                            "state": info.status,
+                        }
+                    ],
+                }
+            )
+
+        return {
+            "collections": collections,
+            "collection_count": len(collections),
+            "total_vectors": total_vectors,
+            "estimated_total_memory_bytes": total_estimated_memory,
+            "db_file_size_bytes": None,
+        }
+
+    def clear_all_data(self) -> None:
+        client = self._get_client()
+        try:
+            response = client.get_collections()
+        except Exception as exc:  # pragma: no cover
+            raise RuntimeError(f"Failed to list Qdrant collections: {exc}") from exc
+
+        for description in response.collections or []:
+            try:
+                client.delete_collection(description.name)
+            except Exception:
+                continue

services/vector_db/service.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Dict, Optional
+
+from .config_manager import VectorDBConfigManager
+from .providers import get_provider_class, get_provider_entry
+from .providers.base import BaseVectorProvider
+
+DEFAULT_VECTOR_DIMENSION = 4096
+
+
+class VectorDBService:
+    _instance: "VectorDBService" | None = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not hasattr(self, "_provider"):
+            self._provider: Optional[BaseVectorProvider] = None
+            self._provider_type: Optional[str] = None
+            self._provider_config: Dict[str, Any] | None = None
+            self._lock = asyncio.Lock()
+
+    async def _ensure_provider(self) -> BaseVectorProvider:
+        if self._provider is None:
+            await self.reload()
+        assert self._provider is not None  # for type checker
+        return self._provider
+
+    async def reload(self) -> BaseVectorProvider:
+        async with self._lock:
+            provider_type, provider_config = await VectorDBConfigManager.load_config()
+            normalized_config = dict(provider_config or {})
+            if (
+                self._provider
+                and self._provider_type == provider_type
+                and self._provider_config == normalized_config
+            ):
+                return self._provider
+
+            entry = get_provider_entry(provider_type)
+            if not entry:
+                raise RuntimeError(f"Unknown vector database provider: {provider_type}")
+            if not entry.get("enabled", True):
+                raise RuntimeError(f"Vector database provider '{provider_type}' is disabled")
+
+            provider_cls = get_provider_class(provider_type)
+            if not provider_cls:
+                raise RuntimeError(f"Provider class not found for '{provider_type}'")
+
+            provider = provider_cls(provider_config)
+            await provider.initialize()
+
+            self._provider = provider
+            self._provider_type = provider_type
+            self._provider_config = normalized_config
+            return provider
+
+    async def ensure_collection(self, collection_name: str, vector: bool = True, dim: int = DEFAULT_VECTOR_DIMENSION) -> None:
+        provider = await self._ensure_provider()
+        provider.ensure_collection(collection_name, vector, dim)
+
+    async def upsert_vector(self, collection_name: str, data: Dict[str, Any]) -> None:
+        provider = await self._ensure_provider()
+        provider.upsert_vector(collection_name, data)
+
+    async def delete_vector(self, collection_name: str, path: str) -> None:
+        provider = await self._ensure_provider()
+        provider.delete_vector(collection_name, path)
+
+    async def search_vectors(self, collection_name: str, query_embedding, top_k: int = 5):
+        provider = await self._ensure_provider()
+        return provider.search_vectors(collection_name, query_embedding, top_k)
+
+    async def search_by_path(self, collection_name: str, query_path: str, top_k: int = 20):
+        provider = await self._ensure_provider()
+        return provider.search_by_path(collection_name, query_path, top_k)
+
+    async def get_all_stats(self) -> Dict[str, Any]:
+        provider = await self._ensure_provider()
+        return provider.get_all_stats()
+
+    async def clear_all_data(self) -> None:
+        provider = await self._ensure_provider()
+        provider.clear_all_data()
+
+    async def current_provider(self) -> Dict[str, Any]:
+        provider_type, provider_config = await VectorDBConfigManager.load_config()
+        entry = get_provider_entry(provider_type) or {}
+        return {
+            "type": provider_type,
+            "config": provider_config,
+            "label": entry.get("label"),
+            "enabled": entry.get("enabled", True),
+        }

setup/foxel.sh

@@ -0,0 +1,367 @@
+#!/bin/bash
+
+#================================================================================
+# Foxel 一键部署与更新脚本
+#
+# 作者: maxage
+# 版本: 1.7 (增加下载镜像, 解决网络问题)
+# 描述: 此脚本用于自动化安装、配置和管理 Foxel 项目 (使用 Docker Compose)。
+#       - 智能检测现有安装，提供安装向导和管理菜单两种模式。
+#       - 自动检测并安装依赖。
+#       - 为国内用户提供镜像源切换选项。
+#
+# 一键运行命令:
+# bash <(curl -sL "https://raw.githubusercontent.com/DrizzleTime/Foxel/main/setup/foxel.sh?_=$(date +%s)")
+#================================================================================
+
+# --- 消息打印函数 ---
+info() {
+    echo "[信息] $1"
+}
+
+warn() {
+    echo "[警告] $1"
+}
+
+error() {
+    echo "[错误] $1"
+}
+
+# --- 基础函数 ---
+command_exists() {
+    command -v "$1" &> /dev/null
+}
+
+confirm_action() {
+    local prompt_message="$1"
+    printf "%s" "${prompt_message} (y/n): "
+    read confirmation
+    if [[ "$confirmation" =~ ^[Yy]$ ]]; then
+        return 0 # Yes
+    else
+        return 1 # No
+    fi
+}
+
+# --- IP地址检测函数 (只输出IP) ---
+get_public_ipv4() {
+    curl -4 -s --max-time 2 https://api.ipify.org || \
+    curl -4 -s --max-time 2 https://ifconfig.me/ip || \
+    curl -4 -s --max-time 2 https://icanhazip.com
+}
+
+get_public_ipv6() {
+    curl -6 -s --max-time 2 https://api64.ipify.org || \
+    curl -6 -s --max-time 2 https://ifconfig.co
+}
+
+get_private_ip() {
+    # 尝试多种方法获取最主要的内网IPv4地址
+    ip -4 route get 1.1.1.1 2>/dev/null | awk -F"src " 'NR==1{print $2}' | awk '{print $1}' || \
+    hostname -I 2>/dev/null | awk '{for(i=1;i<=NF;i++) if($i ~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/) {print $i; exit}}' || \
+    ip -4 addr 2>/dev/null | grep -oP '(?<=inet\s)\d+(\.\d+){3}' | grep -v '127.0.0.1' | head -n 1
+}
+
+
+# --- 依赖与环境检查 ---
+check_and_install_dependencies() {
+    info "正在检查所需依赖..."
+    declare -A deps=( [curl]="curl" [openssl]="openssl" [ss]="iproute2" )
+    local missing_deps=()
+    for cmd in "${!deps[@]}"; do
+        if ! command_exists "$cmd"; then
+            missing_deps+=("${deps[$cmd]}")
+        fi
+    done
+
+    if [ ${#missing_deps[@]} -gt 0 ]; then
+        warn "检测到以下依赖项缺失: ${missing_deps[*]}"
+        if confirm_action "是否尝试自动安装它们？"; then
+            local pm_cmd=""
+            if command_exists apt-get; then pm_cmd="sudo apt-get update && sudo apt-get install -y";
+            elif command_exists yum; then pm_cmd="sudo yum install -y";
+            elif command_exists dnf; then pm_cmd="sudo dnf install -y";
+            else error "未检测到 apt, yum 或 dnf。请手动安装: ${missing_deps[*]}"; exit 1; fi
+            info "即将使用命令安装: '$pm_cmd ${missing_deps[*]}'"
+            $pm_cmd "${missing_deps[@]}"
+            for cmd in "${!deps[@]}"; do
+                if ! command_exists "$cmd"; then error "依赖 '${deps[$cmd]}' 自动安装失败。"; exit 1; fi
+            done
+            info "依赖已成功安装。"
+        else
+            error "用户取消了安装。请先手动安装依赖: ${missing_deps[*]}"; exit 1
+        fi
+    else
+        info "所有基础依赖均已满足。"
+    fi
+}
+
+initialize_environment() {
+    check_and_install_dependencies
+    if ! command_exists docker; then
+        error "未找到 Docker。请参照官方文档安装: https://docs.docker.com/engine/install/"; exit 1;
+    fi
+    if ! docker info &> /dev/null; then error "Docker deamon 未在运行。请先启动 Docker。"; exit 1; fi
+    info "Docker 环境检测通过。"
+
+    if command_exists docker-compose; then COMPOSE_CMD="docker-compose";
+    elif docker compose version &> /dev/null; then COMPOSE_CMD="docker compose";
+    else error "未找到 Docker Compose。请安装 Docker Compose v1 或 v2。"; exit 1; fi
+    info "检测到 Docker Compose 命令: $COMPOSE_CMD"
+}
+
+# --- 新安装流程 ---
+install_new_foxel() {
+    info "--- 开始 Foxel 全新安装 ---"
+    local install_path
+    while true; do
+        read -p "请输入您想在哪里创建 Foxel 的数据目录 (例如: /opt/docker): " install_path
+        if [[ -z "$install_path" ]]; then warn "输入不能为空，请重新输入。"; continue; fi
+        if [ ! -d "$install_path" ]; then
+            if confirm_action "目录 '$install_path' 不存在。您想现在创建它吗？"; then
+                mkdir -p "$install_path"
+                if [ $? -eq 0 ]; then info "目录 '$install_path' 创建成功。"; break;
+                else error "创建目录 '$install_path' 失败。"; fi
+            else info "操作已取消。"; fi
+        else info "将使用已存在的目录 '$install_path'。"; break; fi
+    done
+    echo
+
+    local foxel_dir="$install_path/Foxel"
+    info "将在 '$foxel_dir' 目录中创建所需文件..."
+    mkdir -p "$foxel_dir/data/"{db,mount} && chmod 777 "$foxel_dir/data/"{db,mount}
+    if [ $? -ne 0 ]; then error "创建或设置子目录权限失败。"; exit 1; fi
+    cd "$foxel_dir" || exit
+
+    info "正在下载 'compose.yaml'..."
+    local COMPOSE_MIRROR_URL="https://ghproxy.com/https://raw.githubusercontent.com/DrizzleTime/Foxel/main/compose.yaml"
+    local COMPOSE_OFFICIAL_URL="https://raw.githubusercontent.com/DrizzleTime/Foxel/main/compose.yaml"
+    
+    if ! curl -L -o compose.yaml "$COMPOSE_MIRROR_URL"; then
+        warn "镜像源下载失败，正在尝试从官方源下载..."
+        if ! curl -L -o compose.yaml "$COMPOSE_OFFICIAL_URL"; then
+            error "下载 'compose.yaml' 失败。请检查您的网络连接。"; exit 1;
+        fi
+    fi
+    info "'compose.yaml' 下载成功。"
+    echo
+
+    if confirm_action "您的服务器是否位于中国大陆（以便为您选择更快的镜像源）？"; then
+        info "正在切换到国内镜像源..."
+        sed -i 's|^\( *\)image: ghcr.io/drizzletime/foxel:latest|\1#image: ghcr.io/drizzletime/foxel:latest|' compose.yaml
+        sed -i 's|^\( *\)#image: ghcr.nju.edu.cn/drizzletime/foxel:latest|\1image: ghcr.nju.edu.cn/drizzletime/foxel:latest|' compose.yaml
+        info "已成功切换到 ghcr.nju.edu.cn 镜像源。"
+    else
+        info "将使用默认的 ghcr.io 官方镜像源。"
+    fi
+    echo
+
+    local new_port
+    while true; do
+        read -p "请输入新的对外端口 (或直接按回车使用默认的 8088): " new_port
+        if [[ -z "$new_port" ]]; then
+            new_port="8088"
+            info "将使用默认端口 8088。"
+            break
+        fi
+
+        if ! [[ "$new_port" =~ ^[0-9]+$ ]] || [ "$new_port" -lt 1 ] || [ "$new_port" -gt 65535 ]; then
+            warn "输入无效。请输入 1-65535 之间的数字。"
+            continue
+        fi
+
+        if ss -tuln | grep -q ":${new_port}\b"; then
+            warn "端口 $new_port 已被占用，请换一个。"
+        else
+            sed -i "s/\"8088:80\"/\"$new_port:80\"/" compose.yaml
+            info "端口已成功修改为 $new_port。"
+            break
+        fi
+    done
+    echo
+
+    if ! confirm_action "是否需要生成新的随机密钥 (推荐)？(选择 'n' 将使用默认值)"; then
+        info "将使用 'compose.yaml' 文件中的默认密钥。"
+    else
+        info "正在生成新的随机密钥..."
+        sed -i "s|SECRET_KEY=.*|SECRET_KEY=$(openssl rand -base64 32)|" compose.yaml
+        sed -i "s|TEMP_LINK_SECRET_KEY=.*|TEMP_LINK_SECRET_KEY=$(openssl rand -base64 32)|" compose.yaml
+        info "新的密钥已成功生成并替换。"
+    fi
+    echo
+
+    if confirm_action "所有配置已准备就绪！您想现在启动 Foxel 项目吗？"; then
+        info "正在启动 Foxel 服务... 这可能需要一些时间来拉取镜像。"
+        $COMPOSE_CMD pull && $COMPOSE_CMD up -d
+        if [ $? -eq 0 ]; then
+            info "Foxel 部署成功！"
+            info "-------------------------------------------------"
+            info "正在检测服务器IP地址，请稍候..."
+            
+            # 先捕获所有IP地址
+            local public_ipv4=$(get_public_ipv4 2>/dev/null)
+            local public_ipv6=$(get_public_ipv6 2>/dev/null)
+            local private_ip=$(get_private_ip 2>/dev/null)
+            local final_port=$new_port
+            local ip_found=false
+
+            echo
+            info "部署完成！您可以通过以下地址访问 Foxel:"
+
+            if [[ -n "$private_ip" ]]; then
+                echo "  - 局域网地址: http://${private_ip}:${final_port}"
+                ip_found=true
+            fi
+            if [[ -n "$public_ipv4" ]]; then
+                echo "  - 公网地址 (IPv4): http://${public_ipv4}:${final_port}"
+                ip_found=true
+            fi
+            if [[ -n "$public_ipv6" ]]; then
+                # 正确格式化IPv6地址
+                echo "  - 公网地址 (IPv6): http://[${public_ipv6}]:${final_port}"
+                ip_found=true
+            fi
+
+            if ! $ip_found; then
+                warn "未能自动检测到服务器IP地址。"
+                echo "  请手动使用 http://[您的服务器IP]:${final_port} 访问它。"
+            fi
+            echo "-------------------------------------------------"
+        else 
+            error "启动 Foxel 失败。请运行 'cd $foxel_dir && $COMPOSE_CMD logs' 查看日志。"
+        fi
+    else 
+        info "操作已取消。您可以稍后进入 '$foxel_dir' 并手动运行 '$COMPOSE_CMD up -d'。"
+    fi
+}
+
+# --- 现有安装管理 ---
+get_foxel_install_dir() {
+    local data_path
+    data_path=$(docker inspect foxel --format='{{range .Mounts}}{{if eq .Destination "/app/data"}}{{.Source}}{{end}}{{end}}')
+    if [[ -n "$data_path" ]]; then
+        echo "$(dirname "$data_path")"
+    fi
+}
+
+service_menu() {
+    while true; do
+        echo
+        echo "--- 服务管理 ---"
+        echo "1. 启动 Foxel"
+        echo "2. 停止 Foxel"
+        echo "3. 重启 Foxel"
+        echo "4. 查看日志"
+        echo "5. 返回上级菜单"
+        read -p "请选择操作 [1-5]: " service_choice
+        case $service_choice in
+            1) info "正在启动..."; $COMPOSE_CMD up -d ;;
+            2) info "正在停止..."; $COMPOSE_CMD stop ;;
+            3) info "正在重启..."; $COMPOSE_CMD restart ;;
+            4) info "正在显示日志 (按 Ctrl+C 退出)..."; $COMPOSE_CMD logs -f ;;
+            5) break ;;
+            *) warn "无效输入。" ;;
+        esac
+    done
+}
+
+manage_existing_installation() {
+    info "检测到 Foxel 已安装。"
+    local foxel_dir
+    foxel_dir=$(get_foxel_install_dir)
+
+    if [[ -z "$foxel_dir" || ! -f "$foxel_dir/compose.yaml" ]]; then
+        error "无法自动定位 Foxel 的 compose.yaml 文件。"
+        read -p "请手动输入 Foxel 的安装目录 (包含 compose.yaml 的目录): " foxel_dir
+        if [[ ! -f "$foxel_dir/compose.yaml" ]]; then error "在指定目录中未找到 compose.yaml。退出。"; exit 1; fi
+    fi
+    info "Foxel 安装目录位于: $foxel_dir"
+    cd "$foxel_dir" || exit 1
+
+    while true; do
+        echo
+        echo "--- Foxel 管理菜单 ---"
+        echo "1. 更新"
+        echo "2. 卸载"
+        echo "3. 重新安装"
+        echo "4. 服务管理 (启动/停止/重启/日志)"
+        echo "5. 退出"
+        read -p "请选择操作 [1-5]: " choice
+
+        case $choice in
+            1) # 更新
+                warn "更新前，强烈建议您备份 '$foxel_dir/data' 目录！"
+                if confirm_action "您确定要继续更新吗？"; then
+                    info "正在拉取最新镜像..."
+                    $COMPOSE_CMD pull
+                    info "正在使用新镜像重新部署..."
+                    $COMPOSE_CMD up -d
+                    if [ $? -eq 0 ]; then info "Foxel 更新成功！"; else error "更新失败！"; fi
+                else info "更新操作已取消。"; fi
+                ;;
+            2) # 卸载
+                warn "这将停止并删除 Foxel 容器及相关网络！"
+                warn "强烈建议您先备份 '$foxel_dir/data' 目录！"
+                if confirm_action "您确定要继续卸载吗？"; then
+                    info "正在停止并移除容器..."
+                    $COMPOSE_CMD down
+                    if confirm_action "是否要删除所有数据卷（这将删除数据库等所有数据）？"; then
+                         $COMPOSE_CMD down -v
+                         info "数据卷已删除。"
+                    fi
+                    if confirm_action "是否要删除整个 Foxel 安装目录 '$foxel_dir'？"; then
+                        rm -rf "$foxel_dir"
+                        info "安装目录已删除。"
+                    fi
+                    info "Foxel 卸载完成。"
+                    exit 0
+                else info "卸载操作已取消。"; fi
+                ;;
+            3) # 重新安装
+                warn "重新安装将完全删除当前的 Foxel 实例（包括数据），然后进入全新安装流程。"
+                warn "在继续之前，请务必备份好您的重要数据！"
+                if confirm_action "您确定要重新安装吗？"; then
+                    info "正在执行卸载..."
+                    $COMPOSE_CMD down -v && rm -rf "$foxel_dir"
+                    info "旧实例已彻底移除。"
+                    install_new_foxel
+                    exit 0
+                else info "重新安装操作已取消。"; fi
+                ;;
+            4) # 服务管理
+                service_menu
+                ;;
+            5) # 退出
+                break
+                ;;
+            *)
+                warn "无效输入。"
+                ;;
+        esac
+    done
+}
+
+# --- 主函数 ---
+main() {
+    clear
+    local SCRIPT_VERSION="1.7"
+    echo "================================================="
+    info "欢迎使用 Foxel 一键安装与管理脚本 (版本: ${SCRIPT_VERSION})"
+    echo "================================================="
+    echo
+
+    initialize_environment
+    echo
+
+    if docker ps -a -q -f "name=^/foxel$" | grep -q .; then
+        manage_existing_installation
+    else
+        install_new_foxel
+    fi
+
+    echo
+    info "脚本执行完毕。"
+}
+
+# --- 脚本入口 ---
+main

templates/email/password_reset.html

@@ -0,0 +1,102 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <title>Foxel 密码重置</title>
+    <style>
+      body {
+        background: #f4f7fb;
+        font-family: 'Helvetica Neue', Arial, sans-serif;
+        margin: 0;
+        padding: 32px 0;
+        color: #1f2937;
+      }
+      .wrapper {
+        max-width: 560px;
+        margin: 0 auto;
+      }
+      .card {
+        background: #ffffff;
+        border-radius: 16px;
+        box-shadow: 0 12px 40px rgba(15, 23, 42, 0.12);
+        overflow: hidden;
+        border: 1px solid rgba(99, 102, 241, 0.12);
+      }
+      .header {
+        background: linear-gradient(120deg, #4f46e5, #7c3aed);
+        padding: 32px;
+        color: #ffffff;
+      }
+      .header h1 {
+        margin: 0;
+        font-size: 24px;
+        letter-spacing: 0.2px;
+      }
+      .content {
+        padding: 32px;
+      }
+      .content p {
+        margin: 16px 0;
+        line-height: 1.6;
+      }
+      .cta {
+        display: block;
+        margin: 32px 0;
+        text-align: center;
+      }
+      .cta a {
+        display: inline-block;
+        background: linear-gradient(120deg, #6366f1, #8b5cf6);
+        color: #ffffff;
+        text-decoration: none;
+        padding: 14px 32px;
+        border-radius: 999px;
+        font-weight: 600;
+        box-shadow: 0 8px 24px rgba(79, 70, 229, 0.32);
+      }
+      .info-box {
+        background: #f5f3ff;
+        border: 1px solid rgba(107, 114, 128, 0.1);
+        border-radius: 12px;
+        padding: 18px;
+        margin-top: 16px;
+      }
+      .footer {
+        padding: 24px 32px;
+        font-size: 12px;
+        color: #6b7280;
+        line-height: 1.6;
+        background: #fafafa;
+        border-top: 1px solid rgba(15, 23, 42, 0.04);
+      }
+      .footer a {
+        color: #6366f1;
+        text-decoration: none;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="wrapper">
+      <div class="card">
+        <div class="header">
+          <h1>重置你的 Foxel 密码</h1>
+        </div>
+        <div class="content">
+          <p>你好，${username}。</p>
+          <p>我们收到了重置你 Foxel 帐号密码的请求。请点击下方按钮完成密码重置操作：</p>
+          <div class="cta">
+            <a href="${reset_link}" target="_blank" rel="noopener">重置密码</a>
+          </div>
+          <p>如果按钮无法点击，你也可以复制下面的链接到浏览器打开：</p>
+          <div class="info-box">
+            <div style="word-break: break-all;">${reset_link}</div>
+          </div>
+          <p>该链接在 ${expire_minutes} 分钟内有效。若你未发起此请求，请忽略本邮件，你的密码不会发生变化。</p>
+        </div>
+        <div class="footer">
+          <div>此邮件由 Foxel 系统自动发送，请勿直接回复。</div>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>

templates/email/test.html

@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <title>Foxel 邮件配置测试</title>
+    <style>
+      body {
+        margin: 0;
+        padding: 32px 0;
+        background: linear-gradient(135deg, #eef2ff, #e0f2fe);
+        font-family: 'Helvetica Neue', Arial, sans-serif;
+        color: #0f172a;
+      }
+      .wrapper {
+        max-width: 560px;
+        margin: 0 auto;
+      }
+      .card {
+        background: #ffffff;
+        border-radius: 18px;
+        overflow: hidden;
+        box-shadow: 0 16px 40px rgba(15, 23, 42, 0.18);
+        border: 1px solid rgba(99, 102, 241, 0.08);
+      }
+      .banner {
+        background: linear-gradient(120deg, #1d4ed8, #6366f1);
+        padding: 36px;
+        color: #ffffff;
+        letter-spacing: 0.2px;
+      }
+      .banner h1 {
+        margin: 0;
+        font-size: 24px;
+      }
+      .content {
+        padding: 32px;
+        line-height: 1.7;
+      }
+      .badge {
+        display: inline-block;
+        padding: 6px 14px;
+        border-radius: 999px;
+        background: rgba(59, 130, 246, 0.12);
+        color: #1d4ed8;
+        font-weight: 600;
+        font-size: 13px;
+        margin-bottom: 16px;
+      }
+      .cta-box {
+        margin-top: 32px;
+        padding: 20px;
+        border-radius: 14px;
+        background: linear-gradient(135deg, rgba(99, 102, 241, 0.08), rgba(14, 165, 233, 0.08));
+        border: 1px solid rgba(99, 102, 241, 0.12);
+      }
+      .cta-box strong {
+        display: block;
+        margin-bottom: 8px;
+        font-size: 16px;
+      }
+      .footer {
+        padding: 24px 32px;
+        background: #f8fafc;
+        font-size: 12px;
+        color: #64748b;
+        border-top: 1px solid rgba(148, 163, 184, 0.18);
+      }
+    </style>
+  </head>
+  <body>
+    <div class="wrapper">
+      <div class="card">
+        <div class="banner">
+          <h1>Foxel 邮件服务已连通</h1>
+        </div>
+        <div class="content">
+          <div class="badge">Mail Delivery Test</div>
+          <p>你好，${username}！</p>
+          <p>
+            这是一封来自 <strong>Foxel</strong> 的测试邮件。如果你能够正常阅读到这段内容，说明系统已经成功与配置的邮箱服务建立连接。
+          </p>
+          <div class="cta-box">
+            <strong>接下来可以做什么？</strong>
+            <ul style="margin: 0; padding-left: 18px; line-height: 1.7;">
+              <li>继续完善系统通知、密码重置等业务功能</li>
+              <li>在后台页面中自定义更精美的邮件模板</li>
+              <li>保持发送凭据安全，避免泄露</li>
+            </ul>
+          </div>
+        </div>
+        <div class="footer">
+          本邮件由 Foxel 系统自动发送，请勿直接回复。如非本人操作，请忽略此邮件。
+        </div>
+      </div>
+    </div>
+  </body>
+</html>

web/bun.lock

@@ -6,9 +6,12 @@
       "dependencies": {
         "@ant-design/icons": "5.x",
         "@ant-design/v5-patch-for-react-19": "^1.0.3",
+        "@monaco-editor/react": "^4.7.0",
         "@uiw/react-md-editor": "^4.0.8",
         "antd": "^5.27.0",
+        "artplayer": "^5.2.5",
         "date-fns": "^4.1.0",
+        "monaco-editor": "^0.53.0",
         "react": "^19.1.1",
         "react-dom": "^19.1.1",
         "react-markdown": "^10.1.0",
@@ -178,6 +181,10 @@
 
     "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.30", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q=="],
 
+    "@monaco-editor/loader": ["@monaco-editor/loader@1.5.0", "", { "dependencies": { "state-local": "^1.0.6" } }, "sha512-hKoGSM+7aAc7eRTRjpqAZucPmoNOC4UUbknb/VNoTkEIkCPhqV8LfbsgM1webRM7S/z21eHEx9Fkwx8Z/C/+Xw=="],
+
+    "@monaco-editor/react": ["@monaco-editor/react@4.7.0", "", { "dependencies": { "@monaco-editor/loader": "^1.5.0" }, "peerDependencies": { "monaco-editor": ">= 0.25.0 < 1", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-cyzXQCtO47ydzxpQtCGSQGOC8Gk3ZUeBXFAxD+CWXYFo5OqZyZUonFl0DwUlTyAfRHntBfw2p3w4s9R6oe1eCA=="],
+
     "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
 
     "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
@@ -272,6 +279,8 @@
 
     "@types/react-dom": ["@types/react-dom@19.1.7", "", { "peerDependencies": { "@types/react": "^19.0.0" } }, "sha512-i5ZzwYpqjmrKenzkoLM2Ibzt6mAsM7pxB6BCIouEVVmgiqaMj1TjaK7hnA36hbW5aZv20kx7Lw6hWzPWg0Rurw=="],
 
+    "@types/trusted-types": ["@types/trusted-types@1.0.6", "", {}, "sha512-230RC8sFeHoT6sSUlRO6a8cAnclO06eeiq1QDfiv2FGCLWFvvERWgwIQD4FWqD9A69BN7Lzee4OXwoMVnnsWDw=="],
+
     "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
 
     "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@8.39.1", "", { "dependencies": { "@eslint-community/regexpp": "^4.10.0", "@typescript-eslint/scope-manager": "8.39.1", "@typescript-eslint/type-utils": "8.39.1", "@typescript-eslint/utils": "8.39.1", "@typescript-eslint/visitor-keys": "8.39.1", "graphemer": "^1.4.0", "ignore": "^7.0.0", "natural-compare": "^1.4.0", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "@typescript-eslint/parser": "^8.39.1", "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-yYegZ5n3Yr6eOcqgj2nJH8cH/ZZgF+l0YIdKILSDjYFRjgYQMgv/lRjV5Z7Up04b9VYUondt8EPMqg7kTWgJ2g=="],
@@ -316,6 +325,8 @@
 
     "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
 
+    "artplayer": ["artplayer@5.2.5", "", { "dependencies": { "option-validator": "^2.0.6" } }, "sha512-Ogym5rvkAJ4VLncM4Apl3TJ/a/ozM3csvY4IKuuMR++hUmEZgj/HaGsNonwx8r56nsqiZYE7O4vS1HFZl+NBSg=="],
+
     "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
 
     "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
@@ -532,6 +543,8 @@
 
     "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="],
 
+    "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="],
+
     "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="],
 
     "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
@@ -636,6 +649,8 @@
 
     "minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="],
 
+    "monaco-editor": ["monaco-editor@0.53.0", "", { "dependencies": { "@types/trusted-types": "^1.0.6" } }, "sha512-0WNThgC6CMWNXXBxTbaYYcunj08iB5rnx4/G56UOPeL9UVIUGGHA1GR0EWIh9Ebabj7NpCRawQ5b0hfN1jQmYQ=="],
+
     "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
 
     "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
@@ -646,6 +661,8 @@
 
     "nth-check": ["nth-check@2.1.1", "", { "dependencies": { "boolbase": "^1.0.0" } }, "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w=="],
 
+    "option-validator": ["option-validator@2.0.6", "", { "dependencies": { "kind-of": "^6.0.3" } }, "sha512-tmZDan2LRIRQyhUGvkff68/O0R8UmF+Btmiiz0SmSw2ng3CfPZB9wJlIjHpe/MKUZqyIZkVIXCrwr1tIN+0Dzg=="],
+
     "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="],
 
     "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
@@ -816,6 +833,8 @@
 
     "space-separated-tokens": ["space-separated-tokens@2.0.2", "", {}, "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q=="],
 
+    "state-local": ["state-local@1.0.7", "", {}, "sha512-HTEHMNieakEnoe33shBYcZ7NX83ACUjCu8c40iOGEZsngj9zRnkqS9j1pqQPXwobB0ZcVTk27REb7COQ0UR59w=="],
+
     "string-convert": ["string-convert@0.2.1", "", {}, "sha512-u/1tdPl4yQnPBjnVrmdLo9gtuLvELKsAoRapekWggdiQNvvvum+jYF329d84NAa660KQw7pB2n36KrIKVoXa3A=="],
 
     "stringify-entities": ["stringify-entities@4.0.4", "", { "dependencies": { "character-entities-html4": "^2.0.0", "character-entities-legacy": "^3.0.0" } }, "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg=="],

web/index.html

@@ -1,13 +1,20 @@
 <!doctype html>
-<html lang="en">
+<html lang="zh-CN">
 
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Foxel</title>
+  <link rel='stylesheet'
+    href='https://chinese-fonts-cdn.deno.dev/packages/maple-mono-cn/dist/MapleMono-CN-Regular/result.css' />
 </head>
 
 <body>
+  <style>
+    * {
+      font-family: 'Maple Mono CN';
+    }
+  </style>
   <div id="root"></div>
   <script type="module" src="/src/main.tsx"></script>
 </body>

web/package.json

@@ -12,9 +12,12 @@
   "dependencies": {
     "@ant-design/icons": "5.x",
     "@ant-design/v5-patch-for-react-19": "^1.0.3",
+    "@monaco-editor/react": "^4.7.0",
     "@uiw/react-md-editor": "^4.0.8",
     "antd": "^5.27.0",
+    "artplayer": "^5.2.5",
     "date-fns": "^4.1.0",
+    "monaco-editor": "^0.53.0",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",
     "react-markdown": "^10.1.0",

web/public/icon/claude-color.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude</title><path d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z" fill="#D97757" fill-rule="nonzero"></path></svg>

web/public/icon/deepseek-color.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>DeepSeek</title><path d="M23.748 4.482c-.254-.124-.364.113-.512.234-.051.039-.094.09-.137.136-.372.397-.806.657-1.373.626-.829-.046-1.537.214-2.163.848-.133-.782-.575-1.248-1.247-1.548-.352-.156-.708-.311-.955-.65-.172-.241-.219-.51-.305-.774-.055-.16-.11-.323-.293-.35-.2-.031-.278.136-.356.276-.313.572-.434 1.202-.422 1.84.027 1.436.633 2.58 1.838 3.393.137.093.172.187.129.323-.082.28-.18.552-.266.833-.055.179-.137.217-.329.14a5.526 5.526 0 01-1.736-1.18c-.857-.828-1.631-1.742-2.597-2.458a11.365 11.365 0 00-.689-.471c-.985-.957.13-1.743.388-1.836.27-.098.093-.432-.779-.428-.872.004-1.67.295-2.687.684a3.055 3.055 0 01-.465.137 9.597 9.597 0 00-2.883-.102c-1.885.21-3.39 1.102-4.497 2.623C.082 8.606-.231 10.684.152 12.85c.403 2.284 1.569 4.175 3.36 5.653 1.858 1.533 3.997 2.284 6.438 2.14 1.482-.085 3.133-.284 4.994-1.86.47.234.962.327 1.78.397.63.059 1.236-.03 1.705-.128.735-.156.684-.837.419-.961-2.155-1.004-1.682-.595-2.113-.926 1.096-1.296 2.746-2.642 3.392-7.003.05-.347.007-.565 0-.845-.004-.17.035-.237.23-.256a4.173 4.173 0 001.545-.475c1.396-.763 1.96-2.015 2.093-3.517.02-.23-.004-.467-.247-.588zM11.581 18c-2.089-1.642-3.102-2.183-3.52-2.16-.392.024-.321.471-.235.763.09.288.207.486.371.739.114.167.192.416-.113.603-.673.416-1.842-.14-1.897-.167-1.361-.802-2.5-1.86-3.301-3.307-.774-1.393-1.224-2.887-1.298-4.482-.02-.386.093-.522.477-.592a4.696 4.696 0 011.529-.039c2.132.312 3.946 1.265 5.468 2.774.868.86 1.525 1.887 2.202 2.891.72 1.066 1.494 2.082 2.48 2.914.348.292.625.514.891.677-.802.09-2.14.11-3.054-.614zm1-6.44a.306.306 0 01.415-.287.302.302 0 01.2.288.306.306 0 01-.31.307.303.303 0 01-.304-.308zm3.11 1.596c-.2.081-.399.151-.59.16a1.245 1.245 0 01-.798-.254c-.274-.23-.47-.358-.552-.758a1.73 1.73 0 01.016-.588c.07-.327-.008-.537-.239-.727-.187-.156-.426-.199-.688-.199a.559.559 0 01-.254-.078c-.11-.054-.2-.19-.114-.358.028-.054.16-.186.192-.21.356-.202.767-.136 1.146.016.352.144.618.408 1.001.782.391.451.462.576.685.914.176.265.336.537.445.848.067.195-.019.354-.25.452z" fill="#4D6BFE"></path></svg>

web/public/icon/gemini-color.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Gemini</title><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="#3186FF"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-fill-0)"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-fill-1)"></path><path d="M20.616 10.835a14.147 14.147 0 01-4.45-3.001 14.111 14.111 0 01-3.678-6.452.503.503 0 00-.975 0 14.134 14.134 0 01-3.679 6.452 14.155 14.155 0 01-4.45 3.001c-.65.28-1.318.505-2.002.678a.502.502 0 000 .975c.684.172 1.35.397 2.002.677a14.147 14.147 0 014.45 3.001 14.112 14.112 0 013.679 6.453.502.502 0 00.975 0c.172-.685.397-1.351.677-2.003a14.145 14.145 0 013.001-4.45 14.113 14.113 0 016.453-3.678.503.503 0 000-.975 13.245 13.245 0 01-2.003-.678z" fill="url(#lobe-icons-gemini-fill-2)"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-fill-0" x1="7" x2="11" y1="15.5" y2="12"><stop stop-color="#08B962"></stop><stop offset="1" stop-color="#08B962" stop-opacity="0"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-fill-1" x1="8" x2="11.5" y1="5.5" y2="11"><stop stop-color="#F94543"></stop><stop offset="1" stop-color="#F94543" stop-opacity="0"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-gemini-fill-2" x1="3.5" x2="17.5" y1="13.5" y2="12"><stop stop-color="#FABC12"></stop><stop offset=".46" stop-color="#FABC12" stop-opacity="0"></stop></linearGradient></defs></svg>

web/public/icon/openai.svg

@@ -0,0 +1 @@
+<svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>OpenAI</title><path d="M21.55 10.004a5.416 5.416 0 00-.478-4.501c-1.217-2.09-3.662-3.166-6.05-2.66A5.59 5.59 0 0010.831 1C8.39.995 6.224 2.546 5.473 4.838A5.553 5.553 0 001.76 7.496a5.487 5.487 0 00.691 6.5 5.416 5.416 0 00.477 4.502c1.217 2.09 3.662 3.165 6.05 2.66A5.586 5.586 0 0013.168 23c2.443.006 4.61-1.546 5.361-3.84a5.553 5.553 0 003.715-2.66 5.488 5.488 0 00-.693-6.497v.001zm-8.381 11.558a4.199 4.199 0 01-2.675-.954c.034-.018.093-.05.132-.074l4.44-2.53a.71.71 0 00.364-.623v-6.176l1.877 1.069c.02.01.033.029.036.05v5.115c-.003 2.274-1.87 4.118-4.174 4.123zM4.192 17.78a4.059 4.059 0 01-.498-2.763c.032.02.09.055.131.078l4.44 2.53c.225.13.504.13.73 0l5.42-3.088v2.138a.068.068 0 01-.027.057L9.9 19.288c-1.999 1.136-4.552.46-5.707-1.51h-.001zM3.023 8.216A4.15 4.15 0 015.198 6.41l-.002.151v5.06a.711.711 0 00.364.624l5.42 3.087-1.876 1.07a.067.067 0 01-.063.005l-4.489-2.559c-1.995-1.14-2.679-3.658-1.53-5.63h.001zm15.417 3.54l-5.42-3.088L14.896 7.6a.067.067 0 01.063-.006l4.489 2.557c1.998 1.14 2.683 3.662 1.529 5.633a4.163 4.163 0 01-2.174 1.807V12.38a.71.71 0 00-.363-.623zm1.867-2.773a6.04 6.04 0 00-.132-.078l-4.44-2.53a.731.731 0 00-.729 0l-5.42 3.088V7.325a.068.068 0 01.027-.057L14.1 4.713c2-1.137 4.555-.46 5.707 1.513.487.833.664 1.809.499 2.757h.001zm-11.741 3.81l-1.877-1.068a.065.065 0 01-.036-.051V6.559c.001-2.277 1.873-4.122 4.181-4.12.976 0 1.92.338 2.671.954-.034.018-.092.05-.131.073l-4.44 2.53a.71.71 0 00-.365.623l-.003 6.173v.002zm1.02-2.168L12 9.25l2.414 1.375v2.75L12 14.75l-2.415-1.375v-2.75z"></path></svg>

web/public/icon/siliconcloud-color.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>SiliconCloud</title><path clip-rule="evenodd" d="M22.956 6.521H12.522c-.577 0-1.044.468-1.044 1.044v3.13c0 .577-.466 1.044-1.043 1.044H1.044c-.577 0-1.044.467-1.044 1.044v4.174C0 17.533.467 18 1.044 18h10.434c.577 0 1.044-.467 1.044-1.043v-3.13c0-.578.466-1.044 1.043-1.044h9.391c.577 0 1.044-.467 1.044-1.044V7.565c0-.576-.467-1.044-1.044-1.044z" fill="#6E29F6" fill-rule="evenodd"></path></svg>

web/src/App.tsx

@@ -4,11 +4,13 @@ import { AuthProvider } from './contexts/AuthContext.tsx';
 import { status as getStatus } from './api/config.ts';
 import type { SystemStatus } from './api/config.ts';
 import { SystemContext } from './contexts/SystemContext.tsx';
+import { ThemeProvider } from './contexts/ThemeContext.tsx';
 import { Spin } from 'antd';
 import { Routes, Route, Navigate } from 'react-router';
 import SetupPage from './pages/SetupPage.tsx';
+import { I18nProvider } from './i18n';
 
-function App() {
+function AppInner() {
   const [status, setStatus] = useState<SystemStatus | null>(null);
   useEffect(() => {
     async function checkInitialization() {
@@ -16,9 +18,14 @@ function App() {
         const status = await getStatus();
         setStatus(status);
         document.title = status.title;
-        const favicon = document.querySelector("link[rel*='icon']") as HTMLLinkElement;
+        let favicon = document.querySelector("link[rel*='icon']") as HTMLLinkElement | null;
+        if (!favicon) {
+          favicon = document.createElement('link');
+          favicon.rel = 'icon';
+          document.head.appendChild(favicon);
+        }
         if (favicon) {
-          favicon.href = status.logo;
+          favicon.href = status.favicon || status.logo;
         }
       } catch (error) {
         console.error("Failed to check initialization status:", error);
@@ -38,17 +45,25 @@ function App() {
   return (
     <SystemContext.Provider value={status}>
       <AuthProvider>
-        {!status.is_initialized ? (
-          <Routes>
-            <Route path="/setup" element={<SetupPage />} />
-            <Route path="*" element={<Navigate to="/setup" replace />} />
-          </Routes>
-        ) : (
-          <AppRouter />
-        )}
+        <ThemeProvider>
+          {!status.is_initialized ? (
+            <Routes>
+              <Route path="/setup" element={<SetupPage />} />
+              <Route path="*" element={<Navigate to="/setup" replace />} />
+            </Routes>
+          ) : (
+            <AppRouter />
+          )}
+        </ThemeProvider>
       </AuthProvider>
     </SystemContext.Provider>
   );
 }
 
-export default App;
+export default function App() {
+  return (
+    <I18nProvider>
+      <AppInner />
+    </I18nProvider>
+  );
+}

web/src/api/adapters.ts

@@ -6,14 +6,14 @@ export interface AdapterItem {
   type: string;
   config: any;
   enabled: boolean;
-  mount_path?: string | null;
+  path?: string | null;
   sub_path?: string | null;
 }
 
 export interface AdapterTypeField {
   key: string;
   label: string;
-  type: 'string' | 'password' | 'number';
+  type: 'string' | 'password' | 'number' | 'boolean';
   required?: boolean;
   placeholder?: string;
   default?: any;

web/src/api/aiProviders.ts

@@ -0,0 +1,89 @@
+import request from './client';
+
+export type AIAbility = 'chat' | 'vision' | 'embedding' | 'rerank' | 'voice' | 'tools';
+
+export interface AIProviderPayload {
+  name: string;
+  identifier: string;
+  provider_type?: string | null;
+  api_format: 'openai' | 'gemini';
+  base_url?: string | null;
+  api_key?: string | null;
+  logo_url?: string | null;
+  extra_config?: Record<string, unknown> | null;
+}
+
+export interface AIProvider extends Omit<AIProviderPayload, 'extra_config'> {
+  id: number;
+  extra_config: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+  models?: AIModel[];
+}
+
+export interface AIModelPayload {
+  name: string;
+  display_name?: string | null;
+  description?: string | null;
+  capabilities?: AIAbility[];
+  context_window?: number | null;
+  embedding_dimensions?: number | null;
+  metadata?: Record<string, unknown> | null;
+}
+
+export interface AIModel extends Omit<AIModelPayload, 'metadata'> {
+  id: number;
+  provider_id: number;
+  metadata: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+  provider?: AIProvider;
+}
+
+export type AIDefaultAssignments = Partial<Record<AIAbility, number | null>>;
+export type AIDefaultModels = Partial<Record<AIAbility, AIModel | null>>;
+
+export async function fetchProviders() {
+  const data = await request<{ providers: AIProvider[] }>('/ai/providers');
+  return data.providers;
+}
+
+export async function createProvider(payload: AIProviderPayload) {
+  return request<AIProvider>('/ai/providers', { method: 'POST', json: payload });
+}
+
+export async function updateProvider(id: number, payload: Partial<AIProviderPayload>) {
+  return request<AIProvider>(`/ai/providers/${id}`, { method: 'PUT', json: payload });
+}
+
+export async function deleteProvider(id: number) {
+  await request(`/ai/providers/${id}`, { method: 'DELETE' });
+}
+
+export async function syncProviderModels(id: number) {
+  return request<{ created: number; updated: number }>(`/ai/providers/${id}/sync-models`, { method: 'POST' });
+}
+
+export async function fetchRemoteModels(providerId: number) {
+  return request<{ models: AIModelPayload[] }>(`/ai/providers/${providerId}/remote-models`);
+}
+
+export async function createModel(providerId: number, payload: AIModelPayload) {
+  return request<AIModel>(`/ai/providers/${providerId}/models`, { method: 'POST', json: payload });
+}
+
+export async function updateModel(modelId: number, payload: Partial<AIModelPayload>) {
+  return request<AIModel>(`/ai/models/${modelId}`, { method: 'PUT', json: payload });
+}
+
+export async function deleteModel(modelId: number) {
+  await request(`/ai/models/${modelId}`, { method: 'DELETE' });
+}
+
+export async function fetchDefaults() {
+  return request<AIDefaultModels>('/ai/defaults');
+}
+
+export async function updateDefaults(payload: AIDefaultAssignments) {
+  return request<AIDefaultModels>('/ai/defaults', { method: 'PUT', json: payload });
+}

web/src/api/auth.ts

@@ -17,6 +17,30 @@ export interface AuthResponse {
   token_type: string;
 }
 
+export interface MeResponse {
+  id: number;
+  username: string;
+  email?: string | null;
+  full_name?: string | null;
+  gravatar_url: string;
+}
+
+export interface UpdateMePayload {
+  email?: string | null;
+  full_name?: string | null;
+  old_password?: string;
+  new_password?: string;
+}
+
+export interface PasswordResetRequestPayload {
+  email: string;
+}
+
+export interface PasswordResetConfirmPayload {
+  token: string;
+  password: string;
+}
+
 export const authApi = {
   register: async (username: string, password: string, email?: string, full_name?: string): Promise<any> => {
     return request('/auth/register', {
@@ -42,4 +66,30 @@ export const authApi = {
   logout: () => {
     localStorage.removeItem('token');
   },
+  me: async () => {
+    return await request<MeResponse>('/auth/me', {
+      method: 'GET',
+    });
+  },
+  updateMe: async (payload: UpdateMePayload) => {
+    return await request<MeResponse>('/auth/me', {
+      method: 'PUT',
+      json: payload,
+    });
+  },
+  requestPasswordReset: async (payload: PasswordResetRequestPayload) => {
+    return await request('/auth/password-reset/request', {
+      method: 'POST',
+      json: payload,
+    });
+  },
+  verifyPasswordResetToken: async (token: string) => {
+    return await request<{ username: string; email: string }>('/auth/password-reset/verify?token=' + encodeURIComponent(token));
+  },
+  confirmPasswordReset: async (payload: PasswordResetConfirmPayload) => {
+    return await request('/auth/password-reset/confirm', {
+      method: 'POST',
+      json: payload,
+    });
+  },
 };

web/src/api/client.ts

@@ -73,4 +73,5 @@ async function request<T = any>(url: string, options: RequestOptions = {}): Prom
 export { vfsApi, type VfsEntry, type DirListing } from './vfs';
 export { adaptersApi, type AdapterItem, type AdapterTypeField, type AdapterTypeMeta } from './adapters';
 export { shareApi, type ShareInfo, type ShareInfoWithPassword } from './share';
+export { offlineDownloadsApi, type OfflineDownloadTask, type OfflineDownloadCreate, type TaskProgress } from './offlineDownloads';
 export default request;