feat: Update version to v1.1.2

.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.yml

@@ -32,7 +32,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

.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,5 @@ __pycache__/
 .venv/
 .vscode/
 data/
-
+migrate/
 .env

Dockerfile

@@ -13,11 +13,13 @@ 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 nginx git && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt && pip install gunicorn
 
+RUN git clone https://github.com/DrizzleTime/FoxelUpgrade /app/migrate
+
 COPY --from=frontend-builder /app/web/dist /app/web/dist
 
 COPY . .

README.md

@@ -16,6 +16,12 @@
   </blockquote>
 </div>
 
+## 👀 在线体验
+
+> [https://demo.foxel.cc](https://demo.foxel.cc)
+>
+> 账号/密码：`admin` / `admin`
+
 ## ✨ 核心功能
 
 - **统一文件管理**：集中管理分布于不同存储后端的文件。

api/routers.py

@@ -1,13 +1,12 @@
 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
 
 
 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)

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,26 +39,21 @@ 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
+
+    rec = await StorageAdapter.create(**adapter_fields)
     await runtime_registry.refresh()
     await LogService.action(
         "route:adapters",
@@ -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,33 +104,23 @@ 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 LogService.action(
         "route:adapters",

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/virtual_fs.py

@@ -116,7 +116,7 @@ async def get_thumb(
     if not is_image_filename(rel):
         raise HTTPException(404, detail="Not an image")
     # 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,

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

main.py

@@ -1,21 +1,22 @@
+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
 
 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):
     await init_db()
     await runtime_registry.refresh()
+    await ConfigCenter.set("APP_VERSION", VERSION)
     try:
         yield
     finally:

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)

requirements.txt

@@ -1,14 +1,27 @@
+aioboto3==15.1.0
+aiobotocore==2.24.0
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aioitertools==0.12.0
+aiosignal==1.4.0
 aiosqlite==0.21.0
 annotated-types==0.7.0
 anyio==4.10.0
+asyncclick==8.2.2.2
+attrs==25.3.0
 bcrypt==4.3.0
+boto3==1.39.11
+botocore==1.39.11
 certifi==2025.8.3
 click==8.2.1
+dictdiffer==0.9.0
 dnspython==2.7.0
 email_validator==2.2.0
 fastapi==0.116.1
 fastapi-cli==0.0.8
 fastapi-cloud-cli==0.1.5
+frozenlist==1.7.0
 grpcio==1.74.0
 h11==0.16.0
 httpcore==1.0.9
@@ -18,14 +31,17 @@ idna==3.10
 imageio==2.37.0
 iso8601==2.1.0
 Jinja2==3.1.6
+jmespath==1.0.1
 markdown-it-py==4.0.0
 MarkupSafe==3.0.2
 mdurl==0.1.2
 milvus-lite==2.5.1
+multidict==6.6.4
 numpy==2.3.2
 pandas==2.3.1
 passlib==1.7.4
 pillow==11.3.0
+propcache==0.3.2
 protobuf==6.32.0
 pyaes==1.6.1
 pyasn1==0.6.1
@@ -46,6 +62,7 @@ rich==14.1.0
 rich-toolkit==0.15.0
 rignore==0.6.4
 rsa==4.9.1
+s3transfer==0.13.1
 sentry-sdk==2.35.0
 setuptools==80.9.0
 shellingham==1.5.4
@@ -65,3 +82,5 @@ uvicorn==0.35.0
 uvloop==0.21.0
 watchfiles==1.1.0
 websockets==15.0.1
+wrapt==1.17.3
+yarl==1.20.1

schemas/__init__.py

@@ -1,12 +1,9 @@
 from .adapters import AdapterCreate, AdapterOut
-from .mounts import MountCreate, MountOut
 from .fs import MkdirRequest, MoveRequest
 
 __all__ = [
     "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/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

services/adapters/onedrive.py

@@ -0,0 +1,431 @@
+from __future__ import annotations
+from datetime import datetime, timezone, timedelta
+from typing import List, Dict, Tuple, AsyncIterator
+import httpx
+from fastapi.responses import StreamingResponse
+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("/")
+
+        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() 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() as client:
+            resp = await client.request(method, url, headers=headers, **kwargs)
+            # 如果 token 过期 (401)，刷新并重试一次
+            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) -> Tuple[List[Dict], int]:
+        """
+        列出目录内容。
+        :param root: 根路径 (在此适配器中未使用，通过配置的 root 确定)。
+        :param rel: 相对路径。
+        :param page_num: 页码。
+        :param page_size: 每页大小。
+        :return: 文件/目录列表和总数。
+        """
+        api_path = self._get_api_path(rel)
+        children_path = f"{api_path}:/children" if api_path else "/children"
+
+        # Graph API 的分页是基于 @odata.nextLink token 的。
+        # 为了支持自定义排序（文件夹在前），我们必须获取所有项目，
+        # 然后在内存中进行排序和分页。此版本通过处理分页链接来稳健地获取所有项目。
+        all_items = []
+
+        # 初始请求
+        resp = await self._request("GET", api_path_segment=children_path, params={"$top": 200})
+
+        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]
+        # 排序：文件夹在前，然后按名称排序
+        formatted_items.sort(key=lambda x: (
+            not x["is_dir"], x["name"].lower()))
+
+        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() 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_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() 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": "默认为根目录 /"},
+]
+
+
+def ADAPTER_FACTORY(rec): return OneDriveAdapter(rec)

services/adapters/s3.py

@@ -0,0 +1,366 @@
+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) -> 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",
+                        })
+
+        # 在内存中排序和分页
+        all_items.sort(key=lambda x: (not x["is_dir"], x["name"].lower()))
+        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/telegram.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+from typing import List, Dict, Tuple, AsyncIterator
+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) -> 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=50)
+            for message in messages:
+                if message and (message.document or message.video):
+                    media = message.document or message.video
+                    filename = None
+                    if hasattr(media, 'attributes'):
+                        for attr in media.attributes:
+                            if hasattr(attr, 'file_name') and attr.file_name:
+                                filename = attr.file_name
+                                break
+                    
+                    if not filename:
+                        if message.text and '.' in message.text:
+                             if len(message.text) < 256 and '\n' not in message.text:
+                                  filename = message.text
+
+                    if not filename:
+                        filename = "Unknown"
+                    
+                    entries.append({
+                        "name": f"{message.id}_{filename}",
+                        "is_dir": False,
+                        "size": media.size,
+                        "mtime": int(message.date.timestamp()),
+                        "type": "file",
+                    })
+        finally:
+            if client.is_connected():
+                await client.disconnect()
+
+        return entries, len(entries)
+
+    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):
+                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):
+        raise NotImplementedError("Telegram 适配器是只读的，不支持写入文件。")
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        raise NotImplementedError("Telegram 适配器是只读的，不支持流式写入文件。")
+
+    async def mkdir(self, root: str, rel: str):
+        raise NotImplementedError("Telegram 适配器是只读的，不支持创建目录。")
+
+    async def delete(self, root: str, rel: str):
+        raise NotImplementedError("Telegram 适配器是只读的，不支持删除。")
+
+    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)
+            if not message or not (message.document or message.video):
+                raise FileNotFoundError(f"在频道 {self.chat_id} 中未找到消息ID为 {message_id} 的文件")
+            
+            media = message.document or message.video
+            file_size = media.size
+            
+            start = 0
+            end = file_size - 1
+            status = 200
+            
+            headers = {
+                "Accept-Ranges": "bytes",
+                "Content-Type": media.mime_type or "application/octet-stream",
+                "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)
+            if not message or not (message.document or message.video):
+                raise FileNotFoundError(f"在频道 {self.chat_id} 中未找到消息ID为 {message_id} 的文件")
+            
+            media = message.document or message.video
+            return {
+                "name": rel,
+                "is_dir": False,
+                "size": media.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/ai.py

@@ -2,13 +2,14 @@ import httpx
 from typing import List
 from services.config import ConfigCenter
 
+
 async def describe_image_base64(base64_image: str, detail: str = "high") -> str:
     """
     传入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", "")
+    OAI_API_URL = await ConfigCenter.get("AI_VISION_API_URL")
+    VISION_MODEL = await ConfigCenter.get("AI_VISION_MODEL")
+    API_KEY = await ConfigCenter.get("AI_VISION_API_KEY")
     payload = {
         "model": VISION_MODEL,
         "messages": [
@@ -42,13 +43,14 @@ async def describe_image_base64(base64_image: str, detail: str = "high") -> str:
     except Exception as e:
         return f"请求失败: {str(e)}"
 
+
 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", "")
+    OAI_API_URL = await ConfigCenter.get("AI_EMBED_API_URL")
+    EMBED_MODEL = await ConfigCenter.get("AI_EMBED_MODEL")
+    API_KEY = await ConfigCenter.get("AI_EMBED_API_KEY")
     payload = {
         "model": EMBED_MODEL,
         "input": text
@@ -58,7 +60,11 @@ async def get_text_embedding(text: str) -> List[float]:
         "Content-Type": "application/json"
     }
     async with httpx.AsyncClient() as client:
-        resp = await client.post(OAI_API_URL.replace("chat/completions", "embeddings"), headers=headers, json=payload)
+        if OAI_API_URL.endswith("chat/completions"):
+            url = OAI_API_URL.replace("chat/completions", "embeddings")
+        else:
+            url = OAI_API_URL
+        resp = await client.post(url, headers=headers, json=payload)
         resp.raise_for_status()
         result = resp.json()
         return result["data"][0]["embedding"]

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.1.2"
 
 class ConfigCenter:
     _cache: Dict[str, Any] = {}

services/thumbnail.py

@@ -5,7 +5,8 @@ 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
 CACHE_ROOT = Path('data/.thumb_cache')
@@ -49,11 +50,12 @@ def generate_thumb(data: bytes, w: int, h: int, fit: str, is_raw: bool = False)
                     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)
+                    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}")
@@ -87,18 +89,48 @@ def generate_thumb(data: bytes, w: int, h: int, fit: str, is_raw: bool = False)
 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)
+        raise HTTPException(400, detail="Image too large for thumbnail")
+
+    key = _cache_key(adapter_id, rel, stat['size'], int(
+        stat['mtime']), 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:
+        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/virtual_fs.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Dict, Tuple, Any, Union, AsyncIterator
 from fastapi import HTTPException
 import mimetypes
@@ -8,7 +7,7 @@ import hmac
 import hashlib
 import base64
 
-from models import Mount
+from models import StorageAdapter
 from .adapters.registry import runtime_registry
 from api.response import page
 from .thumbnail import is_image_filename, is_raw_filename
@@ -18,16 +17,16 @@ from services.logging import LogService
 from services.config import ConfigCenter
 
 
-async def resolve_mount(path: str) -> Tuple[Mount, str]:
+async def resolve_adapter_by_path(path: str) -> Tuple[StorageAdapter, str]:
     norm = path if path.startswith('/') else '/' + path
-    mounts = await Mount.filter(enabled=True)
+    adapters = await StorageAdapter.filter(enabled=True)
     best = None
-    for m in mounts:
-        if norm == m.path or norm.startswith(m.path.rstrip('/') + '/'):
-            if (best is None) or len(m.path) > len(best.path):
-                best = m
+    for a in adapters:
+        if norm == a.path or norm.startswith(a.path.rstrip('/') + '/'):
+            if (best is None) or len(a.path) > len(best.path):
+                best = a
     if not best:
-        raise HTTPException(404, detail="No mount for path")
+        raise HTTPException(404, detail="No storage adapter for path")
     rel = norm[len(best.path):].lstrip('/')
     return best, rel
 
@@ -35,16 +34,22 @@ async def resolve_mount(path: str) -> Tuple[Mount, str]:
 
 
 async def resolve_adapter_and_rel(path: str):
-    """返回 (adapter_instance, mount, effective_root, rel_path)."""
+    """返回 (adapter_instance, adapter_model, effective_root, rel_path)."""
     norm = path if path.startswith('/') else '/' + path
     try:
-        mount, rel = await resolve_mount(norm)
+        adapter_model, rel = await resolve_adapter_by_path(norm)
     except HTTPException as e:
         raise e
-    await mount.fetch_related("adapter")
-    adapter_instance = runtime_registry.get(mount.adapter_id)
-    effective_root = adapter_instance.get_effective_root(mount.sub_path)
-    return adapter_instance, mount, effective_root, rel
+    adapter_instance = runtime_registry.get(adapter_model.id)
+    if not adapter_instance:
+        await runtime_registry.refresh()
+        adapter_instance = runtime_registry.get(adapter_model.id)
+        if not adapter_instance:
+            raise HTTPException(
+                404, detail=f"Adapter instance for ID {adapter_model.id} not found or failed to load."
+            )
+    effective_root = adapter_instance.get_effective_root(adapter_model.sub_path)
+    return adapter_instance, adapter_model, effective_root, rel
 
 
 async def _ensure_method(adapter: Any, method: str):
@@ -56,27 +61,35 @@ async def _ensure_method(adapter: Any, method: str):
 
 async def list_virtual_dir(path: str, page_num: int = 1, page_size: int = 50) -> Dict:
     norm = (path if path.startswith('/') else '/' + path).rstrip('/') or '/'
-    mounts = await Mount.filter(enabled=True).prefetch_related("adapter")
+    adapters = await StorageAdapter.filter(enabled=True)
 
     child_mount_entries = []
     norm_prefix = norm.rstrip('/')
-    for m in mounts:
-        if m.path == norm:
+    for a in adapters:
+        if a.path == norm:
             continue
-        if m.path.startswith(norm_prefix + '/'):
-            tail = m.path[len(norm_prefix):].lstrip('/')
+        if a.path.startswith(norm_prefix + '/'):
+            tail = a.path[len(norm_prefix):].lstrip('/')
             if '/' not in tail:
                 child_mount_entries.append(tail)
     child_mount_entries = sorted(set(child_mount_entries))
 
     try:
-        mount, rel = await resolve_mount(norm)
-        await mount.fetch_related("adapter")
-        adapter = runtime_registry.get(mount.adapter_id)
-        effective_root = adapter.get_effective_root(mount.sub_path)
+        adapter_model, rel = await resolve_adapter_by_path(norm)
+        adapter_instance = runtime_registry.get(adapter_model.id)
+        if not adapter_instance:
+            await runtime_registry.refresh()
+            adapter_instance = runtime_registry.get(adapter_model.id)
+        
+        if adapter_instance:
+            effective_root = adapter_instance.get_effective_root(adapter_model.sub_path)
+        else:
+            adapter_model = None
+            effective_root = ""
+            rel = ""
     except HTTPException:
-        mount = None
-        adapter = None
+        adapter_model = None
+        adapter_instance = None
         effective_root = ''
         rel = ''
 
@@ -84,8 +97,8 @@ async def list_virtual_dir(path: str, page_num: int = 1, page_size: int = 50) ->
     adapter_total = 0
     covered = set()
 
-    if mount and adapter:
-        list_dir = await _ensure_method(adapter, "list_dir")
+    if adapter_model and adapter_instance:
+        list_dir = await _ensure_method(adapter_instance, "list_dir")
         try:
             adapter_entries, adapter_total = await list_dir(effective_root, rel, page_num, page_size)
         except NotADirectoryError:
@@ -119,18 +132,18 @@ async def list_virtual_dir(path: str, page_num: int = 1, page_size: int = 50) ->
 
 
 async def read_file(path: str) -> Union[bytes, Any]:
-    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
+    adapter_instance, _, root, rel = await resolve_adapter_and_rel(path)
     if rel.endswith('/') or rel == '':
         raise HTTPException(400, detail="Path is a directory")
-    read_func = await _ensure_method(adapter, "read_file")
+    read_func = await _ensure_method(adapter_instance, "read_file")
     return await read_func(root, rel)
 
 
 async def write_file(path: str, data: bytes):
-    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
+    adapter_instance, _, root, rel = await resolve_adapter_and_rel(path)
     if rel.endswith('/'):
         raise HTTPException(400, detail="Invalid file path")
-    write_func = await _ensure_method(adapter, "write_file")
+    write_func = await _ensure_method(adapter_instance, "write_file")
     await write_func(root, rel, data)
     await task_service.trigger_tasks("file_written", path)
     await LogService.action(
@@ -139,10 +152,10 @@ async def write_file(path: str, data: bytes):
 
 
 async def write_file_stream(path: str, data_iter: AsyncIterator[bytes], overwrite: bool = True):
-    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
+    adapter_instance, _, root, rel = await resolve_adapter_and_rel(path)
     if rel.endswith('/'):
         raise HTTPException(400, detail="Invalid file path")
-    exists_func = getattr(adapter, "exists", None)
+    exists_func = getattr(adapter_instance, "exists", None)
     if not overwrite and callable(exists_func):
         try:
             if await exists_func(root, rel):
@@ -153,7 +166,7 @@ async def write_file_stream(path: str, data_iter: AsyncIterator[bytes], overwrit
             pass
 
     size = 0
-    stream_func = getattr(adapter, "write_file_stream", None)
+    stream_func = getattr(adapter_instance, "write_file_stream", None)
     if callable(stream_func):
         size = await stream_func(root, rel, data_iter)
     else:
@@ -161,7 +174,7 @@ async def write_file_stream(path: str, data_iter: AsyncIterator[bytes], overwrit
         async for chunk in data_iter:
             if chunk:
                 buf.extend(chunk)
-        write_func = await _ensure_method(adapter, "write_file")
+        write_func = await _ensure_method(adapter_instance, "write_file")
         await write_func(root, rel, bytes(buf))
         size = len(buf)
 
@@ -175,35 +188,35 @@ async def write_file_stream(path: str, data_iter: AsyncIterator[bytes], overwrit
 
 
 async def make_dir(path: str):
-    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
+    adapter_instance, _, root, rel = await resolve_adapter_and_rel(path)
     if not rel:
         raise HTTPException(400, detail="Cannot create root")
-    mkdir_func = await _ensure_method(adapter, "mkdir")
+    mkdir_func = await _ensure_method(adapter_instance, "mkdir")
     await mkdir_func(root, rel)
     await LogService.action("virtual_fs", f"Created directory {path}", details={"path": path})
 
 
 async def delete_path(path: str):
-    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
+    adapter_instance, _, root, rel = await resolve_adapter_and_rel(path)
     if not rel:
         raise HTTPException(400, detail="Cannot delete root")
-    delete_func = await _ensure_method(adapter, "delete")
+    delete_func = await _ensure_method(adapter_instance, "delete")
     await delete_func(root, rel)
     await task_service.trigger_tasks("file_deleted", path)
     await LogService.action("virtual_fs", f"Deleted {path}", details={"path": path})
 
 
 async def move_path(src: str, dst: str, overwrite: bool = False, return_debug: bool = True):
-    adapter_s, mount_s, root_s, rel_s = await resolve_adapter_and_rel(src)
-    adapter_d, mount_d, root_d, rel_d = await resolve_adapter_and_rel(dst)
+    adapter_s, adapter_model_s, root_s, rel_s = await resolve_adapter_and_rel(src)
+    adapter_d, adapter_model_d, root_d, rel_d = await resolve_adapter_and_rel(dst)
     debug_info = {
         "src": src, "dst": dst,
         "rel_s": rel_s, "rel_d": rel_d,
         "root_s": root_s, "root_d": root_d,
         "overwrite": overwrite
     }
-    if mount_s.id != mount_d.id:
-        raise HTTPException(400, detail="Cross-mount move not supported")
+    if adapter_model_s.id != adapter_model_d.id:
+        raise HTTPException(400, detail="Cross-adapter move not supported")
     if not rel_s:
         raise HTTPException(400, detail="Cannot move or rename mount root")
     if not rel_d:
@@ -266,16 +279,16 @@ async def move_path(src: str, dst: str, overwrite: bool = False, return_debug: b
 
 
 async def rename_path(src: str, dst: str, overwrite: bool = False, return_debug: bool = True):
-    adapter_s, mount_s, root_s, rel_s = await resolve_adapter_and_rel(src)
-    adapter_d, mount_d, root_d, rel_d = await resolve_adapter_and_rel(dst)
+    adapter_s, adapter_model_s, root_s, rel_s = await resolve_adapter_and_rel(src)
+    adapter_d, adapter_model_d, root_d, rel_d = await resolve_adapter_and_rel(dst)
     debug_info = {
         "src": src, "dst": dst,
         "rel_s": rel_s, "rel_d": rel_d,
         "root_s": root_s, "root_d": root_d,
         "overwrite": overwrite
     }
-    if mount_s.id != mount_d.id:
-        raise HTTPException(400, detail="Cross-mount rename not supported")
+    if adapter_model_s.id != adapter_model_d.id:
+        raise HTTPException(400, detail="Cross-adapter rename not supported")
     if not rel_s:
         raise HTTPException(400, detail="Cannot rename mount root")
     if not rel_d:
@@ -338,7 +351,7 @@ async def rename_path(src: str, dst: str, overwrite: bool = False, return_debug:
 
 
 async def stream_file(path: str, range_header: str | None):
-    adapter, mount, root, rel = await resolve_adapter_and_rel(path)
+    adapter_instance, _, root, rel = await resolve_adapter_and_rel(path)
     if not rel or rel.endswith('/'):
         raise HTTPException(400, detail="Path is a directory")
     if is_raw_filename(rel):
@@ -371,7 +384,7 @@ async def stream_file(path: str, range_header: str | None):
         except Exception as e:
             raise HTTPException(500, detail=f"RAW file processing failed: {e}")
 
-    stream_impl = getattr(adapter, "stream_file", None)
+    stream_impl = getattr(adapter_instance, "stream_file", None)
     if callable(stream_impl):
         return await stream_impl(root, rel, range_header)
     data = await read_file(path)
@@ -380,24 +393,24 @@ async def stream_file(path: str, range_header: str | None):
 
 
 async def stat_file(path: str):
-    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
-    stat_func = getattr(adapter, "stat_file", None)
+    adapter_instance, _, root, rel = await resolve_adapter_and_rel(path)
+    stat_func = getattr(adapter_instance, "stat_file", None)
     if not callable(stat_func):
         raise HTTPException(501, detail="Adapter does not implement stat_file")
     return await stat_func(root, rel)
 
 
 async def copy_path(src: str, dst: str, overwrite: bool = False, return_debug: bool = True):
-    adapter_s, mount_s, root_s, rel_s = await resolve_adapter_and_rel(src)
-    adapter_d, mount_d, root_d, rel_d = await resolve_adapter_and_rel(dst)
+    adapter_s, adapter_model_s, root_s, rel_s = await resolve_adapter_and_rel(src)
+    adapter_d, adapter_model_d, root_d, rel_d = await resolve_adapter_and_rel(dst)
     debug_info = {
         "src": src, "dst": dst,
         "rel_s": rel_s, "rel_d": rel_d,
         "root_s": root_s, "root_d": root_d,
         "overwrite": overwrite
     }
-    if mount_s.id != mount_d.id:
-        raise HTTPException(400, detail="Cross-mount copy not supported")
+    if adapter_model_s.id != adapter_model_d.id:
+        raise HTTPException(400, detail="Cross-adapter copy not supported")
     if not rel_s:
         raise HTTPException(400, detail="Cannot copy mount root")
     if not rel_d:

web/bun.lock

@@ -8,6 +8,7 @@
         "@ant-design/v5-patch-for-react-19": "^1.0.3",
         "@uiw/react-md-editor": "^4.0.8",
         "antd": "^5.27.0",
+        "artplayer": "^5.2.5",
         "date-fns": "^4.1.0",
         "react": "^19.1.1",
         "react-dom": "^19.1.1",
@@ -316,6 +317,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 +535,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=="],
@@ -646,6 +651,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=="],

web/package.json

@@ -14,6 +14,7 @@
     "@ant-design/v5-patch-for-react-19": "^1.0.3",
     "@uiw/react-md-editor": "^4.0.8",
     "antd": "^5.27.0",
+    "artplayer": "^5.2.5",
     "date-fns": "^4.1.0",
     "react": "^19.1.1",
     "react-dom": "^19.1.1",

web/src/api/adapters.ts

@@ -6,7 +6,7 @@ export interface AdapterItem {
   type: string;
   config: any;
   enabled: boolean;
-  mount_path?: string | null;
+  path?: string | null;
   sub_path?: string | null;
 }
 

web/src/apps/VideoPlayer/VideoPlayer.tsx

@@ -1,408 +1,46 @@
-import React, { useEffect, useRef, useState } from 'react';
+import React, { useEffect, useRef } from 'react';
+import Artplayer from 'artplayer';
 import { vfsApi } from '../../api/client';
 import type { AppComponentProps } from '../types';
-import { Spin, Button } from 'antd';
-import {
-  PauseOutlined,
-  CaretRightOutlined,
-  SoundOutlined,
-  FullscreenOutlined,
-  ReloadOutlined
-} from '@ant-design/icons';
+
 
 export const VideoPlayerApp: React.FC<AppComponentProps> = ({ filePath }) => {
-  const containerRef = useRef<HTMLDivElement | null>(null);
-  const videoRef = useRef<HTMLVideoElement | null>(null);
-  const progressBarRef = useRef<HTMLDivElement | null>(null);
-  const progressRef = useRef<HTMLDivElement | null>(null);
-  const isMountedRef = useRef(true);
-  const [isPlaying, setIsPlaying] = useState(false);
-  const [volume, setVolume] = useState(0.7);
-  const [isMuted, setIsMuted] = useState(false);
-  const [currentTime, setCurrentTime] = useState(0);
-  const [duration, setDuration] = useState(0);
-  const [loading, setLoading] = useState(true);
-  const [err, setErr] = useState<string>();
-  const [url, setUrl] = useState<string>();
-  const [showControls, setShowControls] = useState(true);
-  const [retryKey, setRetryKey] = useState(0);
-  const controlsTimerRef = useRef<number | undefined>(undefined);
-
-  useEffect(() => {
-    isMountedRef.current = true;
-
-    return () => {
-      isMountedRef.current = false;
-      if (controlsTimerRef.current) {
-        window.clearTimeout(controlsTimerRef.current);
-      }
-    };
-  }, []);
+  const artRef = useRef<HTMLDivElement | null>(null);
+  const artInstance = useRef<Artplayer | null>(null);
 
   useEffect(() => {
+    //
     const safePath = filePath.replace(/^\/+/, '').split('#').map((seg, idx) => idx === 0 ? seg : encodeURIComponent('#') + seg).join('');
-    const u = vfsApi.streamUrl(safePath);
-    setUrl(u);
-    setErr(undefined);
-    setLoading(true);
-  }, [filePath, retryKey]);
+    const videoUrl = vfsApi.streamUrl(safePath);
 
-  // 处理视频事件
-  useEffect(() => {
-    const video = videoRef.current;
-    if (!video || !url) return;
-
-    const onLoadedMetadata = () => {
-      if (isMountedRef.current) {
-        setDuration(video.duration);
-      }
-    };
-
-    const onTimeUpdate = () => {
-      if (isMountedRef.current) {
-        setCurrentTime(video.currentTime);
-        updateProgressBar();
-      }
-    };
-
-    const onCanPlay = () => {
-      if (isMountedRef.current) {
-        setLoading(false);
-      }
-    };
-
-    const onEnded = () => {
-      if (isMountedRef.current) {
-        setIsPlaying(false);
-      }
-    };
-
-    const onError = () => {
-      if (isMountedRef.current) {
-        setLoading(false);
-        setErr('视频加载失败');
-      }
-    };
-
-    const onPlay = () => {
-      if (isMountedRef.current) {
-        setIsPlaying(true);
-      }
-    };
-
-    const onPause = () => {
-      if (isMountedRef.current) {
-        setIsPlaying(false);
-      }
-    };
-
-    const onProgress = () => {
-      // 监听缓冲进度
-      if (video.buffered.length > 0) {
-        const bufferedEnd = video.buffered.end(video.buffered.length - 1);
-        if (progressBarRef.current) {
-          const bufferProgress = bufferedEnd / video.duration * 100;
-          progressBarRef.current.style.setProperty('--buffer-width', `${bufferProgress}%`);
-        }
-      }
-    };
-
-    video.addEventListener('loadedmetadata', onLoadedMetadata);
-    video.addEventListener('timeupdate', onTimeUpdate);
-    video.addEventListener('canplay', onCanPlay);
-    video.addEventListener('ended', onEnded);
-    video.addEventListener('error', onError);
-    video.addEventListener('play', onPlay);
-    video.addEventListener('pause', onPause);
-    video.addEventListener('progress', onProgress);
+    if (artRef.current) {
+      artInstance.current = new Artplayer({
+        container: artRef.current,
+        url: videoUrl,
+        autoplay: true,
+        fullscreen: true,
+        fullscreenWeb: true,
+        pip: true,
+        setting: true,
+        playbackRate: true,
+      });
+    }
 
     return () => {
-      video.removeEventListener('loadedmetadata', onLoadedMetadata);
-      video.removeEventListener('timeupdate', onTimeUpdate);
-      video.removeEventListener('canplay', onCanPlay);
-      video.removeEventListener('ended', onEnded);
-      video.removeEventListener('error', onError);
-      video.removeEventListener('play', onPlay);
-      video.removeEventListener('pause', onPause);
-      video.removeEventListener('progress', onProgress);
-    };
-  }, [url]);
-
-  // 处理进度条更新
-  const updateProgressBar = () => {
-    const video = videoRef.current;
-    const progress = progressRef.current;
-
-    if (video && progress && duration > 0) {
-      const percentage = (video.currentTime / duration) * 100;
-      progress.style.width = `${percentage}%`;
-    }
-  };
-
-  // 处理进度条点击
-  const handleProgressBarClick = (e: React.MouseEvent<HTMLDivElement>) => {
-    const progressBar = progressBarRef.current;
-    const video = videoRef.current;
-
-    if (progressBar && video) {
-      const rect = progressBar.getBoundingClientRect();
-      const clickPosition = e.clientX - rect.left;
-      const percentage = clickPosition / rect.width;
-      const newTime = percentage * duration;
-
-      video.currentTime = newTime;
-      setCurrentTime(newTime);
-    }
-  };
-
-  // 播放/暂停
-  const togglePlay = () => {
-    const video = videoRef.current;
-    if (!video) return;
-
-    if (isPlaying) {
-      video.pause();
-    } else {
-      video.play().catch(error => {
-        console.error('播放失败:', error);
-        setErr('播放失败');
-      });
-    }
-  };
-
-  // 全屏
-  const toggleFullscreen = () => {
-    const container = containerRef.current;
-    if (!container) return;
-
-    if (!document.fullscreenElement) {
-      container.requestFullscreen().catch(err => {
-        console.error('全屏失败:', err);
-      });
-    } else {
-      document.exitFullscreen();
-    }
-  };
-
-  // 音量控制
-  const handleVolumeChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const newVolume = parseFloat(e.target.value);
-    setVolume(newVolume);
-
-    const video = videoRef.current;
-    if (video) {
-      video.volume = newVolume;
-      setIsMuted(newVolume === 0);
-    }
-  };
-
-  // 静音切换
-  const toggleMute = () => {
-    const video = videoRef.current;
-    if (!video) return;
-
-    const newMuted = !isMuted;
-    setIsMuted(newMuted);
-    video.muted = newMuted;
-  };
-
-  // 格式化时间显示
-  const formatTime = (seconds: number): string => {
-    if (isNaN(seconds)) return '00:00';
-
-    const mins = Math.floor(seconds / 60);
-    const secs = Math.floor(seconds % 60);
-    return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
-  };
-
-  // 控制栏自动隐藏
-  const resetControlsTimer = () => {
-    if (controlsTimerRef.current) {
-      window.clearTimeout(controlsTimerRef.current);
-    }
-
-    setShowControls(true);
-
-    controlsTimerRef.current = window.setTimeout(() => {
-      if (isPlaying && isMountedRef.current) {
-        setShowControls(false);
+      if (artInstance.current) {
+        artInstance.current.destroy();
       }
-    }, 3000);
-  };
-
-  const handleMouseMove = () => {
-    resetControlsTimer();
-  };
-
-  const retry = () => setRetryKey(k => k + 1);
+    };
+  }, [filePath]);
 
   return (
     <div
-      style={{ width: '100%', height: '100%', display: 'flex', flexDirection: 'column', background: '#000' }}
-      ref={containerRef}
-      onMouseMove={handleMouseMove}
-    >
-      <div style={{ flex: 1, position: 'relative', backgroundColor: '#000', overflow: 'hidden' }}>
-        {/* 视频元素 */}
-        <video
-          ref={videoRef}
-          style={{
-            width: '100%',
-            height: '100%',
-            objectFit: 'contain'
-          }}
-          src={url}
-          controlsList="nodownload"
-          crossOrigin="anonymous"
-          preload="metadata"
-          onClick={togglePlay}
-        />
-
-        {/* 加载指示器 */}
-        {loading && !err && (
-          <div style={{ position: 'absolute', inset: 0, display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', background: 'rgba(0,0,0,0.35)', gap: 12 }}>
-            <Spin />
-            <span style={{ fontSize: 12, color: '#aaa' }}>正在缓冲...</span>
-          </div>
-        )}
-
-        {/* 错误显示 */}
-        {err && (
-          <div style={{ position: 'absolute', inset: 0, display: 'flex', flexDirection: 'column', alignItems: 'center', justifyContent: 'center', background: 'rgba(0,0,0,0.5)', gap: 12 }}>
-            <span style={{ color: '#ff4d4f', fontSize: 13 }}>{err}</span>
-            <Button icon={<ReloadOutlined />} size="small" onClick={retry}>重试</Button>
-          </div>
-        )}
-
-        {/* 控制栏 */}
-        {showControls && (
-          <div
-            style={{
-              position: 'absolute',
-              bottom: 0,
-              left: 0,
-              right: 0,
-              background: 'linear-gradient(transparent, rgba(0,0,0,0.7))',
-              padding: '30px 15px 10px',
-              transition: 'opacity 0.3s',
-              opacity: showControls ? 1 : 0,
-              display: 'flex',
-              flexDirection: 'column',
-              gap: '8px'
-            }}
-          >
-            {/* 进度条 */}
-            <div
-              ref={progressBarRef}
-              onClick={handleProgressBarClick}
-              style={{
-                height: '4px',
-                backgroundColor: 'rgba(255,255,255,0.2)',
-                cursor: 'pointer',
-                position: 'relative',
-                borderRadius: '2px',
-                '--buffer-width': '0%'
-              } as React.CSSProperties}
-            >
-              <div
-                style={{
-                  position: 'absolute',
-                  height: '100%',
-                  width: 'var(--buffer-width)',
-                  backgroundColor: 'rgba(255,255,255,0.4)',
-                  borderRadius: '2px'
-                }}
-              />
-              <div
-                ref={progressRef}
-                style={{
-                  height: '100%',
-                  width: '0%',
-                  backgroundColor: '#1890ff',
-                  position: 'relative',
-                  borderRadius: '2px',
-                }}
-              >
-                <div
-                  style={{
-                    position: 'absolute',
-                    right: '-6px',
-                    top: '-4px',
-                    width: '12px',
-                    height: '12px',
-                    borderRadius: '50%',
-                    backgroundColor: '#1890ff',
-                  }}
-                />
-              </div>
-            </div>
-
-            <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-              <div style={{ display: 'flex', alignItems: 'center', gap: '16px' }}>
-                <Button
-                  type="text"
-                  icon={isPlaying ? <PauseOutlined /> : <CaretRightOutlined />}
-                  onClick={togglePlay}
-                  style={{ color: '#fff' }}
-                />
-
-                <div style={{ display: 'flex', alignItems: 'center', gap: '8px', width: '100px' }}>
-                  <Button
-                    type="text"
-                    icon={<SoundOutlined />}
-                    onClick={toggleMute}
-                    style={{ color: isMuted ? '#888' : '#fff' }}
-                  />
-                  <input
-                    type="range"
-                    min="0"
-                    max="1"
-                    step="0.01"
-                    value={isMuted ? 0 : volume}
-                    onChange={handleVolumeChange}
-                    style={{ width: '60px' }}
-                  />
-                </div>
-
-                <div style={{ color: '#fff', fontSize: '12px' }}>
-                  {formatTime(currentTime)} / {formatTime(duration)}
-                </div>
-              </div>
-
-              <div>
-                <Button
-                  type="text"
-                  icon={<FullscreenOutlined />}
-                  onClick={toggleFullscreen}
-                  style={{ color: '#fff' }}
-                />
-              </div>
-            </div>
-          </div>
-        )}
-
-        {!isPlaying && !loading && !err && (
-          <div
-            onClick={togglePlay}
-            style={{
-              position: 'absolute',
-              top: '50%',
-              left: '50%',
-              transform: 'translate(-50%, -50%)',
-              width: '60px',
-              height: '60px',
-              borderRadius: '50%',
-              background: 'rgba(0,0,0,0.5)',
-              display: 'flex',
-              alignItems: 'center',
-              justifyContent: 'center',
-              cursor: 'pointer'
-            }}
-          >
-            <CaretRightOutlined style={{ fontSize: '24px', color: '#fff' }} />
-          </div>
-        )}
-      </div>
-    </div>
+      ref={artRef}
+      style={{
+        width: '100%',
+        height: '100%',
+        backgroundColor: '#000'
+      }}
+    />
   );
 };

web/src/layout/SideNav.tsx

@@ -1,10 +1,11 @@
-import { Layout, Menu, theme, Button, Modal, Tag, Tooltip } from 'antd';
+import { Layout, Menu, theme, Button, Modal, Tag, Tooltip, Descriptions, Alert, Divider, Spin } from 'antd';
 import { navGroups } from './nav.ts';
 import type { NavItem, NavGroup } from './nav.ts';
 import { memo, useEffect, useState } from 'react';
 import { useSystemStatus } from '../contexts/SystemContext.tsx';
 import {
   CheckCircleOutlined,
+  FileTextOutlined,
   GithubOutlined,
   MenuFoldOutlined,
   SendOutlined,
@@ -154,8 +155,8 @@ const SideNav = memo(function SideNav({ collapsed, activeKey, onChange, onToggle
           }} onClick={showVersionModal}>
             {hasUpdate ? (
               <Tooltip title={`发现新版本: ${latestVersion?.version}`} placement={collapsed ? 'right' : 'top'}>
-                <a href="https://github.com/DrizzleTime/Foxel/releases" target="_blank" rel="noopener noreferrer"
-                   style={{ textDecoration: 'none' }}>
+                <a rel="noopener noreferrer"
+                  style={{ textDecoration: 'none' }}>
                   {collapsed ? (
                     <Tag icon={<WarningOutlined />} color="warning" style={{ marginInlineEnd: 0 }} />
                   ) : (
@@ -199,8 +200,14 @@ const SideNav = memo(function SideNav({ collapsed, activeKey, onChange, onToggle
               href="https://t.me/+thDsBfyqJxZkNTU1"
               target="_blank"
             />
+            <Button
+              shape="circle"
+              icon={<FileTextOutlined />}
+              href="https://foxel.cc"
+              target="_blank"
+            />
           </div>
-          
+
         </div>
       </Sider>
       <Modal
@@ -225,13 +232,72 @@ const SideNav = memo(function SideNav({ collapsed, activeKey, onChange, onToggle
         onCancel={() => setIsVersionModalOpen(false)}
         title="版本信息"
         footer={null}
+        width={600}
       >
-        <div>
-          <p>当前版本: {status?.version}</p>
-          {latestVersion && (
-            <div>
-              <p>最新版本: {latestVersion.version}</p>
-              <ReactMarkdown>{latestVersion.body}</ReactMarkdown>
+        <div style={{ paddingTop: 12 }}>
+          {latestVersion ? (
+            <>
+              <Descriptions bordered column={1} size="small">
+                <Descriptions.Item label="当前版本">
+                  <Tag>{status?.version}</Tag>
+                </Descriptions.Item>
+                <Descriptions.Item label="最新版本">
+                  <Tag color={hasUpdate ? 'orange' : 'green'}>{latestVersion.version}</Tag>
+                </Descriptions.Item>
+              </Descriptions>
+
+              {hasUpdate && (
+                <Alert
+                  message={<span style={{ color: token.colorText }}>{`发现新版本: ${latestVersion.version}`}</span>}
+                  description={<span style={{ color: token.colorTextSecondary }}>建议尽快更新到最新版本，以获得新功能和安全修复。</span>}
+                  type="info"
+                  showIcon
+                  style={{ marginTop: 24, marginBottom: 24, background: token.colorInfoBg, borderColor: token.colorInfoBorder }}
+                  action={
+                    <Button
+                      size="small"
+                      type="primary"
+                      href="https://github.com/DrizzleTime/Foxel/releases"
+                      target="_blank"
+                      icon={<GithubOutlined />}
+                    >
+                      前往发布页面
+                    </Button>
+                  }
+                />
+              )}
+
+              <Divider orientation="left" plain>更新日志</Divider>
+              <div style={{
+                maxHeight: '40vh',
+                overflowY: 'auto',
+                padding: '8px 16px',
+                background: token.colorFillAlter,
+                borderRadius: token.borderRadiusLG,
+                border: `1px solid ${token.colorBorderSecondary}`
+              }}>
+                <ReactMarkdown
+                  components={{
+                    h3: ({ ...props }) => <h3 style={{
+                      fontSize: 16,
+                      borderBottom: `1px solid ${token.colorBorderSecondary}`,
+                      paddingBottom: 8,
+                      marginTop: 24,
+                      marginBottom: 16,
+                      color: token.colorTextHeading
+                    }} {...props} />,
+                    ul: ({ ...props }) => <ul style={{ paddingLeft: 20 }} {...props} />,
+                    li: ({ ...props }) => <li style={{ marginBottom: 8 }} {...props} />,
+                    p: ({ ...props }) => <p style={{ marginBottom: 8 }} {...props} />,
+                    a: ({ ...props }) => <a {...props} target="_blank" rel="noopener noreferrer" />
+                  }}
+                >{latestVersion.body}</ReactMarkdown>
+              </div>
+            </>
+          ) : (
+            <div style={{ textAlign: 'center', padding: '40px 0', color: token.colorTextSecondary }}>
+              <Spin size="large" />
+              <p style={{ marginTop: 16 }}>正在获取最新版本信息...</p>
             </div>
           )}
         </div>

web/src/pages/AdaptersPage.tsx

@@ -1,17 +1,8 @@
 import { memo, useState, useEffect, useCallback } from 'react';
 import { Table, Button, Space, Drawer, Form, Input, Switch, message, Typography, Popconfirm, Select } from 'antd';
 import PageCard from '../components/PageCard';
-import { adaptersApi } from '../api/client';
+import { adaptersApi, type AdapterItem } from '../api/client';
 
-interface AdapterItem {
-  id: number;
-  name: string;
-  type: string;
-  config: any;
-  enabled: boolean;
-  mount_path?: string | null;
-  sub_path?: string | null;
-}
 
 interface AdapterTypeField {
   key: string;
@@ -65,7 +56,7 @@ const AdaptersPage = memo(function AdaptersPage() {
     form.setFieldsValue({
       name: '',
       type: defaultType,
-      mount_path: '/',
+      path: '/',
       sub_path: '',
       enabled: true,
       config: cfgDefaults
@@ -79,7 +70,7 @@ const AdaptersPage = memo(function AdaptersPage() {
     form.setFieldsValue({
       name: rec.name,
       type: rec.type,
-      mount_path: rec.mount_path || '/',
+      path: rec.path || '/',
       sub_path: rec.sub_path || '',
       enabled: rec.enabled,
       config: rec.config || {}
@@ -105,7 +96,7 @@ const AdaptersPage = memo(function AdaptersPage() {
       const body = {
         name: values.name.trim(),
         type: values.type,
-        mount_path: values.mount_path || '/',
+        path: values.path || '/',
         sub_path: values.sub_path?.trim() || null,
         enabled: values.enabled,
         config: cfg
@@ -155,7 +146,7 @@ const AdaptersPage = memo(function AdaptersPage() {
   const columns = [
     { title: '名称', dataIndex: 'name' },
     { title: '类型', dataIndex: 'type', width: 100 },
-    { title: '挂载路径', dataIndex: 'mount_path', width: 140, render: (v: string) => v || '-' },
+    { title: '挂载路径', dataIndex: 'path', width: 140, render: (v: string) => v || '-' },
     { title: '子路径', dataIndex: 'sub_path', width: 140, render: (v: string) => v || '-' },
     {
       title: '启用',
@@ -251,7 +242,6 @@ const AdaptersPage = memo(function AdaptersPage() {
               placeholder="选择适配器类型"
               options={availableTypes.map(t => ({ value: t.type, label: `${t.name} (${t.type})` }))}
               onChange={() => {
-                // 切换类型时刷新默认 config
                 const t = availableTypes.find(v => v.type === form.getFieldValue('type'));
                 const cfgDefaults: Record<string, any> = {};
                 t?.config_schema.forEach(f => {
@@ -261,7 +251,7 @@ const AdaptersPage = memo(function AdaptersPage() {
               }}
             />
           </Form.Item>
-          <Form.Item name="mount_path" label="挂载路径" rules={[{ required: true, message: '请输入挂载路径' }]}>
+          <Form.Item name="path" label="挂载路径" rules={[{ required: true, message: '请输入挂载路径' }]}>
             <Input placeholder="/或/drive" />
           </Form.Item>
           <Form.Item name="sub_path" label="子路径(可选)">

web/src/pages/FileExplorerPage/FileExplorerPage.tsx

@@ -109,7 +109,7 @@ const FileExplorerPage = memo(function FileExplorerPage() {
 
       <div style={{ flex: 1, overflow: 'auto', paddingBottom: pagination.total > 0 ? '80px' : '0' }} onContextMenu={openBlankContextMenu}>
         {loading && entries.length === 0 ? (
-          <div style={{ textAlign: 'center', padding: 40 }}><EmptyState isRoot={path === '/'} onCreateDir={() => setCreatingDir(true)} onGoUp={goUp} /></div>
+          <div style={{ textAlign: 'center', padding: 40 }}><EmptyState isRoot={path === '/'} /></div>
         ) : viewMode === 'grid' ? (
           <GridView
             entries={entries}
@@ -121,8 +121,6 @@ const FileExplorerPage = memo(function FileExplorerPage() {
             onSelectRange={handleSelectRange}
             onOpen={handleOpenEntry}
             onContextMenu={openContextMenu}
-            onCreateDir={() => setCreatingDir(true)}
-            onGoUp={goUp}
           />
         ) : (
           <FileListView

web/src/pages/FileExplorerPage/components/EmptyState.tsx

@@ -1,14 +1,12 @@
 import React from 'react';
-import { Button, Space, Typography, theme } from 'antd';
-import { PlusOutlined, CloudUploadOutlined, ArrowUpOutlined, FolderOpenOutlined } from '@ant-design/icons';
+import { Typography, theme } from 'antd';
+import { FolderOpenOutlined } from '@ant-design/icons';
 
 interface Props {
   isRoot: boolean;
-  onCreateDir: () => void;
-  onGoUp: () => void;
 }
 
-export const EmptyState: React.FC<Props> = ({ isRoot, onCreateDir, onGoUp }) => {
+export const EmptyState: React.FC<Props> = ({ isRoot }) => {
   const { token } = theme.useToken();
   return (
     <div style={{ display:'flex', flexDirection:'column', alignItems:'center', justifyContent:'center', padding:isRoot? '80px 40px':'60px 40px', minHeight: isRoot? '400px':'300px', color: token.colorTextSecondary }}>
@@ -19,15 +17,6 @@ export const EmptyState: React.FC<Props> = ({ isRoot, onCreateDir, onGoUp }) =>
       <Typography.Text style={{ color: token.colorTextTertiary, marginBottom:24, textAlign:'center', maxWidth:300, lineHeight:1.5 }}>
         {isRoot ? '开始上传文件或创建新目录来组织您的内容' : '您可以在此目录中创建新的文件夹或上传文件'}
       </Typography.Text>
-      <Space size={12}>
-        <Button type="primary" icon={<PlusOutlined />} onClick={onCreateDir}>新建目录</Button>
-        <Button icon={<CloudUploadOutlined />} disabled>上传文件</Button>
-      </Space>
-      {!isRoot && (
-        <div style={{ marginTop:16 }}>
-          <Button type="link" size="small" icon={<ArrowUpOutlined />} onClick={onGoUp} style={{ color: token.colorTextTertiary }}>返回上级目录</Button>
-        </div>
-      )}
     </div>
   );
 };

web/src/pages/FileExplorerPage/components/GridView.tsx

@@ -7,20 +7,14 @@ import { EmptyState } from './EmptyState';
 
 interface Props {
   entries: VfsEntry[];
-  thumbs: Record<string,string>;
-  // ...existing code...
-  // selected was single entry before; now use selectedEntries for multi-select
+  thumbs: Record<string, string>;
   selectedEntries: string[];
   loading: boolean;
   path: string;
-  // onSelect: clicked entry, additive indicates Ctrl/Cmd click to toggle
   onSelect: (e: VfsEntry, additive?: boolean) => void;
-  // onSelectRange: called when marquee/selecting multiple by box
   onSelectRange: (names: string[]) => void;
   onOpen: (e: VfsEntry) => void;
   onContextMenu: (e: React.MouseEvent, entry: VfsEntry) => void;
-  onCreateDir: () => void;
-  onGoUp: () => void;
 }
 
 const formatSize = (size: number) => {
@@ -30,14 +24,12 @@ const formatSize = (size: number) => {
   return (size / 1024 / 1024 / 1024).toFixed(1) + ' GB';
 };
 
-export const GridView: React.FC<Props> = ({ entries, thumbs, selectedEntries, loading, path, onSelect, onSelectRange, onOpen, onContextMenu, onCreateDir, onGoUp }) => {
+export const GridView: React.FC<Props> = ({ entries, thumbs, selectedEntries, loading, path, onSelect, onSelectRange, onOpen, onContextMenu }) => {
   const { token } = theme.useToken();
-
-  // refs for marquee selection
   const containerRef = useRef<HTMLDivElement | null>(null);
   const itemRefs = useRef<Record<string, HTMLDivElement | null>>({});
-  const startRef = useRef<{x:number,y:number} | null>(null);
-  const [rect, setRect] = useState<{left:number,top:number,width:number,height:number} | null>(null);
+  const startRef = useRef<{ x: number, y: number } | null>(null);
+  const [rect, setRect] = useState<{ left: number, top: number, width: number, height: number } | null>(null);
   const [selecting, setSelecting] = useState(false);
 
   useEffect(() => {
@@ -52,12 +44,11 @@ export const GridView: React.FC<Props> = ({ entries, thumbs, selectedEntries, lo
       const height = Math.abs(cy - s.y);
       setRect({ left, top, width, height });
     };
-    const onUp = () => { // 不需要 MouseEvent 参数，避免未使用警告
+    const onUp = () => {
       if (!startRef.current) return;
       setSelecting(false);
       const r = rect;
       if (r) {
-        // compute intersecting items
         const container = containerRef.current;
         if (container) {
           const sel: string[] = [];
@@ -89,17 +80,14 @@ export const GridView: React.FC<Props> = ({ entries, thumbs, selectedEntries, lo
   }, [selecting, rect, entries, onSelectRange]);
 
   const handleMouseDown = (e: React.MouseEvent) => {
-    // only left button and not on an item actionable element
     if (e.button !== 0) return;
-    // start marquee if click on empty space inside container
     const target = e.target as HTMLElement;
     if (target.closest('.fx-grid-item')) {
-      return; // clicks on item handled separately
+      return;
     }
     startRef.current = { x: e.clientX, y: e.clientY };
     setSelecting(true);
     setRect({ left: e.clientX, top: e.clientY, width: 0, height: 0 });
-    // prevent text selection
     e.preventDefault();
   };
 
@@ -108,29 +96,28 @@ export const GridView: React.FC<Props> = ({ entries, thumbs, selectedEntries, lo
       {entries.map(ent => {
         const isImg = thumbs[ent.name];
         const ext = ent.name.split('.').pop()?.toLowerCase();
-        const isPictureType = ['png','jpg','jpeg','gif','webp','svg'].includes(ext || '');
+        const isPictureType = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'].includes(ext || '');
         const isSelected = selectedEntries.includes(ent.name);
         return (
           <div
             key={ent.name}
-            ref={(el) => { itemRefs.current[ent.name] = el; }} // 确保函数不返回值，匹配 Ref 类型
-            className={['fx-grid-item', isSelected ? 'selected' : '', ent.is_dir? 'dir':'file'].join(' ')}
+            ref={(el) => { itemRefs.current[ent.name] = el; }}
+            className={['fx-grid-item', isSelected ? 'selected' : '', ent.is_dir ? 'dir' : 'file'].join(' ')}
             onClick={(ev) => {
-              // click selection: support ctrl/cmd to toggle
               const additive = ev.ctrlKey || ev.metaKey;
               onSelect(ent, additive);
             }}
             onDoubleClick={() => onOpen(ent)}
-            onContextMenu={(e)=> onContextMenu(e, ent)}
-            style={{ userSelect:'none' }}
+            onContextMenu={(e) => onContextMenu(e, ent)}
+            style={{ userSelect: 'none' }}
           >
             <div className="thumb" style={{ background: ent.is_dir ? 'linear-gradient(#fafafa,#f2f2f2)' : '#fff' }}>
-              {ent.is_dir && <FolderFilled style={{ fontSize:32, color: token.colorPrimary }} />}
-              {!ent.is_dir && (isImg ? <img src={isImg} alt={ent.name} style={{ maxWidth:'100%', maxHeight:'100%'}} /> : isPictureType ? <PictureOutlined style={{ fontSize:32, color:'#8c8c8c' }} /> : getFileIcon(ent.name,32))}
+              {ent.is_dir && <FolderFilled style={{ fontSize: 32, color: token.colorPrimary }} />}
+              {!ent.is_dir && (isImg ? <img src={isImg} alt={ent.name} style={{ maxWidth: '100%', maxHeight: '100%' }} /> : isPictureType ? <PictureOutlined style={{ fontSize: 32, color: '#8c8c8c' }} /> : getFileIcon(ent.name, 32))}
               {ent.type === 'mount' && <span className="badge">M</span>}
             </div>
-            <Tooltip title={ent.name}><div className="name ellipsis" style={{ userSelect:'none' }}>{ent.name}</div></Tooltip>
-            <div className="meta ellipsis" style={{ fontSize:11, color: token.colorTextSecondary, userSelect:'none' }}>{ent.is_dir ? '目录' : formatSize(ent.size)}</div>
+            <Tooltip title={ent.name}><div className="name ellipsis" style={{ userSelect: 'none' }}>{ent.name}</div></Tooltip>
+            <div className="meta ellipsis" style={{ fontSize: 11, color: token.colorTextSecondary, userSelect: 'none' }}>{ent.is_dir ? '目录' : formatSize(ent.size)}</div>
           </div>
         )
       })}
@@ -148,8 +135,8 @@ export const GridView: React.FC<Props> = ({ entries, thumbs, selectedEntries, lo
           }}
         />
       )}
-      {loading && <div style={{ width:'100%', textAlign:'center', padding:40 }}><Spin /></div>}
-      {!loading && entries.length === 0 && <EmptyState isRoot={path==='/' } onCreateDir={onCreateDir} onGoUp={onGoUp} />}
+      {loading && <div style={{ width: '100%', textAlign: 'center', padding: 40 }}><Spin /></div>}
+      {!loading && entries.length === 0 && <EmptyState isRoot={path === '/'} />}
     </div>
   );
 };

web/src/pages/PublicSharePage.tsx

@@ -1,165 +0,0 @@
-import { memo, useState, useEffect, useCallback } from 'react';
-import { useParams } from 'react-router';
-import { Card, message, Spin, List, Typography, Button, Empty, Breadcrumb, Input, Form } from 'antd';
-import { FileOutlined, FolderOutlined, DownloadOutlined } from '@ant-design/icons';
-import { shareApi, type ShareInfo } from '../api/share';
-import { type VfsEntry } from '../api/vfs';
-import { format, parseISO } from 'date-fns';
-
-const { Title, Text } = Typography;
-
-const PublicSharePage = memo(function PublicSharePage() {
-  const { token } = useParams<{ token: string }>();
-  const [loading, setLoading] = useState(true);
-  const [shareInfo, setShareInfo] = useState<ShareInfo | null>(null);
-  const [entries, setEntries] = useState<VfsEntry[]>([]);
-  const [currentPath, setCurrentPath] = useState('/');
-  const [error, setError] = useState('');
-  const [password, setPassword] = useState('');
-  const [verified, setVerified] = useState(false);
-
-  const loadData = useCallback(async (p: string, pwd?: string) => {
-    if (!token) return;
-    setLoading(true);
-    setError('');
-    try {
-      let info = shareInfo;
-      if (!info) {
-        info = await shareApi.get(token);
-        setShareInfo(info);
-      }
-      
-      if (info?.access_type === 'password' && !verified) {
-        // Do not load files until password is verified
-        setLoading(false);
-        return;
-      }
-
-      const currentPassword = pwd || password;
-      const listing = await shareApi.listDir(token, p, currentPassword);
-      setEntries(listing.entries || []);
-      setCurrentPath(p);
-    } catch (e: any) {
-      setError(e.message || '加载分享失败');
-      if (e.message === '需要密码') {
-        setVerified(false);
-      }
-    } finally {
-      setLoading(false);
-    }
-  }, [token, shareInfo, password, verified]);
-
-  useEffect(() => {
-    loadData(currentPath);
-  }, [loadData, currentPath]);
-
-  const handleEntryClick = (entry: VfsEntry) => {
-    if (entry.is_dir) {
-      const newPath = (currentPath === '/' ? '' : currentPath) + '/' + entry.name;
-      loadData(newPath);
-    } else {
-      // Preview logic can be added here
-      message.info('暂不支持预览');
-    }
-  };
-
-  const handleBreadcrumbClick = (path: string) => {
-    loadData(path);
-  };
-
-  const renderBreadcrumb = () => {
-    const parts = currentPath.split('/').filter(Boolean);
-    const items = [{ title: '全部文件', path: '/' }];
-    parts.forEach((part, i) => {
-      const path = '/' + parts.slice(0, i + 1).join('/');
-      items.push({ title: part, path });
-    });
-    return (
-      <Breadcrumb>
-        {items.map((item, i) => (
-          <Breadcrumb.Item key={i}>
-            {i === items.length - 1 ? (
-              <span>{item.title}</span>
-            ) : (
-              <a onClick={() => handleBreadcrumbClick(item.path)}>{item.title}</a>
-            )}
-          </Breadcrumb.Item>
-        ))}
-      </Breadcrumb>
-    );
-  };
-
-  const handlePasswordSubmit = async (values: { password_input: string }) => {
-    if (!token) return;
-    try {
-      await shareApi.verifyPassword(token, values.password_input);
-      setPassword(values.password_input);
-      setVerified(true);
-      setError('');
-      loadData(currentPath, values.password_input);
-    } catch (e: any) {
-      message.error(e.message || '密码错误');
-    }
-  };
-
-  if (loading && !shareInfo) {
-    return <div style={{ textAlign: 'center', padding: 50 }}><Spin size="large" /></div>;
-  }
-
-  if (error && !error.includes('需要密码')) {
-    return <div style={{ textAlign: 'center', padding: 50 }}><Empty description={error} /></div>;
-  }
-
-  if (shareInfo?.access_type === 'password' && !verified) {
-    return (
-      <div style={{ padding: '24px', maxWidth: 400, margin: '100px auto' }}>
-        <Card title="需要密码">
-          <Form onFinish={handlePasswordSubmit}>
-            <Form.Item name="password_input" rules={[{ required: true, message: '请输入密码' }]}>
-              <Input.Password placeholder="请输入密码" />
-            </Form.Item>
-            <Form.Item>
-              <Button type="primary" htmlType="submit" block>
-                确认
-              </Button>
-            </Form.Item>
-          </Form>
-        </Card>
-      </div>
-    );
-  }
-
-  return (
-    <div style={{ padding: '24px', maxWidth: 960, margin: 'auto' }}>
-      <Card>
-        <Title level={4}>{shareInfo?.name}</Title>
-        <Text type="secondary">
-          创建于 {shareInfo && format(parseISO(shareInfo.created_at), 'yyyy-MM-dd')}
-          {shareInfo?.expires_at && `，将于 ${format(parseISO(shareInfo.expires_at), 'yyyy-MM-dd')} 过期`}
-        </Text>
-        <div style={{ margin: '16px 0' }}>
-          {renderBreadcrumb()}
-        </div>
-        <List
-          loading={loading}
-          dataSource={entries}
-          renderItem={item => (
-            <List.Item
-              actions={[
-                !item.is_dir ? <Button type="text" icon={<DownloadOutlined />} href={shareApi.downloadUrl(token!, (currentPath === '/' ? '' : currentPath) + '/' + item.name, password)} download /> : null
-              ]}
-            >
-              <List.Item.Meta
-                avatar={item.is_dir ? <FolderOutlined /> : <FileOutlined />}
-                title={<a onClick={() => handleEntryClick(item)}>{item.name}</a>}
-                description={!item.is_dir ? `${(item.size / 1024).toFixed(2)} KB` : ''}
-              />
-            </List.Item>
-          )}
-        />
-      </Card>
-    </div>
-  );
-});
-
-export default PublicSharePage;

web/src/pages/PublicSharePage/DirectoryViewer.tsx

@@ -0,0 +1,110 @@
+import { memo, useState, useEffect, useCallback } from 'react';
+import { Card, message, List, Typography, Button, Empty, Breadcrumb } from 'antd';
+import { FileOutlined, FolderOutlined, DownloadOutlined } from '@ant-design/icons';
+import { shareApi, type ShareInfo } from '../../api/share';
+import { type VfsEntry } from '../../api/vfs';
+import { format, parseISO } from 'date-fns';
+
+const { Title, Text } = Typography;
+
+interface DirectoryViewerProps {
+    token: string;
+    shareInfo: ShareInfo;
+    password?: string;
+}
+
+export const DirectoryViewer = memo(function DirectoryViewer({ token, shareInfo, password }: DirectoryViewerProps) {
+    const [loading, setLoading] = useState(true);
+    const [entries, setEntries] = useState<VfsEntry[]>([]);
+    const [currentPath, setCurrentPath] = useState('/');
+    const [error, setError] = useState('');
+
+    const loadData = useCallback(async (p: string) => {
+        setLoading(true);
+        setError('');
+        try {
+            const listing = await shareApi.listDir(token, p, password);
+            setEntries(listing.entries || []);
+            setCurrentPath(p);
+        } catch (e: any) {
+            setError(e.message || '加载分享失败');
+        } finally {
+            setLoading(false);
+        }
+    }, [token, password]);
+
+    useEffect(() => {
+        loadData(currentPath);
+    }, [loadData, currentPath]);
+
+    const handleEntryClick = (entry: VfsEntry) => {
+        if (entry.is_dir) {
+            const newPath = (currentPath === '/' ? '' : currentPath) + '/' + entry.name;
+            loadData(newPath);
+        } else {
+            message.info('暂不支持预览');
+        }
+    };
+
+    const handleBreadcrumbClick = (path: string) => {
+        loadData(path);
+    };
+
+    const renderBreadcrumb = () => {
+        const parts = currentPath.split('/').filter(Boolean);
+        const items = [{ title: '全部文件', path: '/' }];
+        parts.forEach((part, i) => {
+            const path = '/' + parts.slice(0, i + 1).join('/');
+            items.push({ title: part, path });
+        });
+        return (
+            <Breadcrumb>
+                {items.map((item, i) => (
+                    <Breadcrumb.Item key={i}>
+                        {i === items.length - 1 ? (
+                            <span>{item.title}</span>
+                        ) : (
+                            <a onClick={() => handleBreadcrumbClick(item.path)}>{item.title}</a>
+                        )}
+                    </Breadcrumb.Item>
+                ))}
+            </Breadcrumb>
+        );
+    };
+
+    if (error) {
+        return <div style={{ textAlign: 'center', padding: 50 }}><Empty description={error} /></div>;
+    }
+
+    return (
+        <div style={{ padding: '24px', maxWidth: 960, margin: 'auto' }}>
+            <Card>
+                <Title level={4}>{shareInfo?.name}</Title>
+                <Text type="secondary">
+                    创建于 {shareInfo && format(parseISO(shareInfo.created_at), 'yyyy-MM-dd')}
+                    {shareInfo?.expires_at && `，将于 ${format(parseISO(shareInfo.expires_at), 'yyyy-MM-dd')} 过期`}
+                </Text>
+                <div style={{ margin: '16px 0' }}>
+                    {renderBreadcrumb()}
+                </div>
+                <List
+                    loading={loading}
+                    dataSource={entries}
+                    renderItem={item => (
+                        <List.Item
+                            actions={[
+                                !item.is_dir ? <Button type="text" icon={<DownloadOutlined />} href={shareApi.downloadUrl(token!, (currentPath === '/' ? '' : currentPath) + '/' + item.name, password)} download /> : null
+                            ]}
+                        >
+                            <List.Item.Meta
+                                avatar={item.is_dir ? <FolderOutlined /> : <FileOutlined />}
+                                title={<a onClick={() => handleEntryClick(item)}>{item.name}</a>}
+                                description={!item.is_dir ? `${(item.size / 1024).toFixed(2)} KB` : ''}
+                            />
+                        </List.Item>
+                    )}
+                />
+            </Card>
+        </div>
+    );
+});

web/src/pages/PublicSharePage/FileViewer.tsx

@@ -0,0 +1,102 @@
+import { memo, useState, useEffect } from 'react';
+import { Card, Spin, Button, Typography, Empty } from 'antd';
+import { DownloadOutlined } from '@ant-design/icons';
+import { shareApi, type ShareInfo } from '../../api/share';
+import { type VfsEntry } from '../../api/vfs';
+import { format, parseISO } from 'date-fns';
+import ReactMarkdown from 'react-markdown';
+
+const { Title, Text } = Typography;
+
+interface FileViewerProps {
+  token: string;
+  shareInfo: ShareInfo;
+  entry: VfsEntry;
+  password?: string;
+}
+
+export const FileViewer = memo(function FileViewer({ token, shareInfo, entry, password }: FileViewerProps) {
+  const [loading, setLoading] = useState(true);
+  const [content, setContent] = useState<string>('');
+  const [error, setError] = useState('');
+
+  useEffect(() => {
+    const loadFileContent = async () => {
+      setLoading(true);
+      setError('');
+      try {
+        const url = shareApi.downloadUrl(token, entry.name, password);
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error('无法加载文件');
+        }
+        const text = await response.text();
+        setContent(text);
+      } catch (e: any) {
+        setError(e.message || '加载文件失败');
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    if (entry.name.endsWith('.md')) {
+      loadFileContent();
+    } else {
+      setLoading(false);
+    }
+  }, [token, entry.name, password]);
+
+  const renderContent = () => {
+    if (loading) {
+      return <div style={{ textAlign: 'center', padding: 50 }}><Spin /></div>;
+    }
+    if (error) {
+      return <Empty description={error} />;
+    }
+    if (entry.name.endsWith('.md')) {
+      return <ReactMarkdown>{content}</ReactMarkdown>;
+    }
+    return (
+      <Empty
+        description={
+          <div>
+            <p>暂不支持在线预览此类型文件</p>
+            <Button
+              type="primary"
+              icon={<DownloadOutlined />}
+              href={shareApi.downloadUrl(token, entry.name, password)}
+              download
+            >
+              下载文件
+            </Button>
+          </div>
+        }
+      />
+    );
+  };
+
+  return (
+    <div style={{ padding: '24px', maxWidth: 960, margin: 'auto' }}>
+      <Card>
+        <Title level={4}>{entry.name}</Title>
+        <Text type="secondary">
+          创建于 {shareInfo && format(parseISO(shareInfo.created_at), 'yyyy-MM-dd')}
+          {shareInfo?.expires_at && `，将于 ${format(parseISO(shareInfo.expires_at), 'yyyy-MM-dd')} 过期`}
+        </Text>
+        <div style={{ marginTop: 16 }}>
+          <Button
+            style={{ marginBottom: 16 }}
+            icon={<DownloadOutlined />}
+            href={shareApi.downloadUrl(token, entry.name, password)}
+            download
+          >
+            下载
+          </Button>
+        </div>
+        <Card>
+          {renderContent()}
+        </Card>
+      </Card>
+    </div>
+  );
+});

web/src/pages/PublicSharePage/index.tsx

@@ -0,0 +1,109 @@
+import { memo, useState, useEffect, useCallback } from 'react';
+import { useParams } from 'react-router';
+import { Card, message, Spin, Button, Empty, Input, Form } from 'antd';
+import { shareApi, type ShareInfo } from '../../api/share';
+import { type VfsEntry } from '../../api/vfs';
+import { DirectoryViewer } from './DirectoryViewer';
+import { FileViewer } from './FileViewer';
+
+const PublicSharePage = memo(function PublicSharePage() {
+  const { token } = useParams<{ token: string }>();
+  const [loading, setLoading] = useState(true);
+  const [shareInfo, setShareInfo] = useState<ShareInfo | null>(null);
+  const [entry, setEntry] = useState<VfsEntry | null>(null);
+  const [error, setError] = useState('');
+  const [password, setPassword] = useState('');
+  const [verified, setVerified] = useState(false);
+
+  const loadData = useCallback(async (pwd?: string) => {
+    if (!token) return;
+    setLoading(true);
+    setError('');
+    try {
+      let info = shareInfo;
+      if (!info) {
+        info = await shareApi.get(token);
+        setShareInfo(info);
+      }
+
+      if (info?.access_type === 'password' && !verified) {
+        setLoading(false);
+        return;
+      }
+
+      const currentPassword = pwd || password;
+
+      if (info.paths.length === 1) {
+        const listing = await shareApi.listDir(token, '/', currentPassword);
+        if (listing.entries.length === 1) {
+          const singleEntry = listing.entries[0];
+          setEntry(singleEntry);
+        }
+      }
+
+    } catch (e: any) {
+      setError(e.message || '加载分享失败');
+      if (e.message === '需要密码') {
+        setVerified(false);
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [token, shareInfo, password, verified]);
+
+  useEffect(() => {
+    loadData();
+  }, [loadData]);
+
+  const handlePasswordSubmit = async (values: { password_input: string }) => {
+    if (!token) return;
+    try {
+      await shareApi.verifyPassword(token, values.password_input);
+      setPassword(values.password_input);
+      setVerified(true);
+      setError('');
+      loadData(values.password_input);
+    } catch (e: any) {
+      message.error(e.message || '密码错误');
+    }
+  };
+
+  if (loading && !shareInfo) {
+    return <div style={{ textAlign: 'center', padding: 50 }}><Spin size="large" /></div>;
+  }
+
+  if (error && !error.includes('需要密码')) {
+    return <div style={{ textAlign: 'center', padding: 50 }}><Empty description={error} /></div>;
+  }
+
+  if (shareInfo?.access_type === 'password' && !verified) {
+    return (
+      <div style={{ padding: '24px', maxWidth: 400, margin: '100px auto' }}>
+        <Card title="需要密码">
+          <Form onFinish={handlePasswordSubmit}>
+            <Form.Item name="password_input" rules={[{ required: true, message: '请输入密码' }]}>
+              <Input.Password placeholder="请输入密码" />
+            </Form.Item>
+            <Form.Item>
+              <Button type="primary" htmlType="submit" block>
+                确认
+              </Button>
+            </Form.Item>
+          </Form>
+        </Card>
+      </div>
+    );
+  }
+
+  if (!shareInfo) {
+    return <div style={{ textAlign: 'center', padding: 50 }}><Empty description="无法加载分享信息" /></div>;
+  }
+
+  if (entry && !entry.is_dir) {
+    return <FileViewer token={token!} shareInfo={shareInfo} entry={entry} password={password} />;
+  } else {
+    return <DirectoryViewer token={token!} shareInfo={shareInfo} password={password} />;
+  }
+});
+
+export default PublicSharePage;

web/src/pages/SetupPage.tsx

@@ -26,7 +26,7 @@ const SetupPage = () => {
             root: values.root_dir
           },
           sub_path: null,
-          mount_path: values.mount_path,
+          path: values.path,
           enabled: true
         });
         window.location.href = '/';
@@ -41,7 +41,7 @@ const SetupPage = () => {
 
   const stepFields = [
     ['db_driver', 'vector_db_driver'],
-    ['adapter_name', 'adapter_type', 'mount_path', 'root_dir'],
+    ['adapter_name', 'adapter_type', 'path', 'root_dir'],
     ['username', 'full_name', 'email', 'password', 'confirm'],
   ]
 
@@ -105,7 +105,7 @@ const SetupPage = () => {
           </Form.Item>
           <Form.Item
             label="挂载路径"
-            name="mount_path"
+            name="path"
             initialValue="/local"
             rules={[{ required: true, message: '请输入挂载路径！' }]}
           >

web/src/pages/SystemSettingsPage/SystemSettingsPage.tsx

@@ -1,4 +1,4 @@
-import { Form, Input, Button, message, Tabs, Space } from 'antd';
+import { Form, Input, Button, message, Tabs, Space, Card } from 'antd';
 import { useEffect, useState } from 'react';
 import PageCard from '../../components/PageCard';
 import { getAllConfig, setConfig } from '../../api/config';
@@ -11,16 +11,23 @@ const APP_CONFIG_KEYS = [
   { key: 'SERVER_URL', label: '服务端URL', default: API_BASE_URL },
 ];
 
-const AI_CONFIG_KEYS = [
-  { key: 'AI_API_URL', label: 'AI API地址' },
-  { key: 'AI_VISION_MODEL', label: '视觉模型' },
-  { key: 'AI_EMBED_MODEL', label: '嵌入模型' },
-  { key: 'AI_API_KEY', label: 'API Key' },
+const VISION_CONFIG_KEYS = [
+  { key: 'AI_VISION_API_URL', label: '视觉模型 API 地址' },
+  { key: 'AI_VISION_MODEL', label: '视觉模型', default: 'Qwen/Qwen2.5-VL-32B-Instruct' },
+  { key: 'AI_VISION_API_KEY', label: '视觉模型 API Key' },
 ];
 
+const EMBED_CONFIG_KEYS = [
+  { key: 'AI_EMBED_API_URL', label: '嵌入模型 API 地址' },
+  { key: 'AI_EMBED_MODEL', label: '嵌入模型', default: 'Qwen/Qwen3-Embedding-8B' },
+  { key: 'AI_EMBED_API_KEY', label: '嵌入模型 API Key' },
+];
+
+const ALL_AI_KEYS = [...VISION_CONFIG_KEYS, ...EMBED_CONFIG_KEYS];
+
 export default function SystemSettingsPage() {
   const [loading, setLoading] = useState(false);
-  const [config, setConfigState] = useState<Record<string, string> | null>(null); 
+  const [config, setConfigState] = useState<Record<string, string> | null>(null);
   const [activeTab, setActiveTab] = useState('app');
 
   useEffect(() => {
@@ -41,14 +48,13 @@ export default function SystemSettingsPage() {
     setLoading(false);
   };
 
-  // 加载中时不渲染表单
   if (!config) {
     return <PageCard title='系统设置'><div>加载中...</div></PageCard>;
   }
 
   return (
     <PageCard
-    title='系统设置'
+      title='系统设置'
     >
       <Space direction="vertical" style={{ width: '100%' }} size={32}>
         <Tabs
@@ -73,7 +79,7 @@ export default function SystemSettingsPage() {
                   }}
                   onFinish={handleSave}
                   style={{ marginTop: 24 }}
-                  key={JSON.stringify(config)} 
+                  key={JSON.stringify(config)}
                 >
                   {APP_CONFIG_KEYS.map(({ key, label }) => (
                     <Form.Item key={key} name={key} label={label}>
@@ -100,18 +106,27 @@ export default function SystemSettingsPage() {
                 <Form
                   layout="vertical"
                   initialValues={{
-                    ...Object.fromEntries(AI_CONFIG_KEYS.map(({ key }) => [key, config[key] ?? ''])),
+                    ...Object.fromEntries(ALL_AI_KEYS.map(({ key, default: def }) => [key, config[key] ?? def ?? ''])),
                   }}
                   onFinish={handleSave}
                   style={{ marginTop: 24 }}
-                  key={JSON.stringify(config)} // 强制表单重置
+                  key={JSON.stringify(config)}
                 >
-                  {AI_CONFIG_KEYS.map(({ key, label }) => (
-                    <Form.Item key={key} name={key} label={label}>
-                      <Input size="large" />
-                    </Form.Item>
-                  ))}
-                  <Form.Item>
+                  <Card title="视觉模型" style={{ marginBottom: 24 }}>
+                    {VISION_CONFIG_KEYS.map(({ key, label }) => (
+                      <Form.Item key={key} name={key} label={label}>
+                        <Input size="large" />
+                      </Form.Item>
+                    ))}
+                  </Card>
+                  <Card title="嵌入模型">
+                    {EMBED_CONFIG_KEYS.map(({ key, label }) => (
+                      <Form.Item key={key} name={key} label={label}>
+                        <Input size="large" />
+                      </Form.Item>
+                    ))}
+                  </Card>
+                  <Form.Item style={{ marginTop: 24 }}>
                     <Button type="primary" htmlType="submit" loading={loading} block>
                       保存
                     </Button>

web/src/router/index.tsx

@@ -3,7 +3,7 @@ import type { RouteObject } from 'react-router';
 import LayoutShell from './LayoutShell.tsx';
 import LoginPage from '../pages/LoginPage.tsx';
 import SetupPage from '../pages/SetupPage.tsx';
-import PublicSharePage from '../pages/PublicSharePage.tsx';
+import PublicSharePage from '../pages/PublicSharePage';
 import { useAuth } from '../contexts/AuthContext';
 import type { JSX } from 'react';
 

web/src/theme.ts

@@ -4,6 +4,7 @@ import type { ThemeConfig } from 'antd/es/config-provider/context';
 export const foxelTheme: ThemeConfig = {
   algorithm: [theme.defaultAlgorithm, theme.compactAlgorithm],
   token: {
+    colorInfoBg: '#efefef',
     colorPrimary: '#111',
     colorInfo: '#111',
     colorText: '#111',
@@ -37,7 +38,7 @@ export const foxelTheme: ThemeConfig = {
     },
     Card: {
       borderRadiusLG: 16,
-     padding: 16
+      padding: 16
     },
     Input: { borderRadius: 8 },
     Dropdown: { controlItemBgHover: '#f2f2f2' },