Initial commit

.dockerignore

@@ -0,0 +1,27 @@
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+.venv/
+.env/
+
+# Database
+*.sqlite3
+*.sqlite3-shm
+*.sqlite3-wal
+*.db
+*.db.lock
+
+# Node
+web/node_modules/
+web/dist/
+
+# IDEs and editors
+.idea/
+.vscode/

.github/workflows/docker.yml

@@ -0,0 +1,51 @@
+name: Build and Push Docker image
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+  workflow_dispatch:
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: docker-container
+
+      - name: Lowercase repo name
+        run: echo "REPO_LC=${GITHUB_REPOSITORY,,}" >> $GITHUB_ENV
+
+      - name: Set up Docker tags
+        id: meta
+        run: |
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            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
+          fi
+
+      - name: Log in to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64
+          push: true
+          tags: ${{ env.DOCKER_TAGS }}

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*$py.class
+
+.venv/
+.vscode/
+data/
+
+.env

CONTRIBUTING.md

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

Dockerfile

@@ -0,0 +1,32 @@
+FROM oven/bun:1.2-slim AS frontend-builder
+
+WORKDIR /app/web
+
+COPY web/package.json web/bun.lock ./
+RUN bun install --frozen-lockfile
+
+COPY web/ ./
+
+RUN bun run build
+
+FROM python:3.13-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y nginx && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt && pip install gunicorn
+
+COPY --from=frontend-builder /app/web/dist /app/web/dist
+
+COPY . .
+
+COPY nginx.conf /etc/nginx/nginx.conf
+
+EXPOSE 80
+
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+CMD ["/entrypoint.sh"]

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright © 2025 Foxel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

api/middleware.py

@@ -0,0 +1,46 @@
+import time
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from services.logging import LogService
+from models.database import UserAccount
+import jwt
+from jwt.exceptions import InvalidTokenError
+from services.auth import  ALGORITHM
+from services.config import ConfigCenter
+
+class LoggingMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        start_time = time.time()
+        user_id = None
+        if "authorization" in request.headers:
+            token_str = request.headers.get("authorization")
+            try:
+                if token_str and token_str.startswith("Bearer "):
+                    token = token_str.split(" ")[1]
+                    payload = jwt.decode(token, ConfigCenter.get_secret_key("SECRET_KEY"), algorithms=[ALGORITHM])
+                    username = payload.get("sub")
+                    if username:
+                        user_account = await UserAccount.get_or_none(username=username)
+                        if user_account:
+                            user_id = user_account.id
+            except (InvalidTokenError, Exception):
+                pass
+
+        response = await call_next(request)
+        
+        process_time = (time.time() - start_time) * 1000
+        
+        details = {
+            "client_ip": request.client.host,
+            "method": request.method,
+            "path": request.url.path,
+            "headers": dict(request.headers),
+            "status_code": response.status_code,
+            "process_time_ms": round(process_time, 2)
+        }
+        
+        message = f"{request.method} {request.url.path} - {response.status_code}"
+        
+        await LogService.api(message, details, user_id)
+        
+        return response

api/response.py

@@ -0,0 +1,16 @@
+from typing import Any, Optional
+
+
+def success(data: Any = None, msg: str = "ok", code: int = 0):
+    """标准成功响应包装。"""
+    return {"code": code, "msg": msg, "data": data}
+
+
+def page(items: list[Any], total: int, page: int, page_size: int):
+    """统一分页数据结构。"""
+    pages = (total + page_size - 1) // page_size if page_size else 0
+    return {"items": items, "total": total, "page": page, "page_size": page_size, "pages": pages}
+
+
+def error(msg: str, code: int = 1, data: Optional[Any] = None):
+    return {"code": code, "msg": msg, "data": data}

api/routers.py

@@ -0,0 +1,18 @@
+from fastapi import FastAPI
+
+from .routes import adapters, virtual_fs, mounts, 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)
+    app.include_router(tasks.router)
+    app.include_router(logs.router)
+    app.include_router(share.router)
+    app.include_router(share.public_router)
+    app.include_router(backup.router)

api/routes/adapters.py

@@ -0,0 +1,179 @@
+from fastapi import APIRouter, HTTPException, Depends
+from tortoise.transactions import in_transaction
+from typing import Annotated
+
+from models import StorageAdapter, Mount
+from schemas import AdapterCreate, AdapterOut
+from services.auth import get_current_active_user, User
+from services.adapters.registry import runtime_registry, get_config_schemas
+from api.response import success
+from services.logging import LogService
+
+router = APIRouter(prefix="/api/adapters", tags=["adapters"])
+
+
+def validate_and_normalize_config(adapter_type: str, cfg):
+    schemas = get_config_schemas()
+    if not isinstance(cfg, dict):
+        raise HTTPException(400, detail="config 必须是对象")
+    schema = schemas.get(adapter_type)
+    if not schema:
+        raise HTTPException(400, detail=f"不支持的适配器类型: {adapter_type}")
+    out = {}
+    missing = []
+    for f in schema:
+        k = f["key"]
+        if k in cfg and cfg[k] not in (None, ""):
+            out[k] = cfg[k]
+        elif "default" in f:
+            out[k] = f["default"]
+        elif f.get("required"):
+            missing.append(k)
+    if missing:
+        raise HTTPException(400, detail="缺少必填配置字段: " + ", ".join(missing))
+    return out
+
+
+@router.post("")
+async def create_adapter(
+    data: AdapterCreate,
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    adapter_fields = {
+        "name": data.name,
+        "type": data.type,
+        "config": validate_and_normalize_config(data.type, data.config or {}),
+        "enabled": data.enabled,
+    }
+    norm_path = AdapterCreate.normalize_mount_path(data.mount_path)
+    exists = await Mount.get_or_none(path=norm_path)
+    if exists:
+        raise HTTPException(400, detail="Mount path already exists")
+    async with in_transaction():
+        rec = await StorageAdapter.create(**adapter_fields)
+        await Mount.create(
+            path=norm_path,
+            sub_path=data.sub_path,
+            adapter=rec,
+            enabled=True,
+        )
+    rec.mount_path = norm_path
+    rec.sub_path = data.sub_path
+    await runtime_registry.refresh()
+    await LogService.action(
+        "route:adapters",
+        f"Created adapter {rec.name}",
+        details=adapter_fields,
+        user_id=current_user.id if hasattr(current_user, "id") else None,
+    )
+    return success(rec)
+
+
+@router.get("")
+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)
+    return success(out)
+
+
+@router.get("/available")
+async def available_adapter_types(
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    data = []
+    for t, fields in get_config_schemas().items():
+        data.append({
+            "type": t,
+            "name": "本地文件系统" if t == "local" else ("WebDAV" if t == "webdav" else t),
+            "config_schema": fields,
+        })
+    return success(data)
+
+
+@router.get("/{adapter_id}")
+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")
+    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)
+
+
+@router.put("/{adapter_id}")
+async def update_adapter(
+    adapter_id: int,
+    data: AdapterCreate,
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+
+    rec = await StorageAdapter.get_or_none(id=adapter_id).prefetch_related("mounts")
+    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):
+        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
+    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",
+        f"Updated adapter {rec.name}",
+        details=data.model_dump(),
+        user_id=current_user.id if hasattr(current_user, "id") else None,
+    )
+    return success(rec)
+
+
+@router.delete("/{adapter_id}")
+async def delete_adapter(
+    adapter_id: int,
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    deleted = await StorageAdapter.filter(id=adapter_id).delete()
+    if not deleted:
+        raise HTTPException(404, detail="Not found")
+    await runtime_registry.refresh()
+    await LogService.action(
+        "route:adapters",
+        f"Deleted adapter {adapter_id}",
+        details={"adapter_id": adapter_id},
+        user_id=current_user.id if hasattr(current_user, "id") else None,
+    )
+    return success({"deleted": True})

api/routes/auth.py

@@ -0,0 +1,53 @@
+from typing import Annotated
+from fastapi import APIRouter, HTTPException, Depends, Form
+from fastapi.security import OAuth2PasswordRequestForm
+from services.auth import (
+    authenticate_user_db,
+    create_access_token,
+    ACCESS_TOKEN_EXPIRE_MINUTES,
+    register_user,
+    Token,
+)
+from pydantic import BaseModel
+from datetime import timedelta
+from api.response import success
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+
+class RegisterRequest(BaseModel):
+    username: str
+    password: str
+    email: str | None = None
+    full_name: str | None = None
+
+@router.post("/register", summary="注册第一个管理员用户")
+async def register(data: RegisterRequest):
+    """
+    仅当系统中没有用户时，才允许注册。
+    """
+    user = await register_user(
+        username=data.username,
+        password=data.password,
+        email=data.email,
+        full_name=data.full_name,
+    )
+    return success({"username": user.username}, msg="初始用户注册成功")
+
+
+@router.post("/login")
+async def login_for_access_token(
+    form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
+) -> Token:
+    user = await authenticate_user_db(form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=401,
+            detail="用户名或密码错误",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = await create_access_token(
+        data={"sub": user.username}, expires_delta=access_token_expires
+    )
+    return Token(access_token=access_token, token_type="bearer")

api/routes/backup.py

@@ -0,0 +1,50 @@
+from fastapi import APIRouter, Depends, UploadFile, File, HTTPException
+from fastapi.responses import JSONResponse
+from services.auth import get_current_active_user
+from services.backup import BackupService
+from models.database import UserAccount
+import json
+import datetime
+
+router = APIRouter(
+    prefix="/api/backup",
+    tags=["Backup & Restore"],
+    dependencies=[Depends(get_current_active_user)],
+)
+
+@router.get("/export", summary="导出全站数据")
+async def export_backup():
+    """
+    生成并下载一个包含所有关键数据的JSON文件。
+    """
+    try:
+        data = await BackupService.export_data()
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        headers = {
+            "Content-Disposition": f"attachment; filename=foxel_backup_{timestamp}.json"
+        }
+        return JSONResponse(content=data, headers=headers)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/import", summary="导入数据")
+async def import_backup(file: UploadFile = File(...)):
+    """
+    从上传的JSON文件恢复数据。
+    **警告**: 这将会覆盖所有现有数据！
+    """
+
+    if not file.filename.endswith(".json"):
+        raise HTTPException(status_code=400, detail="无效的文件类型, 请上传 .json 文件")
+
+    try:
+        contents = await file.read()
+        data = json.loads(contents)
+    except Exception:
+        raise HTTPException(status_code=400, detail="无法解析JSON文件")
+    
+    try:
+        await BackupService.import_data(data)
+        return {"message": "数据导入成功。"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"导入失败: {e}")

api/routes/config.py

@@ -0,0 +1,45 @@
+from fastapi import APIRouter, Depends, Form
+from typing import Annotated
+from services.config import ConfigCenter
+from services.auth import get_current_active_user, User, has_users
+from api.response import success
+
+router = APIRouter(prefix="/api/config", tags=["config"])
+
+
+@router.get("/")
+async def get_config(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    key: str
+):
+    value = await ConfigCenter.get(key)
+    return success({"key": key, "value": value})
+
+
+@router.post("/")
+async def set_config(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    key: str = Form(...),
+    value: str = Form(...)
+):
+    await ConfigCenter.set(key, value)
+    return success({"key": key, "value": value})
+
+
+@router.get("/all")
+async def get_all_config(
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    configs = await ConfigCenter.get_all()
+    return success(configs)
+
+
+@router.get("/status")
+async def get_system_status():
+    system_info = {
+        "version": "1.0.0",
+        "title":  await ConfigCenter.get("APP_NAME", "Foxel"),
+        "logo": await ConfigCenter.get("APP_LOGO", "/logo.svg"),
+        "is_initialized": await has_users()
+    }
+    return success(system_info)

api/routes/logs.py

@@ -0,0 +1,48 @@
+from typing import Optional
+from fastapi import APIRouter, Query
+from models.database import Log
+from api.response import page, success
+from tortoise.expressions import Q
+from datetime import datetime
+
+router = APIRouter(prefix="/api/logs", tags=["Logs"])
+
+@router.get("")
+async def get_logs(
+    page_num: int = Query(1, alias="page"),
+    page_size: int = Query(20, alias="page_size"),
+    level: Optional[str] = Query(None),
+    source: Optional[str] = Query(None),
+    start_time: Optional[datetime] = Query(None),
+    end_time: Optional[datetime] = Query(None),
+):
+    """获取日志列表，支持分页和筛选"""
+    query = Log.all()
+    if level:
+        query = query.filter(level=level)
+    if source:
+        query = query.filter(source__icontains=source)
+    if start_time:
+        query = query.filter(timestamp__gte=start_time)
+    if end_time:
+        query = query.filter(timestamp__lte=end_time)
+
+    total = await query.count()
+    logs = await query.order_by("-timestamp").offset((page_num - 1) * page_size).limit(page_size)
+
+    return success(page([log for log in logs], total, page_num, page_size))
+
+@router.delete("")
+async def clear_logs(
+    start_time: Optional[datetime] = Query(None),
+    end_time: Optional[datetime] = Query(None),
+):
+    """清理指定时间范围内的日志"""
+    query = Log.all()
+    if start_time:
+        query = query.filter(timestamp__gte=start_time)
+    if end_time:
+        query = query.filter(timestamp__lte=end_time)
+    
+    deleted_count = await query.delete()
+    return success({"deleted_count": deleted_count})

api/routes/mounts.py

@@ -0,0 +1,84 @@
+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/processors.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, Depends, Body
+from typing import Annotated
+from services.processors.registry import get_config_schemas
+from services.virtual_fs import process_file
+from services.auth import get_current_active_user, User
+from api.response import success
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api/processors", tags=["processors"])
+
+
+@router.get("")
+async def list_processors(
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    schemas = get_config_schemas()
+    out = []
+    for t, meta in schemas.items():
+        out.append({
+            "type": meta["type"],
+            "name": meta["name"],
+            "supported_exts": meta.get("supported_exts", []),
+            "config_schema": meta["config_schema"],
+            "produces_file": meta.get("produces_file", False), 
+        })
+    return success(out)
+
+
+class ProcessRequest(BaseModel):
+    path: str
+    processor_type: str
+    config: dict
+    save_to: str | None = None
+    overwrite: bool = False
+
+
+@router.post("/process")
+async def process_file_with_processor(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    req: ProcessRequest = Body(...)
+):
+    save_to = req.path if req.overwrite else req.save_to
+    result = await process_file(req.path, req.processor_type, req.config, save_to)
+    return success(result)

api/routes/search.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, Depends, Query
+from schemas.fs import SearchResultItem
+from services.auth import get_current_active_user, User
+from services.ai import get_text_embedding
+from services.vector_db import VectorDBService
+
+router = APIRouter(prefix="/api/search", tags=["search"])
+
+async def search_files_by_vector(q: str, top_k: int):
+    embedding = await get_text_embedding(q)
+    vector_db = VectorDBService()
+    results = vector_db.search_vectors("vector_collection", embedding, top_k)
+    items = [
+        SearchResultItem(id=res["id"], path=res["entity"]["path"], score=res["distance"])
+        for res in results[0]
+    ]
+    return {"items": items, "query": q}
+
+async def search_files_by_name(q: str, top_k: int):
+    vector_db = VectorDBService()
+    results = vector_db.search_by_path("vector_collection", q, top_k)
+    items = [
+        SearchResultItem(id=idx, path=res["entity"]["path"], score=res["distance"])
+        for idx, res in enumerate(results[0])
+    ]
+    return {"items": items, "query": q}
+
+
+@router.get("")
+async def search_files(
+    q: str = Query(..., description="搜索查询"),
+    top_k: int = Query(10, description="返回结果数量"),
+    mode: str = Query("vector", description="搜索模式: 'vector' 或 'filename'"),
+    user: User = Depends(get_current_active_user),
+):
+    if mode == "vector":
+        return await search_files_by_vector(q, top_k)
+    elif mode == "filename":
+        return await search_files_by_name(q, top_k)
+    else:
+        return {"items": [], "query": q, "error": "Invalid search mode"}

api/routes/share.py

@@ -0,0 +1,195 @@
+from typing import List, Optional
+from urllib.parse import quote
+from fastapi import APIRouter, Depends, HTTPException, Request
+from pydantic import BaseModel
+
+from api.response import success
+from services.auth import User, get_current_active_user
+from services.share import share_service
+from services.virtual_fs import stream_file, stat_file
+from models.database import ShareLink, UserAccount
+
+public_router = APIRouter(prefix="/api/s", tags=["Share - Public"])
+router = APIRouter(prefix="/api/shares", tags=["Share - Management"])
+
+class ShareCreate(BaseModel):
+    name: str
+    paths: List[str]
+    expires_in_days: Optional[int] = 7
+    access_type: str = "public"
+    password: Optional[str] = None
+
+
+class ShareInfo(BaseModel):
+    id: int
+    token: str
+    name: str
+    paths: List[str]
+    created_at: str
+    expires_at: Optional[str] = None
+    access_type: str
+    
+    @classmethod
+    def from_orm(cls, obj: ShareLink):
+        return cls(
+            id=obj.id,
+            token=obj.token,
+            name=obj.name,
+            paths=obj.paths,
+            created_at=obj.created_at.isoformat(),
+            expires_at=obj.expires_at.isoformat() if obj.expires_at else None,
+            access_type=obj.access_type,
+        )
+
+# --- Management Routes ---
+
+@router.post("", response_model=ShareInfo)
+async def create_share(
+    payload: ShareCreate,
+    current_user: User = Depends(get_current_active_user),
+):
+    """
+    创建一个新的分享链接。
+    """
+    user_account = await UserAccount.get(id=current_user.id)
+    share = await share_service.create_share_link(
+        user=user_account,
+        name=payload.name,
+        paths=payload.paths,
+        expires_in_days=payload.expires_in_days,
+        access_type=payload.access_type,
+        password=payload.password,
+    )
+    return ShareInfo.from_orm(share)
+
+
+@router.get("", response_model=List[ShareInfo])
+async def get_my_shares(current_user: User = Depends(get_current_active_user)):
+    """
+    获取当前用户的所有分享链接。
+    """
+    user_account = await UserAccount.get(id=current_user.id)
+    shares = await share_service.get_user_shares(user=user_account)
+    return [ShareInfo.from_orm(s) for s in shares]
+
+
+@router.delete("/{share_id}")
+async def delete_share(
+    share_id: int,
+    current_user: User = Depends(get_current_active_user),
+):
+    """
+    删除一个分享链接。
+    """
+    await share_service.delete_share_link(user=current_user, share_id=share_id)
+    return success(msg="分享已取消")
+
+
+# --- Public Routes ---
+
+class SharePassword(BaseModel):
+    password: str
+
+@public_router.post("/{token}/verify")
+async def verify_password(token: str, payload: SharePassword):
+    """
+    验证分享链接的密码。
+    """
+    share = await share_service.get_share_by_token(token)
+    if share.access_type != "password":
+        raise HTTPException(status_code=400, detail="此分享不需要密码")
+
+    if not share_service._verify_password(payload.password, share.hashed_password):
+        raise HTTPException(status_code=403, detail="密码错误")
+    
+    # 在这里可以考虑返回一个有时效性的token用于后续访问，但为了简单起见，
+    # 我们让前端在每次请求时都带上密码或一个会话标识。
+    # 简单起见，我们只返回成功状态。
+    return success(msg="验证成功")
+
+
+@public_router.get("/{token}/ls")
+async def list_share_content(token: str, path: str = "/", password: Optional[str] = None):
+    """
+    列出分享链接中的文件和目录。
+    """
+    share = await share_service.get_share_by_token(token)
+    
+    if share.access_type == "password":
+        if not password:
+            raise HTTPException(status_code=401, detail="需要密码")
+        if not share_service._verify_password(password, share.hashed_password):
+            raise HTTPException(status_code=403, detail="密码错误")
+
+    content = await share_service.get_shared_item_details(share, path)
+    return success({
+        "path": path,
+        "entries": content.get("items", []),
+        "pagination": {
+            "total": content.get("total", 0),
+            "page": content.get("page", 1),
+            "page_size": content.get("page_size", 1),
+            "pages": content.get("pages", 1),
+        }
+    })
+
+@public_router.get("/{token}")
+async def get_share_info(token: str):
+    """
+    获取分享链接的元数据信息。
+    """
+    share = await share_service.get_share_by_token(token)
+    return success(ShareInfo.from_orm(share))
+
+
+
+@public_router.get("/{token}/download")
+async def download_shared_file(token: str, path: str, request: Request, password: Optional[str] = None):
+    """
+    下载分享链接中的单个文件。
+    """
+    if not path or path == "/" or ".." in path.split('/'):
+        raise HTTPException(status_code=400, detail="无效的文件路径")
+
+    share = await share_service.get_share_by_token(token)
+    if share.access_type == "password":
+        if not password:
+            raise HTTPException(status_code=401, detail="需要密码")
+        if not share_service._verify_password(password, share.hashed_password):
+            raise HTTPException(status_code=403, detail="密码错误")
+    base_shared_path = share.paths[0]
+
+    # 判断分享的是文件还是目录
+    is_dir = False
+    try:
+        stat = await stat_file(base_shared_path)
+        if stat and stat.get("is_dir"):
+            is_dir = True
+    except HTTPException as e:
+        if "Path is a directory" in str(e.detail) or "Not a file" in str(e.detail):
+            is_dir = True
+        else:
+            # The shared path itself doesn't exist, which is an issue.
+            raise HTTPException(status_code=404, detail="分享的源文件不存在")
+
+    if is_dir:
+        # 目录分享：拼接路径
+        full_virtual_path = f"{base_shared_path.rstrip('/')}/{path.lstrip('/')}"
+        if not full_virtual_path.startswith(base_shared_path):
+            raise HTTPException(status_code=403, detail="无权访问此路径")
+    else:
+        # 文件分享：路径应为分享的根路径
+        shared_filename = base_shared_path.split('/')[-1]
+        request_filename = path.lstrip('/')
+        if shared_filename != request_filename:
+            raise HTTPException(status_code=403, detail="无权访问此路径")
+        full_virtual_path = base_shared_path
+
+    range_header = request.headers.get("Range")
+    response = await stream_file(full_virtual_path, range_header)
+
+    # 设置 Content-Disposition 头来强制下载
+    filename = full_virtual_path.split('/')[-1]
+    response.headers["Content-Disposition"] = f"attachment; filename*=UTF-8''{quote(filename)}"
+    
+    return response

api/routes/tasks.py

@@ -0,0 +1,84 @@
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Annotated
+
+from models.database import AutomationTask
+from schemas.tasks import AutomationTaskCreate, AutomationTaskUpdate
+from api.response import success
+from services.auth import get_current_active_user, User
+from services.logging import LogService
+
+router = APIRouter(
+    prefix="/api/tasks",
+    tags=["Tasks"],
+    dependencies=[Depends(get_current_active_user)],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.post("/")
+async def create_task(
+    task_in: AutomationTaskCreate,
+    user: User = Depends(get_current_active_user)
+):
+    task = await AutomationTask.create(**task_in.model_dump())
+    await LogService.action(
+        "route:tasks",
+        f"Created task {task.name}",
+        details=task_in.model_dump(),
+        user_id=user.id if hasattr(user, "id") else None,
+    )
+    return success(task)
+
+
+@router.get("/{task_id}")
+async def get_task(task_id: int):
+    task = await AutomationTask.get_or_none(id=task_id)
+    if not task:
+        raise HTTPException(
+            status_code=404, detail=f"Task {task_id} not found")
+    return success(task)
+
+
+@router.get("/")
+async def list_tasks():
+    tasks = await AutomationTask.all()
+    return success(tasks)
+
+
+@router.put("/{task_id}")
+async def update_task(
+        current_user: Annotated[User, Depends(get_current_active_user)],
+        task_id: int, task_in: AutomationTaskUpdate):
+    task = await AutomationTask.get_or_none(id=task_id)
+    if not task:
+        raise HTTPException(
+            status_code=404, detail=f"Task {task_id} not found")
+    update_data = task_in.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(task, key, value)
+    await task.save()
+    await LogService.action(
+        "route:tasks",
+        f"Updated task {task.name}",
+        details=task_in.model_dump(),
+        user_id=current_user.id,
+    )
+    return success(task)
+
+
+@router.delete("/{task_id}")
+async def delete_task(
+    task_id: int,
+    user: User = Depends(get_current_active_user)
+):
+    deleted_count = await AutomationTask.filter(id=task_id).delete()
+    if not deleted_count:
+        raise HTTPException(
+            status_code=404, detail=f"Task {task_id} not found")
+    await LogService.action(
+        "route:tasks",
+        f"Deleted task {task_id}",
+        details={"task_id": task_id},
+        user_id=user.id if hasattr(user, "id") else None,
+    )
+    return success(msg="Task deleted")

api/routes/virtual_fs.py

@@ -0,0 +1,317 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException, Response, Query, Request, Depends
+import mimetypes
+import re
+from typing import Annotated
+
+from services.auth import get_current_active_user, User
+from services.virtual_fs import (
+    list_virtual_dir,
+    read_file,
+    write_file,
+    make_dir,
+    delete_path,
+    move_path,
+    resolve_adapter_and_rel,
+    stream_file,
+    generate_temp_link_token,
+    verify_temp_link_token,
+)
+from services.thumbnail import is_image_filename, get_or_create_thumb
+from schemas import MkdirRequest, MoveRequest
+from api.response import success
+from services.ai import get_text_embedding
+from services.vector_db import VectorDBService
+
+router = APIRouter(prefix='/api/fs', tags=["virtual-fs"])
+
+
+@router.get("/file/{full_path:path}")
+async def get_file(
+    full_path: str,
+    request: Request,
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+
+    try:
+        content = await read_file(full_path)
+    except FileNotFoundError:
+        raise HTTPException(404, detail="File not found")
+
+    if not isinstance(content, (bytes, bytearray)):
+        return Response(content=content, media_type="application/octet-stream")
+
+    content_length = len(content)
+    content_type = mimetypes.guess_type(
+        full_path)[0] or "application/octet-stream"
+
+    range_header = request.headers.get('Range')
+    if range_header:
+        range_match = re.match(r'bytes=(\d+)-(\d*)', range_header)
+        if range_match:
+            start = int(range_match.group(1))
+            end = int(range_match.group(2)) if range_match.group(
+                2) else content_length - 1
+
+            start = max(0, min(start, content_length - 1))
+            end = max(start, min(end, content_length - 1))
+
+            chunk = content[start:end + 1]
+            chunk_size = len(chunk)
+
+            headers = {
+                'Content-Range': f'bytes {start}-{end}/{content_length}',
+                'Accept-Ranges': 'bytes',
+                'Content-Length': str(chunk_size),
+                'Content-Type': content_type,
+            }
+
+            return Response(
+                content=chunk,
+                status_code=206,
+                headers=headers
+            )
+
+    headers = {
+        'Accept-Ranges': 'bytes',
+        'Content-Length': str(content_length),
+        'Content-Type': content_type,
+    }
+
+    if content_type.startswith('video/'):
+        headers['Cache-Control'] = 'public, max-age=3600'
+
+    return Response(content=content, headers=headers)
+
+
+@router.get("/thumb/{full_path:path}")
+async def get_thumb(
+    full_path: str,
+    w: int = Query(256, ge=8, le=1024),
+    h: int = Query(256, ge=8, le=1024),
+    fit: str = Query("cover"),
+):
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    if fit not in ("cover", "contain"):
+        raise HTTPException(400, detail="fit must be cover|contain")
+    adapter, mount, root, rel = await resolve_adapter_and_rel(full_path)
+    if not rel or rel.endswith('/'):
+        raise HTTPException(400, detail="Not a file")
+    if not is_image_filename(rel):
+        raise HTTPException(404, detail="Not an image")
+    # type: ignore
+    data, mime, key = await get_or_create_thumb(adapter, mount.adapter_id, root, rel, w, h, fit)
+    headers = {
+        'Cache-Control': 'public, max-age=3600',
+        'ETag': key,
+    }
+    return Response(content=data, media_type=mime, headers=headers)
+
+
+@router.get("/stream/{full_path:path}")
+async def stream_endpoint(
+    full_path: str,
+    request: Request,
+):
+    """支持 Range 的视频/大文件流式读取，优先使用底层适配器 Range 能力。"""
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    range_header = request.headers.get('Range')
+    try:
+        return await stream_file(full_path, range_header)
+    except HTTPException:
+        raise
+    except FileNotFoundError:
+        raise HTTPException(404, detail="File not found")
+    except Exception as e:
+        raise HTTPException(500, detail=f"Stream error: {e}")
+
+
+@router.get("/temp-link/{full_path:path}")
+async def get_temp_link(
+    full_path: str,
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    """获取文件的临时公开访问令牌"""
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    token = await generate_temp_link_token(full_path)
+    return success({"token": token, "path": full_path})
+
+
+@router.get("/public/{token}")
+async def access_public_file(
+    token: str,
+    request: Request,
+):
+    """通过令牌公开访问文件，支持 Range 请求"""
+    try:
+        path = await verify_temp_link_token(token)
+    except HTTPException as e:
+        raise e
+
+    range_header = request.headers.get('Range')
+    try:
+        return await stream_file(path, range_header)
+    except FileNotFoundError:
+        raise HTTPException(404, detail="File not found via token")
+    except Exception as e:
+        raise HTTPException(500, detail=f"File access error: {e}")
+
+
+@router.get("/stat/{full_path:path}")
+async def get_file_stat(
+    full_path: str,
+    current_user: Annotated[User, Depends(get_current_active_user)]
+):
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    from services.virtual_fs import stat_file
+    stat = await stat_file(full_path)
+    return success(stat)
+
+
+@router.post("/file/{full_path:path}")
+async def put_file(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    full_path: str,
+    file: UploadFile = File(...)
+):
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    data = await file.read()
+    await write_file(full_path, data)
+    return success({"written": True, "path": full_path, "size": len(data)})
+
+
+@router.post("/mkdir")
+async def api_mkdir(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    body: MkdirRequest
+):
+    path = body.path if body.path.startswith('/') else '/' + body.path
+    if not path or path == '/':
+        raise HTTPException(400, detail="Invalid path")
+    await make_dir(path)
+    return success({"created": True, "path": path})
+
+
+@router.post("/move")
+async def api_move(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    body: MoveRequest
+):
+    src = body.src if body.src.startswith('/') else '/' + body.src
+    dst = body.dst if body.dst.startswith('/') else '/' + body.dst
+    await move_path(src, dst)
+    return success({"moved": True, "src": src, "dst": dst})
+
+
+@router.post("/rename")
+async def api_rename(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    body: MoveRequest,
+    overwrite: bool = Query(False, description="是否允许覆盖已存在目标"),
+    debug: bool = Query(False, description="返回调试信息")
+):
+    src = body.src if body.src.startswith('/') else '/' + body.src
+    dst = body.dst if body.dst.startswith('/') else '/' + body.dst
+    from services.virtual_fs import rename_path
+    debug_info = await rename_path(src, dst, overwrite=overwrite, return_debug=debug)
+    return success({
+        "renamed": True,
+        "src": src,
+        "dst": dst,
+        "overwrite": overwrite,
+        **({"debug": debug_info} if debug else {})
+    })
+
+
+@router.post("/copy")
+async def api_copy(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    body: MoveRequest,
+    overwrite: bool = Query(False, description="是否覆盖已存在目标"),
+    debug: bool = Query(False, description="返回调试信息")
+):
+    from services.virtual_fs import copy_path
+    src = body.src if body.src.startswith('/') else '/' + body.src
+    dst = body.dst if body.dst.startswith('/') else '/' + body.dst
+    debug_info = await copy_path(src, dst, overwrite=overwrite, return_debug=debug)
+    return success({
+        "copied": True,
+        "src": src,
+        "dst": dst,
+        "overwrite": overwrite,
+        **({"debug": debug_info} if debug else {})
+    })
+
+
+@router.post("/upload/{full_path:path}")
+async def upload_stream(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    full_path: str,
+    file: UploadFile = File(...),
+    overwrite: bool = Query(True, description="是否覆盖已存在文件"),
+    chunk_size: int = Query(1024 * 1024, ge=8 * 1024,
+                            le=8 * 1024 * 1024, description="单次读取块大小")
+):
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    if full_path.endswith('/'):
+        raise HTTPException(400, detail="Path must be a file")
+    from services.virtual_fs import write_file_stream, resolve_adapter_and_rel
+    adapter, _m, root, rel = await resolve_adapter_and_rel(full_path)
+    exists_func = getattr(adapter, "exists", None)
+    if not overwrite and callable(exists_func):
+        try:
+            if await exists_func(root, rel):
+                raise HTTPException(409, detail="Destination exists")
+        except HTTPException:
+            raise
+        except Exception:
+            pass
+
+    async def gen():
+        while True:
+            chunk = await file.read(chunk_size)
+            if not chunk:
+                break
+            yield chunk
+    size = await write_file_stream(full_path, gen(), overwrite=overwrite)
+    return success({"uploaded": True, "path": full_path, "size": size, "overwrite": overwrite})
+
+
+@router.get("/{full_path:path}")
+async def browse_fs(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    full_path: str,
+    page_num: int = Query(1, alias="page", ge=1, description="页码"),
+    page_size: int = Query(50, ge=1, le=500, description="每页条数")
+):
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    result = await list_virtual_dir(full_path, page_num, page_size)
+    return success({
+        "path": full_path,
+        "entries": result["items"],
+        "pagination": {
+            "total": result["total"],
+            "page": result["page"],
+            "page_size": result["page_size"],
+            "pages": result["pages"]
+        }
+    })
+
+
+@router.delete("/{full_path:path}")
+async def api_delete(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    full_path: str
+):
+    full_path = '/' + full_path if not full_path.startswith('/') else full_path
+    await delete_path(full_path)
+    return success({"deleted": True, "path": full_path})
+
+
+@router.get("/")
+async def root_listing(
+    current_user: Annotated[User, Depends(get_current_active_user)],
+    page_num: int = Query(1, alias="page", ge=1, description="页码"),
+    page_size: int = Query(50, ge=1, le=500, description="每页条数")
+):
+    return await browse_fs("", page_num, page_size)

compose.yaml

@@ -0,0 +1,20 @@
+services:
+  foxel:
+    image: ghcr.io/drizzletime/foxel:last
+    container_name: foxel
+    restart: unless-stopped
+    ports:
+      - "8088:80"
+    environment:
+      - TZ=Asia/Shanghai
+      - SECRET_KEY=EnsRhL9NFPxgFVc+7t96/y70DIOR+9SpntcIqQa90TU=
+      - TEMP_LINK_SECRET_KEY=EnsRhL9NFPxgFVc+7t96/y70DIOR+9SpntcIqQa90TU=
+    volumes:
+      - ./data:/app/data
+    pull_policy: always
+    networks:
+      - foxel-network
+
+networks:
+  foxel-network:
+    driver: bridge

db/__init__.py

@@ -0,0 +1,3 @@
+from .session import init_db, close_db
+
+__all__ = ["init_db", "close_db"]

db/session.py

@@ -0,0 +1,23 @@
+from tortoise import Tortoise
+
+from services.adapters.registry import runtime_registry
+
+TORTOISE_ORM = {
+    "connections": {"default": "sqlite://data/db/db.sqlite3"},
+    "apps": {
+        "models": {
+            "models": ["models.database"],
+            "default_connection": "default",
+        }
+    },
+}
+
+
+async def init_db():
+    await Tortoise.init(config=TORTOISE_ORM)
+    await Tortoise.generate_schemas()
+    await runtime_registry.refresh()
+
+
+async def close_db():
+    await Tortoise.close_connections()

entrypoint.sh

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

main.py

@@ -0,0 +1,45 @@
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from fastapi import FastAPI
+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 api.middleware import LoggingMiddleware
+from services.adapters.registry import runtime_registry
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await init_db()
+    await runtime_registry.refresh()
+    try:
+        yield
+    finally:
+        await close_db()
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="Foxel",
+        description="AList-like virtual storage aggregator",
+        lifespan=lifespan,
+    )
+    include_routers(app)
+    app.add_middleware(LoggingMiddleware)
+    return app
+
+
+app = create_app()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

models/__init__.py

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

models/database.py

@@ -0,0 +1,95 @@
+from tortoise import fields
+from tortoise.models import Model
+
+
+class StorageAdapter(Model):
+    id = fields.IntField(pk=True)
+    name = fields.CharField(max_length=100, unique=True)
+    type = fields.CharField(max_length=30)
+    config = fields.JSONField()
+    enabled = fields.BooleanField(default=True)
+    mounts: fields.ReverseRelation["Mount"]
+
+    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)
+    email = fields.CharField(max_length=100, unique=True, null=True)
+    full_name = fields.CharField(max_length=100, null=True)
+    hashed_password = fields.CharField(max_length=128)
+    disabled = fields.BooleanField(default=False)
+
+    class Meta:
+        table = "user"
+
+
+class Configuration(Model):
+    id = fields.IntField(pk=True)
+    key = fields.CharField(max_length=100, unique=True)
+    value = fields.TextField()
+
+    class Meta:
+        table = "configurations"
+
+
+class AutomationTask(Model):
+    id = fields.IntField(pk=True)
+    name = fields.CharField(max_length=100)
+    event = fields.CharField(max_length=50)
+
+    path_pattern = fields.CharField(max_length=1024, null=True)
+    filename_regex = fields.CharField(max_length=255, null=True)
+
+    processor_type = fields.CharField(max_length=100)
+    processor_config = fields.JSONField()
+
+    enabled = fields.BooleanField(default=True)
+
+    class Meta:
+        table = "automation_tasks"
+
+
+class Log(Model):
+    id = fields.IntField(pk=True)
+    timestamp = fields.DatetimeField(auto_now_add=True)
+    level = fields.CharField(max_length=50)
+    source = fields.CharField(max_length=100)
+    message = fields.TextField()
+    details = fields.JSONField(null=True)
+    user_id = fields.IntField(null=True)
+
+    class Meta:
+        table = "logs"
+
+
+class ShareLink(Model):
+    id = fields.IntField(pk=True)
+    token = fields.CharField(max_length=100, unique=True, index=True)
+    name = fields.CharField(max_length=255)
+    paths = fields.JSONField()
+    user: fields.ForeignKeyRelation[UserAccount] = fields.ForeignKeyField(
+        "models.UserAccount", related_name="shares", on_delete=fields.CASCADE
+    )
+    created_at = fields.DatetimeField(auto_now_add=True)
+    expires_at = fields.DatetimeField(null=True)
+    access_type = fields.CharField(max_length=20, default="public")
+    hashed_password = fields.CharField(max_length=128, null=True)
+
+    class Meta:
+        table = "share_links"

nginx.conf

@@ -0,0 +1,44 @@
+user www-data;
+worker_processes auto;
+pid /run/nginx.pid;
+include /etc/nginx/modules-enabled/*.conf;
+
+events {
+    worker_connections 768;
+}
+
+http {
+    sendfile on;
+    tcp_nopush on;
+    types_hash_max_size 2048;
+    include /etc/nginx/mime.types;
+    default_type application/octet-stream;
+
+    ssl_protocols TLSv1.2 TLSv1.3; 
+    ssl_prefer_server_ciphers on;
+
+    access_log /var/log/nginx/access.log;
+    error_log /var/log/nginx/error.log;
+
+    gzip on;
+    gzip_disable "msie6";
+
+    server {
+        listen 80;
+        server_name _;
+
+        location ~ ^/(api|docs) {
+            proxy_pass http://127.0.0.1:8000;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+        }
+
+        location / {
+            root   /app/web/dist;
+            index  index.html;
+            try_files $uri $uri/ /index.html;
+        }
+    }
+}

requirements.txt

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

schemas/__init__.py

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

@@ -0,0 +1,32 @@
+from typing import Dict, Optional
+from pydantic import BaseModel, Field, validator
+
+
+class AdapterCreate(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  
+
+    @staticmethod
+    def normalize_mount_path(p: str) -> str:
+        p = p.strip()
+        if not p.startswith('/'):
+            p = '/' + p
+        p = p.rstrip('/')
+        return p or '/'
+
+    @validator("mount_path")
+    def _v_mount(cls, v: str):
+        if not v:
+            raise ValueError("mount_path required")
+        return cls.normalize_mount_path(v)
+
+
+class AdapterOut(AdapterCreate):
+    id: int
+
+    class Config:
+        from_attributes = True

schemas/fs.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+
+class VfsEntry(BaseModel):
+    name: str
+    is_dir: bool
+    size: int
+    mtime: int
+    type: Optional[str] = None
+    is_image: Optional[bool] = None
+
+
+class DirListing(BaseModel):
+    path: str
+    entries: List[VfsEntry]
+    pagination: Optional[dict] = None
+
+
+class SearchResultItem(BaseModel):
+    id: int | str
+    path: str
+    score: float
+
+
+class MkdirRequest(BaseModel):
+    path: str
+
+
+class MoveRequest(BaseModel):
+    src: str
+    dst: str

schemas/mounts.py

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

schemas/tasks.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
+
+
+class AutomationTaskBase(BaseModel):
+    name: str
+    event: str
+    path_pattern: Optional[str] = None
+    filename_regex: Optional[str] = None
+    processor_type: str
+    processor_config: Dict[str, Any] = {}
+    enabled: bool = True
+
+
+class AutomationTaskCreate(AutomationTaskBase):
+    pass
+
+
+class AutomationTaskUpdate(AutomationTaskBase):
+    name: Optional[str] = None
+    event: Optional[str] = None
+    processor_type: Optional[str] = None
+    processor_config: Optional[Dict[str, Any]] = None
+    enabled: Optional[bool] = None
+
+
+class AutomationTaskRead(AutomationTaskBase):
+    id: int
+
+    class Config:
+        orm_mode = True

services/adapters/base.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from typing import List, Dict, Protocol, runtime_checkable, Tuple, AsyncIterator
+from models import StorageAdapter
+
+# 约定：任意新适配器模块需定义:
+# ADAPTER_TYPE: str
+# CONFIG_SCHEMA: List[Dict]
+# ADAPTER_FACTORY: Callable[[StorageAdapter], BaseAdapter] (可省略, 会自动寻找 *Adapter 类)
+
+@runtime_checkable
+class BaseAdapter(Protocol):
+    record: StorageAdapter
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50) -> Tuple[List[Dict], int]: ...
+    async def read_file(self, root: str, rel: str) -> bytes: ...
+    async def write_file(self, root: str, rel: str, data: bytes): ...
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]): ... 
+    async def mkdir(self, root: str, rel: str): ...
+    async def delete(self, root: str, rel: str): ...
+    async def move(self, root: str, src_rel: str, dst_rel: str): ...
+    async def rename(self, root: str, src_rel: str, dst_rel: str): ... 
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False): ...
+    async def stream_file(self, root: str, rel: str, range_header: str | None): ...
+    async def stat_file(self, root: str, rel: str): ...
+    def get_effective_root(self, sub_path: str | None) -> str: ...

services/adapters/local.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+import os
+import shutil
+import stat
+import time
+from pathlib import Path
+from typing import List, Dict, Tuple, AsyncIterator
+import asyncio
+import mimetypes
+from fastapi import HTTPException
+from fastapi.responses import StreamingResponse, Response
+from models import StorageAdapter
+from services.logging import LogService
+
+
+def _safe_join(root: str, rel: str) -> Path:
+    root_path = Path(root).resolve()
+    full = (root_path / rel).resolve()
+    if not str(full).startswith(str(root_path)):
+        raise ValueError("Path escape detected")
+    return full
+
+
+DEFAULT_FILE_MODE = 0o666
+DEFAULT_DIR_MODE = 0o777
+
+
+def _apply_mode(path: Path, mode: int):
+    try:
+        os.chmod(path, mode)
+    except Exception:
+        pass
+
+
+class LocalAdapter:
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        self.root = self.record.config.get("root")
+        if not self.root:
+            raise ValueError("Local adapter config requires 'root'")
+        Path(self.root).mkdir(parents=True, exist_ok=True)
+
+    def get_effective_root(self, sub_path: str | None) -> str:
+        root = self.record.config.get("root")
+        if sub_path:
+            return str(Path(root) / sub_path)
+        return root
+
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50) -> Tuple[List[Dict], int]:
+        rel = rel.strip('/')
+        base = _safe_join(root, rel) if rel else Path(root)
+        if not base.exists():
+            return [], 0
+        if not base.is_dir():
+            raise NotADirectoryError(rel)
+        
+        # 获取所有文件名并排序
+        all_names = await asyncio.to_thread(lambda: sorted(os.listdir(base), key=str.lower))
+        total_count = len(all_names)
+        
+        # 计算分页范围
+        start_idx = (page_num - 1) * page_size
+        end_idx = start_idx + page_size
+        page_names = all_names[start_idx:end_idx]
+        
+        entries = []
+        for name in page_names:
+            fp = base / name
+            try:
+                st = await asyncio.to_thread(fp.stat)
+            except FileNotFoundError:
+                continue
+            is_dir = fp.is_dir()
+            entries.append({
+                "name": name,
+                "is_dir": is_dir,
+                "size": 0 if is_dir else st.st_size,
+                "mtime": int(st.st_mtime),
+                "mode": stat.S_IMODE(st.st_mode),
+                "type": "dir" if is_dir else "file",
+            })
+        
+        # 按目录优先排序
+        entries.sort(key=lambda x: (not x["is_dir"], x["name"].lower()))
+        return entries, total_count
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        fp = _safe_join(root, rel)
+        if not fp.exists() or not fp.is_file():
+            raise FileNotFoundError(rel)
+        return await asyncio.to_thread(fp.read_bytes)
+
+    async def write_file(self, root: str, rel: str, data: bytes):
+        fp = _safe_join(root, rel)
+        pre_exists = fp.exists() 
+        await asyncio.to_thread(os.makedirs, fp.parent, mode=DEFAULT_DIR_MODE, exist_ok=True)
+        await asyncio.to_thread(fp.write_bytes, data)
+        if not pre_exists:
+            await asyncio.to_thread(_apply_mode, fp, DEFAULT_FILE_MODE)
+        await LogService.info(
+            "adapter:local",
+            f"Wrote file to {rel}",
+            details={"adapter_id": self.record.id, "path": str(fp), "size": len(data)},
+        )
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        fp = _safe_join(root, rel)
+        pre_exists = fp.exists()
+        await asyncio.to_thread(os.makedirs, fp.parent, mode=DEFAULT_DIR_MODE, exist_ok=True)
+        # 流式写入，避免一次性读入内存
+        def _open():
+            return open(fp, "wb")
+        f = await asyncio.to_thread(_open)
+        size = 0
+        try:
+            async for chunk in data_iter:
+                if not chunk:
+                    continue
+                size += len(chunk)
+                await asyncio.to_thread(f.write, chunk)
+        finally:
+            await asyncio.to_thread(f.close)
+        if not pre_exists:
+            await asyncio.to_thread(_apply_mode, fp, DEFAULT_FILE_MODE)
+        await LogService.info(
+            "adapter:local",
+            f"Wrote file stream to {rel}",
+            details={"adapter_id": self.record.id, "path": str(fp), "size": size},
+        )
+        return size
+
+    async def mkdir(self, root: str, rel: str):
+        fp = _safe_join(root, rel)
+        await asyncio.to_thread(os.makedirs, fp, mode=DEFAULT_DIR_MODE, exist_ok=True)
+        await LogService.info(
+            "adapter:local",
+            f"Created directory {rel}",
+            details={"adapter_id": self.record.id, "path": str(fp)},
+        )
+
+    async def delete(self, root: str, rel: str):
+        fp = _safe_join(root, rel)
+        if not fp.exists():
+            return
+        if fp.is_dir():
+            await asyncio.to_thread(shutil.rmtree, fp)
+        else:
+            await asyncio.to_thread(fp.unlink)
+        await LogService.info(
+            "adapter:local",
+            f"Deleted {rel}",
+            details={"adapter_id": self.record.id, "path": str(fp)},
+        )
+
+    async def stat_path(self, root: str, rel: str):
+        """新增: 返回路径状态调试信息"""
+        fp = _safe_join(root, rel)
+        def _stat():
+            if not fp.exists():
+                return {"exists": False, "is_dir": None, "path": str(fp)}
+            return {
+                "exists": True,
+                "is_dir": fp.is_dir(),
+                "path": str(fp)
+            }
+        return await asyncio.to_thread(_stat)
+
+    async def exists(self, root: str, rel: str) -> bool:
+        """新增: 判断路径是否存在"""
+        fp = _safe_join(root, rel)
+        return await asyncio.to_thread(fp.exists)
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        src = _safe_join(root, src_rel)
+        dst = _safe_join(root, dst_rel)
+        if str(src) == str(dst):
+            return
+        if not src.exists():
+            raise FileNotFoundError(src_rel)
+        await asyncio.to_thread(dst.parent.mkdir, parents=True, exist_ok=True)
+
+        def _do_move():
+            try:
+                os.replace(src, dst) 
+            except OSError:
+                shutil.move(str(src), str(dst))
+        await asyncio.to_thread(_do_move)
+        await LogService.info(
+            "adapter:local",
+            f"Moved {src_rel} to {dst_rel}",
+            details={
+                "adapter_id": self.record.id,
+                "src": str(src),
+                "dst": str(dst),
+            },
+        )
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        src = _safe_join(root, src_rel)
+        dst = _safe_join(root, dst_rel)
+        if str(src) == str(dst):
+            return
+        if not src.exists():
+            raise FileNotFoundError(src_rel)
+        await asyncio.to_thread(dst.parent.mkdir, parents=True, exist_ok=True)
+        def _do_rename():
+            try:
+                os.rename(src, dst)
+            except OSError:
+                os.replace(src, dst)
+        await asyncio.to_thread(_do_rename)
+        await LogService.info(
+            "adapter:local",
+            f"Renamed {src_rel} to {dst_rel}",
+            details={
+                "adapter_id": self.record.id,
+                "src": str(src),
+                "dst": str(dst),
+            },
+        )
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        src = _safe_join(root, src_rel)
+        dst = _safe_join(root, dst_rel)
+        if not src.exists():
+            raise FileNotFoundError(src_rel)
+        if str(src) == str(dst):
+            return
+        await asyncio.to_thread(dst.parent.mkdir, parents=True, exist_ok=True)
+        def _do():
+            if dst.exists():
+                if not overwrite:
+                    raise FileExistsError(dst_rel)
+                if dst.is_dir():
+                    shutil.rmtree(dst)
+                else:
+                    dst.unlink()
+            if src.is_dir():
+                shutil.copytree(src, dst)
+            else:
+                shutil.copy2(src, dst)
+        await asyncio.to_thread(_do)
+        await LogService.info(
+            "adapter:local",
+            f"Copied {src_rel} to {dst_rel}",
+            details={
+                "adapter_id": self.record.id,
+                "src": str(src),
+                "dst": str(dst),
+            },
+        )
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        fp = _safe_join(root, rel)
+        if not fp.exists() or not fp.is_file():
+            raise HTTPException(404, detail="File not found")
+        mime, _ = mimetypes.guess_type(rel)
+        content_type = mime or "application/octet-stream"
+        file_size = (await asyncio.to_thread(fp.stat)).st_size
+        start = 0
+        end = file_size - 1
+        status = 200
+        headers = {
+            "Accept-Ranges": "bytes",
+            "Content-Type": content_type,
+        }
+        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, detail="Requested Range Not Satisfiable")
+                if end >= file_size:
+                    end = file_size - 1
+                status = 206
+            except ValueError:
+                raise HTTPException(400, detail="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 iterator():
+            # 使用线程池避免阻塞
+            def _read_segment(offset: int, length: int):
+                with open(fp, "rb") as f:
+                    f.seek(offset)
+                    return f.read(length)
+            chunk_size = 256 * 1024
+            remaining = end - start + 1
+            offset = start
+            while remaining > 0:
+                size = min(chunk_size, remaining)
+                data = await asyncio.to_thread(_read_segment, offset, size)
+                if not data:
+                    break
+                yield data
+                remaining -= len(data)
+                offset += len(data)
+
+        return StreamingResponse(iterator(), status_code=status, headers=headers, media_type=content_type)
+
+    async def stat_file(self, root: str, rel: str):
+        fp = _safe_join(root, rel)
+        if not fp.exists():
+            raise FileNotFoundError(rel)
+        st = await asyncio.to_thread(fp.stat)
+        info = {
+            "name": fp.name,
+            "is_dir": fp.is_dir(),
+            "size": st.st_size,
+            "mtime": int(st.st_mtime),
+            "mode": stat.S_IMODE(st.st_mode),
+            "type": "dir" if fp.is_dir() else "file",
+            "path": str(fp),
+        }
+        # exif信息
+        exif = None
+        if not fp.is_dir():
+            mime, _ = mimetypes.guess_type(fp.name)
+            if mime and mime.startswith("image/"):
+                try:
+                    from PIL import Image
+                    img = await asyncio.to_thread(Image.open, fp)
+                    exif_data = img._getexif()
+                    if exif_data:
+                        exif = {str(k): str(v) for k, v in exif_data.items()}
+                except Exception:
+                    exif = None
+        info["exif"] = exif
+        return info
+
+
+ADAPTER_TYPE = "local"
+CONFIG_SCHEMA = [
+    {"key": "root", "label": "根目录", "type": "string", "required": True, "placeholder": "/data/storage"},
+]
+ADAPTER_FACTORY = lambda rec: LocalAdapter(rec)

services/adapters/registry.py

@@ -0,0 +1,83 @@
+from typing import Dict, Callable
+import pkgutil
+import inspect
+from importlib import import_module
+
+from .base import BaseAdapter
+from models import StorageAdapter
+
+AdapterFactory = Callable[[StorageAdapter], object]
+
+TYPE_MAP: Dict[str, AdapterFactory] = {}
+CONFIG_SCHEMAS: Dict[str, list] = {}
+
+
+def discover_adapters():
+    """扫描 services.adapters 包, 自动注册适配器类型、工厂与配置 schema。"""
+    from .. import adapters as adapters_pkg
+    TYPE_MAP.clear()
+    CONFIG_SCHEMAS.clear()
+    for modinfo in pkgutil.iter_modules(adapters_pkg.__path__):
+        if modinfo.name.startswith("_"):
+            continue
+        full_name = f"{adapters_pkg.__name__}.{modinfo.name}"
+        try:
+            module = import_module(full_name)
+        except Exception:
+            continue
+        adapter_type = getattr(module, "ADAPTER_TYPE", None)
+        schema = getattr(module, "CONFIG_SCHEMA", None)
+        factory = getattr(module, "ADAPTER_FACTORY", None)
+
+        if not adapter_type:
+            continue
+
+        if factory is None:
+            for attr in module.__dict__.values():
+                if inspect.isclass(attr) and attr.__name__.endswith("Adapter"):
+                    def _mk(cls=attr):
+                        return lambda rec: cls(rec)
+                    factory = _mk()
+                    break
+        if not callable(factory):
+            continue
+
+        TYPE_MAP[adapter_type] = factory
+        if isinstance(schema, list):
+            CONFIG_SCHEMAS[adapter_type] = schema
+
+
+def get_config_schemas() -> Dict[str, list]:
+    return CONFIG_SCHEMAS
+
+
+def get_config_schema(adapter_type: str):
+    return CONFIG_SCHEMAS.get(adapter_type)
+
+
+class RuntimeRegistry:
+    def __init__(self):
+        self._instances: Dict[int, object] = {}
+
+    async def refresh(self):
+        discover_adapters()
+        self._instances.clear()
+        adapters = await StorageAdapter.filter(enabled=True)
+        for rec in adapters:
+            factory = TYPE_MAP.get(rec.type)
+            if not factory:
+                continue
+            try:
+                self._instances[rec.id] = factory(rec)
+            except Exception:
+                continue  
+
+    def get(self, adapter_id: int):
+        return self._instances.get(adapter_id)
+
+    def snapshot(self) -> Dict[int, BaseAdapter]:
+        return dict(self._instances)
+
+
+runtime_registry = RuntimeRegistry()
+discover_adapters()

services/adapters/webdav.py

@@ -0,0 +1,509 @@
+from __future__ import annotations
+from typing import List, Dict, Optional, Tuple, AsyncIterator
+import httpx
+from urllib.parse import urljoin, quote
+from urllib.parse import urlparse, unquote
+import xml.etree.ElementTree as ET
+from models import StorageAdapter
+import mimetypes
+import logging
+from fastapi import HTTPException
+from fastapi.responses import StreamingResponse, Response
+from services.logging import LogService
+
+NS = {"d": "DAV:"}
+
+
+class WebDAVAdapter:
+    def __init__(self, record: StorageAdapter):
+        self.record = record
+        cfg = record.config
+        self.base_url: str = cfg.get("base_url", "").rstrip('/') + '/'
+        if not self.base_url.startswith("http"):
+            raise ValueError("webdav requires base_url http/https")
+        self.username = cfg.get("username")
+        self.password = cfg.get("password")
+        self.timeout = cfg.get("timeout", 15)
+
+    def get_effective_root(self, sub_path: str | None) -> str:
+        base_url = self.record.config.get("base_url", "").rstrip('/') + '/'
+        if sub_path:
+            return base_url + sub_path.strip('/') + '/'
+        return base_url
+
+    def _client(self):
+        auth = (self.username, self.password) if self.username else None
+        return httpx.AsyncClient(auth=auth, timeout=self.timeout, follow_redirects=True)
+
+    def _build_url(self, rel: str):
+        rel = rel.strip('/')
+        return self.base_url if not rel else urljoin(self.base_url, quote(rel) + ('/' if rel.endswith('/') else ''))
+
+    async def list_dir(self, root: str, rel: str, page_num: int = 1, page_size: int = 50) -> Tuple[List[Dict], int]:
+        raw_url = self._build_url(rel)
+        url = raw_url if raw_url.endswith('/') else raw_url + '/'
+        depth = "1"
+        body = """<?xml version="1.0" encoding="utf-8" ?>
+<d:propfind xmlns:d="DAV:">
+  <d:prop>
+    <d:displayname />
+    <d:getcontentlength />
+    <d:getlastmodified />
+    <d:resourcetype />
+  </d:prop>
+</d:propfind>"""
+        async with self._client() as client:
+            resp = await client.request("PROPFIND", url, data=body, headers={"Depth": depth})
+            resp.raise_for_status()
+            xml_text = resp.text
+        root_el = ET.fromstring(xml_text)
+        all_entries: List[Dict] = []
+        parsed_req = urlparse(url)
+        base_path = parsed_req.path
+        if not base_path.endswith('/'):
+            base_path += '/'
+        seen = set()
+        for resp_el in root_el.findall("d:response", NS):
+            href_el = resp_el.find("d:href", NS)
+            if href_el is None:
+                continue
+            href = (href_el.text or "")
+            parsed_href = urlparse(href)
+            href_path = parsed_href.path or ""
+            if not href_path.startswith(base_path):
+                continue
+            rel_path = href_path[len(base_path):].strip('/')
+            if rel_path == "":
+                continue
+            name = unquote(rel_path.split('/')[0]).rstrip('/')
+            if not name or name in seen:
+                continue
+            seen.add(name)
+            propstat = resp_el.find("d:propstat", NS)
+            if propstat is None:
+                continue
+            prop = propstat.find("d:prop", NS)
+            if prop is None:
+                continue
+            size_el = prop.find("d:getcontentlength", NS)
+            lm_el = prop.find("d:getlastmodified", NS)
+            rt_el = prop.find("d:resourcetype", NS)
+            is_dir = rt_el.find(
+                "d:collection", NS) is not None if rt_el is not None else href_path.endswith('/')
+            size = int(
+                size_el.text) if size_el is not None and size_el.text and size_el.text.isdigit() else 0
+            all_entries.append({
+                "name": name,
+                "is_dir": is_dir,
+                "size": 0 if is_dir else size,
+                "mtime": 0,
+                "type": "dir" if is_dir else "file",
+            })
+
+        # 排序所有条目
+        all_entries.sort(key=lambda x: (not x["is_dir"], x["name"].lower()))
+        total_count = len(all_entries)
+
+        # 应用分页
+        start_idx = (page_num - 1) * page_size
+        end_idx = start_idx + page_size
+        page_entries = all_entries[start_idx:end_idx]
+
+        return page_entries, total_count
+
+    async def read_file(self, root: str, rel: str) -> bytes:
+        url = self._build_url(rel)
+        async with self._client() as client:
+            resp = await client.get(url)
+            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):
+        url = self._build_url(rel)
+        async with self._client() as client:
+            resp = await client.put(url, content=data)
+            resp.raise_for_status()
+        await LogService.info(
+            "adapter:webdav",
+            f"Wrote file to {rel}",
+            details={
+                "adapter_id": self.record.id,
+                "url": url,
+                "size": len(data),
+            },
+        )
+
+    async def mkdir(self, root: str, rel: str):
+        url = self._build_url(rel.rstrip('/') + '/')
+        async with self._client() as client:
+            resp = await client.request("MKCOL", url)
+            if resp.status_code not in (201, 405):
+                resp.raise_for_status()
+        await LogService.info(
+            "adapter:webdav",
+            f"Created directory {rel}",
+            details={"adapter_id": self.record.id, "url": url},
+        )
+
+    async def delete(self, root: str, rel: str):
+        url = self._build_url(rel)
+        async with self._client() as client:
+            resp = await client.delete(url)
+            if resp.status_code not in (204, 200, 404):
+                resp.raise_for_status()
+        await LogService.info(
+            "adapter:webdav",
+            f"Deleted {rel}",
+            details={"adapter_id": self.record.id, "url": url},
+        )
+
+    async def move(self, root: str, src_rel: str, dst_rel: str):
+        src_url = self._build_url(src_rel)
+        dst_url = self._build_url(dst_rel)
+        async with self._client() as client:
+            resp = await client.request("MOVE", src_url, headers={"Destination": dst_url})
+            resp.raise_for_status()
+        await LogService.info(
+            "adapter:webdav",
+            f"Moved {src_rel} to {dst_rel}",
+            details={
+                "adapter_id": self.record.id,
+                "src_url": src_url,
+                "dst_url": dst_url,
+            },
+        )
+
+    async def rename(self, root: str, src_rel: str, dst_rel: str):
+        src_url = self._build_url(src_rel)
+        dst_url = self._build_url(dst_rel)
+        async with self._client() as client:
+            resp = await client.request("MOVE", src_url, headers={"Destination": dst_url})
+            resp.raise_for_status()
+        await LogService.info(
+            "adapter:webdav",
+            f"Renamed {src_rel} to {dst_rel}",
+            details={
+                "adapter_id": self.record.id,
+                "src_url": src_url,
+                "dst_url": dst_url,
+            },
+        )
+
+    async def get_file_size(self, root: str, rel: str) -> int:
+        """获取文件大小"""
+        url = self._build_url(rel)
+        async with self._client() as client:
+            # 使用HEAD请求获取文件信息
+            resp = await client.head(url)
+            if resp.status_code == 404:
+                raise FileNotFoundError(rel)
+            resp.raise_for_status()
+
+            content_length = resp.headers.get('content-length')
+            if content_length:
+                return int(content_length)
+
+            # 如果HEAD不返回content-length，尝试PROPFIND
+            body = """<?xml version="1.0" encoding="utf-8" ?>
+<d:propfind xmlns:d="DAV:">
+  <d:prop>
+    <d:getcontentlength />
+  </d:prop>
+</d:propfind>"""
+            resp = await client.request("PROPFIND", url, data=body, headers={"Depth": "0"})
+            resp.raise_for_status()
+
+            root_el = ET.fromstring(resp.text)
+            for resp_el in root_el.findall("d:response", NS):
+                propstat = resp_el.find("d:propstat", NS)
+                if propstat is None:
+                    continue
+                prop = propstat.find("d:prop", NS)
+                if prop is None:
+                    continue
+                size_el = prop.find("d:getcontentlength", NS)
+                if size_el is not None and size_el.text and size_el.text.isdigit():
+                    return int(size_el.text)
+
+            return 0
+
+    async def read_file_range(self, root: str, rel: str, start: int, end: Optional[int] = None) -> bytes:
+        """读取文件的指定范围"""
+        url = self._build_url(rel)
+
+        # 构建Range头
+        if end is None:
+            range_header = f"bytes={start}-"
+        else:
+            range_header = f"bytes={start}-{end}"
+
+        async with self._client() as client:
+            resp = await client.get(url, headers={"Range": range_header})
+            if resp.status_code == 404:
+                raise FileNotFoundError(rel)
+            if resp.status_code not in (200, 206):  # 206是Partial Content
+                resp.raise_for_status()
+            return resp.content
+
+    async def stream_file(self, root: str, rel: str, range_header: str | None):
+        url = self._build_url(rel)
+        mime, _ = mimetypes.guess_type(rel)
+        content_type = mime or "application/octet-stream"
+        logger = logging.getLogger(__name__)
+        timeout = self.timeout
+        auth = (self.username, self.password) if self.username else None
+
+        client_start = 0
+        client_end = None
+        status_code = 200
+        if range_header and range_header.startswith("bytes="):
+            status_code = 206
+            part = range_header.removeprefix("bytes=")
+            s, e = part.split("-", 1)
+            if s.strip():
+                client_start = int(s)
+            if e.strip():
+                client_end = int(e)
+
+        total_size = None
+        accept_ranges = False
+        async with httpx.AsyncClient(timeout=timeout, auth=auth, follow_redirects=True) as client:
+            try:
+                head_resp = await client.head(url)
+                if head_resp.status_code == 404:
+                    raise HTTPException(404, detail="File not found")
+                if head_resp.status_code == 200:
+                    cl = head_resp.headers.get("Content-Length")
+                    if cl and cl.isdigit():
+                        total_size = int(cl)
+                    ar = head_resp.headers.get("Accept-Ranges", "").lower()
+                    accept_ranges = "bytes" in ar
+            except HTTPException:
+                raise
+            except Exception as e:
+                logger.debug("HEAD failed %s err=%s", url, e)
+            if total_size is None and (client_end is None):
+                try:
+                    probe_req = client.build_request("GET", url, headers={"Range": "bytes=0-0"})
+                    probe_resp = await client.send(probe_req, stream=True)
+                    if probe_resp.status_code in (200, 206):
+                        cr = probe_resp.headers.get("Content-Range")
+                        if cr and "/" in cr:
+                            try:
+                                total_size = int(cr.rsplit("/", 1)[1])
+                            except Exception:
+                                pass
+                    await probe_resp.aclose()
+                except Exception as e:
+                    logger.debug("Probe 0-0 failed %s err=%s", url, e)
+
+        if total_size is not None and client_end is None:
+            client_end = total_size - 1
+        if client_end is not None and client_end < client_start:
+            raise HTTPException(416, detail="Requested Range Not Satisfiable")
+
+        # 若客户端未请求范围且上游不支持 Range，直接透传
+        if status_code == 200 and (range_header is None) and not accept_ranges:
+            async with httpx.AsyncClient(timeout=timeout, auth=auth, follow_redirects=True) as client:
+                req = client.build_request("GET", url)
+                resp = await client.send(req, stream=True)
+                if resp.status_code == 404:
+                    await resp.aclose()
+                    raise HTTPException(404, detail="File not found")
+                upstream_ct = resp.headers.get("Content-Type", content_type)
+
+                async def passthrough():
+                    try:
+                        async for chunk in resp.aiter_bytes():
+                            if chunk:
+                                yield chunk
+                    finally:
+                        await resp.aclose()
+                return StreamingResponse(passthrough(), status_code=resp.status_code,
+                                         headers={"Accept-Ranges": "bytes",
+                                                  "X-VFS-Remote-Status": str(resp.status_code)},
+                                         media_type=upstream_ct)
+
+        SEGMENT_SIZE = 5 * 1024 * 1024
+        MAX_RETRY_PER_SEG = 3
+        FIRST_BYTE_MAX_RETRY = 3
+
+        resp_headers = {
+            "Accept-Ranges": "bytes",
+            "Content-Type": content_type,
+            "X-VFS-Segmented": "1",
+        }
+        if status_code == 206 and total_size is not None:
+            resp_headers["Content-Range"] = f"bytes {client_start}-{client_end}/{total_size}"
+
+        async def segmented_body():
+            current = client_start
+            first_byte_sent = False
+            while True:
+                if client_end is not None and current > client_end:
+                    break
+                seg_start = current
+                seg_end = (min(seg_start + SEGMENT_SIZE - 1, client_end)
+                           if client_end is not None else seg_start + SEGMENT_SIZE - 1)
+                attempt = 0
+                ok = False
+                while attempt < MAX_RETRY_PER_SEG and not ok:
+                    attempt += 1
+                    headers_req = {"Range": f"bytes={seg_start}-{seg_end}"}
+                    try:
+                        async with httpx.AsyncClient(timeout=timeout, auth=auth, follow_redirects=True) as cseg:
+                            req = cseg.build_request("GET", url, headers=headers_req)
+                            rseg = await cseg.send(req, stream=True)
+                            if rseg.status_code in (200, 206):
+                                async for chunk in rseg.aiter_bytes():
+                                    if chunk:
+                                        first_byte_sent = True
+                                        yield chunk
+                                await rseg.aclose()
+                                ok = True
+                            elif rseg.status_code == 404:
+                                await rseg.aclose()
+                                if not first_byte_sent:
+                                    raise HTTPException(404, detail="File not found")
+                                return
+                            else:
+                                await rseg.aclose()
+                                logger.warning("Segment unexpected status %s %s-%s %s", rel, seg_start, seg_end, rseg.status_code)
+                        if not ok:
+                            continue
+                    except (httpx.ReadError, httpx.HTTPError, httpx.StreamError) as e:
+                        if not first_byte_sent and attempt >= FIRST_BYTE_MAX_RETRY:
+                            raise HTTPException(502, detail=f"Upstream error before first byte err={e}")
+                        logger.warning("Segment error %s %s-%s attempt=%d err=%s", rel, seg_start, seg_end, attempt, e)
+                    except Exception as e:
+                        if not first_byte_sent:
+                            raise
+                        logger.error("Segment unexpected %s %s-%s attempt=%d err=%s", rel, seg_start, seg_end, attempt, e)
+                if not ok:
+                    logger.error("Abort streaming %s at %s-%s", rel, seg_start, seg_end)
+                    break
+                current = seg_end + 1
+                if client_end is None:
+                    continue
+                if current > client_end:
+                    break
+
+        return StreamingResponse(segmented_body(), status_code=status_code, headers=resp_headers, media_type=content_type)
+
+    async def stat_file(self, root: str, rel: str):
+        url = self._build_url(rel)
+        async with self._client() as client:
+            # PROPFIND 获取属性
+            body = """<?xml version="1.0" encoding="utf-8" ?>
+<d:propfind xmlns:d="DAV:">
+  <d:prop>
+    <d:getcontentlength />
+    <d:getlastmodified />
+    <d:resourcetype />
+  </d:prop>
+</d:propfind>"""
+            resp = await client.request("PROPFIND", url, data=body, headers={"Depth": "0"})
+            if resp.status_code == 404:
+                raise FileNotFoundError(rel)
+            resp.raise_for_status()
+            root_el = ET.fromstring(resp.text)
+            info = {
+                "name": rel.split("/")[-1],
+                "is_dir": False,
+                "size": None,
+                "mtime": None,
+                "type": "file",
+                "path": url,
+            }
+            for resp_el in root_el.findall("d:response", NS):
+                propstat = resp_el.find("d:propstat", NS)
+                if propstat is None:
+                    continue
+                prop = propstat.find("d:prop", NS)
+                if prop is None:
+                    continue
+                size_el = prop.find("d:getcontentlength", NS)
+                lm_el = prop.find("d:getlastmodified", NS)
+                rt_el = prop.find("d:resourcetype", NS)
+                is_dir = rt_el.find("d:collection", NS) is not None if rt_el is not None else False
+                info["is_dir"] = is_dir
+                info["type"] = "dir" if is_dir else "file"
+                if size_el is not None and size_el.text and size_el.text.isdigit():
+                    info["size"] = int(size_el.text)
+                if lm_el is not None and lm_el.text:
+                    info["mtime"] = lm_el.text
+            # exif信息
+            exif = None
+            if not info["is_dir"]:
+                mime, _ = mimetypes.guess_type(info["name"])
+                if mime and mime.startswith("image/"):
+                    try:
+                        resp_img = await client.get(url)
+                        if resp_img.status_code == 200:
+                            from PIL import Image
+                            from io import BytesIO
+                            img = Image.open(BytesIO(resp_img.content))
+                            exif_data = img._getexif()
+                            if exif_data:
+                                exif = {str(k): str(v) for k, v in exif_data.items()}
+                    except Exception:
+                        exif = None
+            info["exif"] = exif
+            return info
+
+    async def exists(self, root: str, rel: str) -> bool:
+        url = self._build_url(rel)
+        async with self._client() as client:
+            try:
+                r = await client.head(url)
+                return r.status_code in (200, 204)
+            except Exception:
+                return False
+
+    async def write_file_stream(self, root: str, rel: str, data_iter: AsyncIterator[bytes]):
+        url = self._build_url(rel)
+        async def agen():
+            async for chunk in data_iter:
+                if chunk:
+                    yield chunk
+        async with self._client() as client:
+            resp = await client.put(url, content=agen())
+            resp.raise_for_status()
+        return True
+
+    async def copy(self, root: str, src_rel: str, dst_rel: str, overwrite: bool = False):
+        src_url = self._build_url(src_rel)
+        dst_url = self._build_url(dst_rel)
+        headers = {
+            "Destination": dst_url,
+            "Overwrite": "T" if overwrite else "F"
+        }
+        async with self._client() as client:
+            resp = await client.request("COPY", src_url, headers=headers)
+            if resp.status_code == 412: 
+                raise FileExistsError(dst_rel)
+            if resp.status_code == 404:
+                raise FileNotFoundError(src_rel)
+            resp.raise_for_status()
+        await LogService.info(
+            "adapter:webdav",
+            f"Copied {src_rel} to {dst_rel}",
+            details={
+                "adapter_id": self.record.id,
+                "src_url": src_url,
+                "dst_url": dst_url,
+            },
+        )
+
+ADAPTER_TYPE = "webdav"
+CONFIG_SCHEMA = [
+    {"key": "base_url", "label": "基础地址", "type": "string",
+        "required": True, "placeholder": "https://example.com/dav/"},
+    {"key": "username", "label": "用户名", "type": "string", "required": False},
+    {"key": "password", "label": "密码", "type": "password", "required": False},
+    {"key": "timeout",
+        "label": "超时(秒)", "type": "number", "required": False, "default": 15},
+]
+def ADAPTER_FACTORY(rec): return WebDAVAdapter(rec)

services/ai.py

@@ -0,0 +1,64 @@
+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", "")
+    payload = {
+        "model": VISION_MODEL,
+        "messages": [
+            {"role": "user", "content": [
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{base64_image}",
+                        "detail": detail
+                    }
+                },
+                {
+                    "type": "text",
+                    "text": "描述这个图片"
+                }
+            ]}
+        ]
+    }
+    headers = {
+        "Authorization": f"Bearer {API_KEY}",
+        "Content-Type": "application/json"
+    }
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(OAI_API_URL, headers=headers, json=payload)
+            resp.raise_for_status()
+            result = resp.json()
+            return result["choices"][0]["message"]["content"]
+    except httpx.ReadTimeout:
+        return "请求超时，请稍后重试。"
+    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", "")
+    payload = {
+        "model": EMBED_MODEL,
+        "input": text
+    }
+    headers = {
+        "Authorization": f"Bearer {API_KEY}",
+        "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)
+        resp.raise_for_status()
+        result = resp.json()
+        return result["data"][0]["embedding"]

services/auth.py

@@ -0,0 +1,161 @@
+from datetime import datetime, timedelta, timezone
+from typing import Annotated
+
+import jwt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jwt.exceptions import InvalidTokenError
+from passlib.context import CryptContext
+from pydantic import BaseModel
+
+from models.database import UserAccount
+from services.config import ConfigCenter
+
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 365
+
+
+async def get_secret_key():
+    return await ConfigCenter.get_secret_key(
+        "SECRET_KEY", None
+    )
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+class TokenData(BaseModel):
+    username: str | None = None
+
+
+class User(BaseModel):
+    id:int
+    username: str
+    email: str | None = None
+    full_name: str | None = None
+    disabled: bool | None = None
+
+
+class UserInDB(User):
+    hashed_password: str
+
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="auth/login")
+
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+
+def get_user(db, username: str):
+    if username in db:
+        user_dict = db[username]
+        return UserInDB(**user_dict)
+
+
+async def get_user_db(username_or_email: str):
+    user = await UserAccount.get_or_none(username=username_or_email)
+    if not user:
+        user = await UserAccount.get_or_none(email=username_or_email)
+    if user:
+        return UserInDB(
+            id= user.id,
+            username=user.username,
+            email=user.email,
+            full_name=user.full_name,
+            disabled=user.disabled,
+            hashed_password=user.hashed_password,
+        )
+
+
+def authenticate_user(fake_db, username: str, password: str):
+    user = get_user(fake_db, username)
+    if not user:
+        return False
+    if not verify_password(password, user.hashed_password):
+        return False
+    return user
+
+
+async def authenticate_user_db(username_or_email: str, password: str):
+    user = await get_user_db(username_or_email)
+    if not user:
+        return False
+    if not verify_password(password, user.hashed_password):
+        return False
+    return user
+
+
+async def register_user(username: str, password: str, email: str = None, full_name: str = None):
+    if await has_users():
+        raise HTTPException(status_code=403, detail="系统已初始化，不允许注册新用户")
+    exists = await UserAccount.get_or_none(username=username)
+    if exists:
+        raise HTTPException(status_code=400, detail="用户名已存在")
+    hashed = get_password_hash(password)
+    user = await UserAccount.create(
+        username=username,
+        email=email,
+        full_name=full_name,
+        hashed_password=hashed,
+        disabled=False,
+    )
+    return user
+
+
+async def has_users() -> bool:
+    """
+    检查数据库中是否存在任何用户
+    """
+    user_count = await UserAccount.all().count()
+    return user_count > 0
+
+
+async def create_access_token(data: dict, expires_delta: timedelta | None = None):
+    to_encode = data.copy()
+    if "sub" not in to_encode and "username" in to_encode:
+        to_encode["sub"] = to_encode["username"]
+    if expires_delta:
+        expire = datetime.now(timezone.utc) + expires_delta
+    else:
+        expire = datetime.now(timezone.utc) + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    secret_key = await get_secret_key()
+    encoded_jwt = jwt.encode(to_encode, secret_key, algorithm=ALGORITHM)
+    return encoded_jwt
+
+
+async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        secret_key = await get_secret_key()
+        payload = jwt.decode(token, secret_key, algorithms=[ALGORITHM])
+        username = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except InvalidTokenError:
+        raise credentials_exception
+    user = await get_user_db(token_data.username)
+    if user is None:
+        raise credentials_exception
+    return user
+
+
+async def get_current_active_user(
+    current_user: Annotated[User, Depends(get_current_user)],
+):
+    if current_user.disabled:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user

services/backup.py

@@ -0,0 +1,86 @@
+import json
+from tortoise.transactions import in_transaction
+from models.database import (
+    StorageAdapter,
+    Mount,
+    UserAccount,
+    AutomationTask,
+    ShareLink,
+    Configuration,
+)
+
+class BackupService:
+    @staticmethod
+    async def export_data():
+        """
+        导出所有相关数据到JSON格式。
+        """
+        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()
+            configs = await Configuration.all().values()
+
+        for share in shares:
+            share["created_at"] = share["created_at"].isoformat() if share.get("created_at") else None
+            share["expires_at"] = share["expires_at"].isoformat() if share.get("expires_at") else None
+
+        return {
+            "storage_adapters": list(adapters),
+            "mounts": list(mounts),
+            "user_accounts": list(users),
+            "automation_tasks": list(tasks),
+            "share_links": list(shares),
+            "configurations": list(configs),
+        }
+
+    @staticmethod
+    async def import_data(data: dict):
+        """
+        从JSON数据导入到数据库。
+        """
+        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()
+
+            if data.get("configurations"):
+                await Configuration.bulk_create(
+                    [Configuration(**c) for c in data["configurations"]],
+                    using_db=conn
+                )
+            
+            if data.get("user_accounts"):
+                await UserAccount.bulk_create(
+                    [UserAccount(**u) for u in data["user_accounts"]],
+                    using_db=conn
+                )
+
+            if data.get("storage_adapters"):
+                await StorageAdapter.bulk_create(
+                    [StorageAdapter(**a) for a in data["storage_adapters"]],
+                    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"]],
+                    using_db=conn
+                )
+
+            if data.get("share_links"):
+                await ShareLink.bulk_create(
+                    [ShareLink(**s) for s in data["share_links"]],
+                    using_db=conn
+                )

services/config.py

@@ -0,0 +1,61 @@
+import os
+from typing import Any, Optional, Dict
+
+from dotenv import load_dotenv
+from models.database import Configuration
+load_dotenv(dotenv_path=".env")
+
+
+class ConfigCenter:
+    _cache: Dict[str, Any] = {}
+    @classmethod
+    async def get(cls, key: str, default: Optional[Any] = None) -> Any:
+        if key in cls._cache:
+            return cls._cache[key]
+        try:
+            config = await Configuration.get_or_none(key=key)
+            if config:
+                cls._cache[key] = config.value
+                return config.value
+        except Exception:
+            pass
+        env_value = os.getenv(key)
+        if env_value is not None:
+            cls._cache[key] = env_value
+            return env_value
+        return default
+
+    @classmethod
+    async def get_secret_key(cls, key: str, default: Optional[Any] = None) -> bytes:
+        """获取密钥，确保返回的是bytes"""
+        value = await cls.get(key, default)
+        if isinstance(value, bytes):
+            return value
+        if isinstance(value, str):
+            return value.encode('utf-8')
+        if value is None:
+            raise ValueError(f"Secret key '{key}' not found in config or environment.")
+        return str(value).encode('utf-8')
+
+    @classmethod
+    async def set(cls, key: str, value: Any):
+        obj, _ = await Configuration.get_or_create(key=key, defaults={"value": value})
+        obj.value = value
+        await obj.save()
+        cls._cache[key] = value
+
+    @classmethod
+    async def get_all(cls) -> Dict[str, Any]:
+        try:
+            configs = await Configuration.all()
+            result = {}
+            for config in configs:
+                result[config.key] = config.value
+                cls._cache[config.key] = config.value
+            return result
+        except Exception:
+            return {}
+
+    @classmethod
+    def clear_cache(cls):
+        cls._cache.clear()

services/logging.py

@@ -0,0 +1,44 @@
+from typing import Optional, Dict, Any
+from models.database import Log
+
+class LogService:
+    @staticmethod
+    async def _log(level: str, source: str, message: str, details: Optional[Dict[str, Any]] = None, user_id: Optional[int] = None):
+        """通用日志记录方法"""
+        await Log.create(
+            level=level,
+            source=source,
+            message=message,
+            details=details,
+            user_id=user_id
+        )
+
+    @staticmethod
+    async def info(source: str, message: str, details: Optional[Dict[str, Any]] = None, user_id: Optional[int] = None):
+        """记录普通信息日志"""
+        await LogService._log("INFO", source, message, details, user_id)
+
+    @staticmethod
+    async def warning(source: str, message: str, details: Optional[Dict[str, Any]] = None, user_id: Optional[int] = None):
+        """记录警告日志"""
+        await LogService._log("WARNING", source, message, details, user_id)
+
+    @staticmethod
+    async def error(source: str, message: str, details: Optional[Dict[str, Any]] = None, user_id: Optional[int] = None):
+        """记录错误日志"""
+        await LogService._log("ERROR", source, message, details, user_id)
+
+    @staticmethod
+    async def api(message: str, details: Optional[Dict[str, Any]] = None, user_id: Optional[int] = None):
+        """专门记录API请求日志"""
+        await LogService._log("API", "api_middleware", message, details, user_id)
+
+    @staticmethod
+    async def action(
+        source: str,
+        message: str,
+        details: Optional[Dict[str, Any]] = None,
+        user_id: Optional[int] = None,
+    ):
+        """记录用户操作日志"""
+        await LogService._log("ACTION", source, message, details, user_id)

services/processors/base.py

@@ -0,0 +1,17 @@
+from typing import Protocol, Dict, Any
+
+
+class BaseProcessor(Protocol):
+    name: str
+    supported_exts: list
+    config_schema: list
+    produces_file: bool
+
+    async def process(self, input_bytes: bytes, path: str, config: Dict[str, Any]) -> bytes:
+        """处理文件内容并返回处理后的内容"""
+        ...
+
+# 约定：每个处理器需定义
+# PROCESSOR_TYPE: str
+# CONFIG_SCHEMA: list
+# PROCESSOR_FACTORY: Callable[[], BaseProcessor]

services/processors/image_watermark.py

@@ -0,0 +1,67 @@
+from .base import BaseProcessor
+from typing import Dict, Any
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+from fastapi.responses import Response
+from services.logging import LogService
+
+class ImageWatermarkProcessor:
+    name = "图片水印"
+    supported_exts = ["jpg", "jpeg", "png", "bmp"]
+    config_schema = [
+        {"key": "text", "label": "水印文字", "type": "string", "required": True},
+        {
+            "key": "position",
+            "label": "位置",
+            "type": "select",
+            "required": False,
+            "default": "bottom-right",
+            "options": [
+                {"value": "top-left", "label": "左上"},
+                {"value": "center", "label": "居中"},
+                {"value": "bottom-right", "label": "右下"},
+            ],
+        },
+        {"key": "font_size", "label": "字体大小", "type": "number", "required": False, "default": 24},
+    ]
+    produces_file = True
+
+    async def process(self, input_bytes: bytes,path: str, config: Dict[str, Any]) -> Response:
+        text = config.get("text", "")
+        position = config.get("position", "bottom-right")
+        font_size = int(config.get("font_size", 24))
+        img = Image.open(BytesIO(input_bytes)).convert("RGBA")
+        watermark = Image.new("RGBA", img.size)
+        draw = ImageDraw.Draw(watermark)
+        try:
+            font = ImageFont.truetype("arial.ttf", font_size)
+        except Exception:
+            font = ImageFont.load_default()
+        w, h = img.size
+        try:
+            text_w, text_h = font.getsize(text)
+        except AttributeError:
+            bbox = draw.textbbox((0, 0), text, font=font)
+            text_w, text_h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        if position == "bottom-right":
+            xy = (w - text_w - 10, h - text_h - 10)
+        elif position == "top-left":
+            xy = (10, 10)
+        else:
+            xy = (w // 2 - text_w // 2, h // 2 - text_h // 2)
+        draw.text(xy, text, font=font, fill=(255, 255, 255, 128))
+        out = Image.alpha_composite(img, watermark)
+        buf = BytesIO()
+        out.convert("RGB").save(buf, format="JPEG")
+        await LogService.info(
+            "processor:image_watermark",
+            f"Watermarked image {path}",
+            details={"path": path, "config": config},
+        )
+        return Response(content=buf.getvalue(), media_type="image/jpeg")
+
+PROCESSOR_TYPE = "image_watermark"
+PROCESSOR_NAME = ImageWatermarkProcessor.name
+SUPPORTED_EXTS = ImageWatermarkProcessor.supported_exts
+CONFIG_SCHEMA = ImageWatermarkProcessor.config_schema
+PROCESSOR_FACTORY = lambda: ImageWatermarkProcessor()

services/processors/registry.py

@@ -0,0 +1,65 @@
+import pkgutil
+import inspect
+from importlib import import_module
+from typing import Dict, Callable
+from .base import BaseProcessor
+
+ProcessorFactory = Callable[[], BaseProcessor]
+TYPE_MAP: Dict[str, ProcessorFactory] = {}
+CONFIG_SCHEMAS: Dict[str, dict] = {}
+
+def discover_processors():
+    import services.processors
+    processors_pkg = services.processors
+    TYPE_MAP.clear()
+    CONFIG_SCHEMAS.clear()
+    for modinfo in pkgutil.iter_modules(processors_pkg.__path__):
+        if modinfo.name.startswith("_"):
+            continue
+        full_name = f"{processors_pkg.__name__}.{modinfo.name}"
+        try:
+            module = import_module(full_name)
+        except Exception:
+            continue
+        processor_type = getattr(module, "PROCESSOR_TYPE", None)
+        processor_name = getattr(module, "PROCESSOR_NAME", None)
+        supported_exts = getattr(module, "SUPPORTED_EXTS", None)
+        schema = getattr(module, "CONFIG_SCHEMA", None)
+        factory = getattr(module, "PROCESSOR_FACTORY", None)
+        if not processor_type:
+            continue
+        if factory is None:
+            for attr in module.__dict__.values():
+                if inspect.isclass(attr) and attr.__name__.endswith("Processor"):
+                    def _mk(cls=attr):
+                        return lambda: cls()
+                    factory = _mk()
+                    break
+        if not callable(factory):
+            continue
+        TYPE_MAP[processor_type] = factory
+        produces_file = getattr(module, "produces_file", None)
+        if produces_file is None and hasattr(factory(), "produces_file"):
+            produces_file = getattr(factory(), "produces_file")
+        if isinstance(schema, list):
+            CONFIG_SCHEMAS[processor_type] = {
+                "type": processor_type,
+                "name": processor_name or processor_type,
+                "supported_exts": supported_exts or [],
+                "config_schema": schema,
+                "produces_file": produces_file if produces_file is not None else False
+            }
+
+def get_config_schemas() -> Dict[str, dict]:
+    return CONFIG_SCHEMAS
+
+def get_config_schema(processor_type: str):
+    return CONFIG_SCHEMAS.get(processor_type)
+
+def get(processor_type: str) -> BaseProcessor:
+    factory = TYPE_MAP.get(processor_type)
+    if factory:
+        return factory()
+    return None
+
+discover_processors()

services/processors/vector_index.py

@@ -0,0 +1,90 @@
+from typing import Dict, Any
+from fastapi.responses import Response
+import base64
+from services.ai import describe_image_base64, get_text_embedding
+from services.vector_db import VectorDBService
+from services.logging import LogService
+
+
+class VectorIndexProcessor:
+    name = "向量索引"
+    supported_exts = ["jpg", "jpeg", "png", "bmp", "txt", "md"]
+    config_schema = [
+        {
+            "key": "action", "label": "操作", "type": "select", "required": True, "default": "create",
+            "options": [
+                {"value": "create", "label": "创建索引"},
+                {"value": "destroy", "label": "销毁索引"},
+            ]
+        },
+        {
+            "key": "index_type", "label": "索引类型", "type": "select", "required": True, "default": "vector",
+            "options": [
+                {"value": "vector", "label": "向量索引"},
+                {"value": "simple", "label": "普通索引"},
+            ]
+        }
+    ]
+    produces_file = False
+
+    async def process(self, input_bytes: bytes, path: str, config: Dict[str, Any]) -> Response:
+        action = config.get("action", "create")
+        index_type = config.get("index_type", "vector")
+        vector_db = VectorDBService()
+        collection_name = "vector_collection"
+        if action == "destroy":
+            vector_db.delete_vector(collection_name, path)
+            await LogService.info(
+                "processor:vector_index",
+                f"Destroyed {index_type} index for {path}",
+                details={"path": path, "action": "destroy", "index_type": index_type},
+            )
+            return Response(content=f"文件 {path} 的 {index_type} 索引已销毁", media_type="text/plain")
+
+        if index_type == 'simple':
+            vector_db.ensure_collection(collection_name, vector=False)
+            vector_db.upsert_vector(collection_name, {'path': path})
+            await LogService.info(
+                "processor:vector_index",
+                f"Created simple index for {path}",
+                details={"path": path, "action": "create", "index_type": "simple"},
+            )
+            return Response(content=f"文件 {path} 的普通索引已创建", media_type="text/plain")
+
+        file_ext = path.split('.')[-1].lower()
+        description = ""
+        embedding = None
+
+        if file_ext in ["jpg", "jpeg", "png", "bmp"]:
+            base64_image = base64.b64encode(input_bytes).decode("utf-8")
+            description = await describe_image_base64(base64_image)
+            embedding = await get_text_embedding(description)
+            log_message = f"Indexed image {path}"
+            response_message = f"图片已索引，描述：{description}"
+        elif file_ext in ["txt", "md"]:
+            text = input_bytes.decode("utf-8")
+            embedding = await get_text_embedding(text)
+            description = text[:100] + "..." if len(text) > 100 else text
+            log_message = f"Indexed text file {path}"
+            response_message = f"文本文件已索引"
+        
+        if embedding is None:
+            return Response(content="不支持的文件类型", status_code=400)
+
+        vector_db.ensure_collection(collection_name, vector=True)
+        vector_db.upsert_vector(
+            collection_name, {'path': path, 'embedding': embedding})
+        
+        await LogService.info(
+            "processor:vector_index",
+            log_message,
+            details={"path": path, "description": description, "action": "create", "index_type": "vector"},
+        )
+        return Response(content=response_message, media_type="text/plain")
+
+
+PROCESSOR_TYPE = "vector_index"
+PROCESSOR_NAME = VectorIndexProcessor.name
+SUPPORTED_EXTS = VectorIndexProcessor.supported_exts
+CONFIG_SCHEMA = VectorIndexProcessor.config_schema
+def PROCESSOR_FACTORY(): return VectorIndexProcessor()

services/share.py

@@ -0,0 +1,125 @@
+import secrets
+import bcrypt
+from datetime import datetime, timedelta, timezone
+from typing import List, Optional
+
+from fastapi import HTTPException, status
+from tortoise.expressions import Q
+
+from models.database import ShareLink, UserAccount
+from services.virtual_fs import resolve_adapter_and_rel, list_virtual_dir, stat_file
+
+
+class ShareService:
+    @staticmethod
+    def _hash_password(password: str) -> str:
+        return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+    @staticmethod
+    def _verify_password(plain_password: str, hashed_password: str) -> bool:
+        return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
+
+    @staticmethod
+    async def create_share_link(
+        user: UserAccount,
+        name: str,
+        paths: List[str],
+        expires_in_days: Optional[int] = 7,
+        access_type: str = "public",
+        password: Optional[str] = None,
+    ) -> ShareLink:
+        """
+        为指定路径创建一个新的分享链接。
+        """
+        if not paths:
+            raise HTTPException(status_code=400, detail="分享路径不能为空")
+
+        if access_type == "password" and not password:
+            raise HTTPException(status_code=400, detail="密码不能为空")
+
+        token = secrets.token_urlsafe(16)
+        
+        # expires_in_days <= 0 or None means permanent
+        expires_at = None
+        if expires_in_days and expires_in_days > 0:
+            expires_at = datetime.now(timezone.utc) + timedelta(days=expires_in_days)
+
+        hashed_password = None
+        if access_type == "password" and password:
+            hashed_password = ShareService._hash_password(password)
+
+        share = await ShareLink.create(
+            token=token,
+            name=name,
+            paths=paths,
+            user=user,
+            expires_at=expires_at,
+            access_type=access_type,
+            hashed_password=hashed_password,
+        )
+        return share
+
+    @staticmethod
+    async def get_share_by_token(token: str) -> ShareLink:
+        """
+        通过token获取分享链接，并检查其有效性。
+        """
+        share = await ShareLink.get_or_none(token=token).prefetch_related("user")
+        if not share:
+            raise HTTPException(status_code=404, detail="分享链接不存在")
+
+        if share.expires_at and share.expires_at < datetime.now(timezone.utc):
+            raise HTTPException(status_code=410, detail="分享链接已过期")
+
+        return share
+
+    @staticmethod
+    async def get_user_shares(user: UserAccount) -> List[ShareLink]:
+        """
+        获取一个用户创建的所有分享链接。
+        """
+        return await ShareLink.filter(user=user).order_by("-created_at")
+
+    @staticmethod
+    async def delete_share_link(user: UserAccount, share_id: int):
+        """
+        删除一个分享链接。
+        """
+        share = await ShareLink.get_or_none(id=share_id, user_id=user.id)
+        if not share:
+            raise HTTPException(status_code=404, detail="分享链接不存在")
+        await share.delete()
+
+    @staticmethod
+    async def get_shared_item_details(share: ShareLink, sub_path: str = ""):
+        """
+        获取分享链接中特定路径下的文件/目录详情。
+        """
+        if not share.paths:
+            raise HTTPException(status_code=404, detail="分享内容为空")
+
+        base_shared_path = share.paths[0]
+
+        if sub_path and sub_path != '/':
+            full_path = f"{base_shared_path.rstrip('/')}/{sub_path.lstrip('/')}".rstrip('/')
+            if not full_path.startswith(base_shared_path):
+                raise HTTPException(status_code=403, detail="无权访问此路径")
+            try:
+                return await list_virtual_dir(full_path)
+            except FileNotFoundError:
+                raise HTTPException(status_code=404, detail="目录未找到")
+
+        try:
+            stat = await stat_file(base_shared_path)
+            if stat.get("is_dir"):
+                return await list_virtual_dir(base_shared_path)
+            
+            stat['name'] = base_shared_path.split('/')[-1]
+            return {"items": [stat], "total": 1, "page": 1, "page_size": 1, "pages": 1}
+        except HTTPException as e:
+            if "Path is a directory" in str(e.detail) or "Not a file" in str(e.detail):
+                return await list_virtual_dir(base_shared_path)
+            raise e
+
+
+share_service = ShareService()

services/tasks.py

@@ -0,0 +1,48 @@
+import re
+from typing import List
+from models.database import AutomationTask
+from services.processors.registry import get as get_processor
+from services.logging import LogService
+
+class TaskService:
+    async def trigger_tasks(self, event: str, path: str):
+        tasks = await AutomationTask.filter(event=event, enabled=True)
+        for task in tasks:
+            if self.match(task, path):
+                await self.execute(task, path)
+
+    def match(self, task: AutomationTask, path: str) -> bool:
+        if task.path_pattern and not path.startswith(task.path_pattern):
+            return False
+        if task.filename_regex:
+            filename = path.split('/')[-1]
+            if not re.match(task.filename_regex, filename):
+                return False
+        return True
+
+    async def execute(self, task: AutomationTask, path: str):
+        from services.virtual_fs import read_file, write_file
+
+        processor = get_processor(task.processor_type)
+        if not processor:
+            print(f"Processor {task.processor_type} not found for task {task.id}")
+            return
+
+        try:
+            file_content = await read_file(path)
+            result = await processor.process(file_content, path, task.processor_config)
+            
+            save_to = task.processor_config.get("save_to")
+            if save_to and getattr(processor, "produces_file", False):
+                await write_file(save_to, result)
+
+        except Exception as e:
+            error_message = f"Error executing task {task.id} for path {path}: {e}"
+            print(error_message)
+            await LogService.error(
+                source=f"task_executor:{task.id}",
+                message=error_message,
+                details={"task_name": task.name, "event": task.event, "path": path, "processor": task.processor_type}
+            )
+
+task_service = TaskService()

services/thumbnail.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+import io
+import hashlib
+from pathlib import Path
+from typing import Tuple
+from fastapi import HTTPException
+
+ALLOWED_EXT = {"jpg", "jpeg", "png", "webp", "gif", "bmp", "tiff"}
+MAX_SOURCE_SIZE = 200 * 1024 * 1024
+CACHE_ROOT = Path('data/.thumb_cache')
+
+
+def is_image_filename(name: str) -> bool:
+    parts = name.rsplit('.', 1)
+    if len(parts) < 2:
+        return False
+    return parts[1].lower() in ALLOWED_EXT
+
+
+def _cache_key(adapter_id: int, rel: str, size: int, mtime: int, w: int, h: int, fit: str) -> str:
+    raw = f"{adapter_id}|{rel}|{size}|{mtime}|{w}x{h}|{fit}".encode()
+    return hashlib.sha1(raw).hexdigest()
+
+
+def _cache_path(key: str) -> Path:
+    sub = Path(key[:2]) / key[2:4]
+    return CACHE_ROOT / sub / f"{key}.webp"
+
+
+def _ensure_cache_dir(p: Path):
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+
+def generate_thumb(data: bytes, w: int, h: int, fit: str) -> Tuple[bytes, str]:
+    from PIL import Image
+    im = Image.open(io.BytesIO(data))
+    if im.mode not in ("RGB", "RGBA"):
+        im = im.convert("RGBA" if im.mode in ("P", "LA") else "RGB")
+    if fit == 'cover':
+        im_ratio = im.width / im.height
+        target_ratio = w / h
+        if im_ratio > target_ratio:
+            new_h = h
+            new_w = int(h * im_ratio)
+        else:
+            new_w = w
+            new_h = int(w / im_ratio)
+        im = im.resize((new_w, new_h))
+        left = max(0, (im.width - w)//2)
+        top = max(0, (im.height - h)//2)
+        im = im.crop((left, top, left + w, top + h))
+    else:
+        im.thumbnail((w, h))
+    buf = io.BytesIO()
+    im.save(buf, 'WEBP', quality=80)
+    return buf.getvalue(), 'image/webp'
+
+
+async def get_or_create_thumb(adapter, adapter_id: int, root: str, rel: str, w: int, h: int, fit: str = 'cover'):
+    read_data = await adapter.read_file(root, rel)
+    if len(read_data) > MAX_SOURCE_SIZE:
+        raise HTTPException(404, detail="Image too large for thumbnail")
+    key = _cache_key(adapter_id, rel, len(read_data), 0, w, h, fit)
+    path = _cache_path(key)
+    if path.exists():
+        return path.read_bytes(), 'image/webp', key
+    _ensure_cache_dir(path)
+    try:
+        thumb_bytes, mime = generate_thumb(read_data, w, h, fit)
+    except Exception as e:
+        raise HTTPException(500, detail=f"Thumbnail generation failed: {e}")
+    path.write_bytes(thumb_bytes)
+    return thumb_bytes, mime, key

services/vector_db.py

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

services/virtual_fs.py

@@ -0,0 +1,484 @@
+from pathlib import Path
+from typing import Dict, Tuple, Any, Union, AsyncIterator
+from fastapi import HTTPException
+import mimetypes
+from fastapi.responses import Response
+import time
+import hmac
+import hashlib
+import base64
+
+from models import Mount
+from .adapters.registry import runtime_registry
+from api.response import page
+from .thumbnail import is_image_filename
+from services.processors.registry import get as get_processor
+from services.tasks import task_service
+from services.logging import LogService
+from services.config import ConfigCenter
+
+
+async def resolve_mount(path: str) -> Tuple[Mount, str]:
+    norm = path if path.startswith('/') else '/' + path
+    mounts = await Mount.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
+    if not best:
+        raise HTTPException(404, detail="No mount for path")
+    rel = norm[len(best.path):].lstrip('/')
+    return best, rel
+
+
+
+
+async def resolve_adapter_and_rel(path: str):
+    """返回 (adapter_instance, mount, effective_root, rel_path)."""
+    norm = path if path.startswith('/') else '/' + path
+    try:
+        mount, rel = await resolve_mount(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
+
+
+async def _ensure_method(adapter: Any, method: str):
+    func = getattr(adapter, method, None)
+    if not callable(func):
+        raise HTTPException(501, detail=f"Adapter does not implement {method}")
+    return func
+
+
+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")
+
+    child_mount_entries = []
+    norm_prefix = norm.rstrip('/')
+    for m in mounts:
+        if m.path == norm:
+            continue
+        if m.path.startswith(norm_prefix + '/'):
+            tail = m.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)
+    except HTTPException:
+        mount = None
+        adapter = None
+        effective_root = ''
+        rel = ''
+
+    adapter_entries = []
+    adapter_total = 0
+    covered = set()
+
+    if mount and adapter:
+        list_dir = await _ensure_method(adapter, "list_dir")
+        try:
+            adapter_entries, adapter_total = await list_dir(effective_root, rel, page_num, page_size)
+        except NotADirectoryError:
+            raise HTTPException(400, detail="Not a directory")
+
+        for item in adapter_entries:
+            covered.add(item["name"])
+
+    mount_entries = []
+    for name in child_mount_entries:
+        if name not in covered:
+            mount_entries.append({"name": name, "is_dir": True,
+                                  "size": 0, "mtime": 0, "type": "mount", "is_image": False})
+
+    for ent in adapter_entries:
+        if not ent.get('is_dir'):
+            ent['is_image'] = is_image_filename(ent['name'])
+        else:
+            ent['is_image'] = False
+    all_entries = adapter_entries + mount_entries
+    all_entries.sort(key=lambda x: (not x.get("is_dir"), x["name"].lower()))
+    total_entries = adapter_total + len(mount_entries)
+    if mount_entries:
+        start_idx = (page_num - 1) * page_size
+        end_idx = start_idx + page_size
+        page_entries = all_entries[start_idx:end_idx]
+
+        return page(page_entries, total_entries, page_num, page_size)
+    else:
+        return page(adapter_entries, adapter_total, page_num, page_size)
+
+
+async def read_file(path: str) -> Union[bytes, Any]:
+    adapter, _mount, 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")
+    return await read_func(root, rel)
+
+
+async def write_file(path: str, data: bytes):
+    adapter, _mount, 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")
+    await write_func(root, rel, data)
+    await task_service.trigger_tasks("file_written", path)
+    await LogService.action(
+        "virtual_fs", f"Wrote file to {path}", details={"path": path, "size": len(data)}
+    )
+
+
+async def write_file_stream(path: str, data_iter: AsyncIterator[bytes], overwrite: bool = True):
+    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
+    if rel.endswith('/'):
+        raise HTTPException(400, detail="Invalid file path")
+    exists_func = getattr(adapter, "exists", None)
+    if not overwrite and callable(exists_func):
+        try:
+            if await exists_func(root, rel):
+                raise HTTPException(409, detail="Destination exists")
+        except HTTPException:
+            raise
+        except Exception:
+            pass
+
+    size = 0
+    stream_func = getattr(adapter, "write_file_stream", None)
+    if callable(stream_func):
+        size = await stream_func(root, rel, data_iter)
+    else:
+        buf = bytearray()
+        async for chunk in data_iter:
+            if chunk:
+                buf.extend(chunk)
+        write_func = await _ensure_method(adapter, "write_file")
+        await write_func(root, rel, bytes(buf))
+        size = len(buf)
+
+    await task_service.trigger_tasks("file_written", path)
+    await LogService.action(
+        "virtual_fs",
+        f"Wrote file stream to {path}",
+        details={"path": path, "size": size},
+    )
+    return size
+
+
+async def make_dir(path: str):
+    adapter, _mount, 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")
+    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)
+    if not rel:
+        raise HTTPException(400, detail="Cannot delete root")
+    delete_func = await _ensure_method(adapter, "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)
+    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 not rel_s:
+        raise HTTPException(400, detail="Cannot move or rename mount root")
+    if not rel_d:
+        raise HTTPException(400, detail="Invalid destination")
+
+    exists_func = getattr(adapter_s, "exists", None)
+    stat_func = getattr(adapter_s, "stat_path", None)
+    delete_func = await _ensure_method(adapter_s, "delete")
+    move_func = await _ensure_method(adapter_s, "move")
+
+    dst_exists = False
+    dst_stat = None
+    if callable(exists_func):
+        dst_exists = await exists_func(root_d, rel_d)
+    if callable(stat_func):
+        dst_stat = await stat_func(root_d, rel_d)
+    debug_info["dst_exists"] = dst_exists
+    debug_info["dst_stat"] = dst_stat
+
+    if dst_exists and not overwrite:
+        kind = None
+        fs_path = None
+        if dst_stat:
+            kind = "dir" if dst_stat.get("is_dir") else "file"
+            fs_path = dst_stat.get("path")
+        raise HTTPException(
+            409,
+            detail=f"Destination already exists(kind={kind}, fs_path={fs_path}, rel_d={rel_d}, overwrite={overwrite})"
+        )
+    if dst_exists and overwrite:
+        try:
+            await delete_func(root_s, rel_d)
+            debug_info["pre_delete"] = "ok"
+        except Exception as e:
+            debug_info["pre_delete"] = f"error:{e}"
+            raise HTTPException(
+                500, detail=f"Pre-delete failed before overwrite: {e}")
+
+    if rel_s == rel_d:
+        debug_info["noop"] = True
+        return debug_info if return_debug else None
+
+    try:
+        await move_func(root_s, rel_s, rel_d)
+        debug_info["moved"] = True
+    except FileNotFoundError:
+        raise HTTPException(404, detail="Source not found")
+    except FileExistsError:
+        raise HTTPException(
+            409, detail="Destination already exists (race condition after pre-check)")
+    except IsADirectoryError:
+        raise HTTPException(400, detail="Invalid directory operation")
+    except Exception as e:
+        raise HTTPException(500, detail=f"Move failed: {e}")
+
+    await LogService.action(
+        "virtual_fs", f"Moved {src} to {dst}", details=debug_info
+    )
+    return debug_info if return_debug else None
+
+
+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)
+    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 not rel_s:
+        raise HTTPException(400, detail="Cannot rename mount root")
+    if not rel_d:
+        raise HTTPException(400, detail="Invalid destination")
+
+    exists_func = getattr(adapter_s, "exists", None)
+    stat_func = getattr(adapter_s, "stat_path", None)
+    delete_func = await _ensure_method(adapter_s, "delete")
+    rename_func = await _ensure_method(adapter_s, "rename")
+
+    dst_exists = False
+    dst_stat = None
+    if callable(exists_func):
+        dst_exists = await exists_func(root_d, rel_d)
+    if callable(stat_func):
+        dst_stat = await stat_func(root_d, rel_d)
+    debug_info["dst_exists"] = dst_exists
+    debug_info["dst_stat"] = dst_stat
+
+    if dst_exists and not overwrite:
+        kind = None
+        fs_path = None
+        if dst_stat:
+            kind = "dir" if dst_stat.get("is_dir") else "file"
+            fs_path = dst_stat.get("path")
+        raise HTTPException(
+            409,
+            detail=f"Destination already exists(kind={kind}, fs_path={fs_path}, rel_d={rel_d}, overwrite={overwrite})"
+        )
+    if dst_exists and overwrite:
+        try:
+            await delete_func(root_s, rel_d)
+            debug_info["pre_delete"] = "ok"
+        except Exception as e:
+            debug_info["pre_delete"] = f"error:{e}"
+            raise HTTPException(
+                500, detail=f"Pre-delete failed before overwrite: {e}")
+
+    if rel_s == rel_d:
+        debug_info["noop"] = True
+        return debug_info if return_debug else None
+
+    try:
+        await rename_func(root_s, rel_s, rel_d)
+        debug_info["renamed"] = True
+    except FileNotFoundError:
+        raise HTTPException(404, detail="Source not found")
+    except FileExistsError:
+        raise HTTPException(
+            409, detail="Destination already exists (race condition after pre-check)")
+    except IsADirectoryError:
+        raise HTTPException(400, detail="Invalid directory operation")
+    except Exception as e:
+        raise HTTPException(500, detail=f"Rename failed: {e}")
+
+    await LogService.action(
+        "virtual_fs", f"Renamed {src} to {dst}", details=debug_info
+    )
+    return debug_info if return_debug else None
+
+
+async def stream_file(path: str, range_header: str | None):
+    adapter, mount, root, rel = await resolve_adapter_and_rel(path)
+    if not rel or rel.endswith('/'):
+        raise HTTPException(400, detail="Path is a directory")
+    stream_impl = getattr(adapter, "stream_file", None)
+    if callable(stream_impl):
+        return await stream_impl(root, rel, range_header)
+    data = await read_file(path)
+    mime, _ = mimetypes.guess_type(rel)
+    return Response(content=data, media_type=mime or "application/octet-stream")
+
+
+async def stat_file(path: str):
+    adapter, _mount, root, rel = await resolve_adapter_and_rel(path)
+    stat_func = getattr(adapter, "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)
+    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 not rel_s:
+        raise HTTPException(400, detail="Cannot copy mount root")
+    if not rel_d:
+        raise HTTPException(400, detail="Invalid destination")
+
+    exists_func = getattr(adapter_s, "exists", None)
+    stat_func = getattr(adapter_s, "stat_path", None)
+    delete_func = getattr(adapter_s, "delete", None)
+    copy_func = await _ensure_method(adapter_s, "copy")
+
+    dst_exists = False
+    dst_stat = None
+    if callable(exists_func):
+        dst_exists = await exists_func(root_d, rel_d)
+    if callable(stat_func):
+        dst_stat = await stat_func(root_d, rel_d)
+    debug_info["dst_exists"] = dst_exists
+    debug_info["dst_stat"] = dst_stat
+
+    if dst_exists and not overwrite:
+        raise HTTPException(409, detail="Destination already exists")
+    if dst_exists and overwrite and callable(delete_func):
+        try:
+            await delete_func(root_s, rel_d)
+            debug_info["pre_delete"] = "ok"
+        except Exception as e:
+            debug_info["pre_delete"] = f"error:{e}"
+            raise HTTPException(500, detail=f"Pre-delete failed: {e}")
+
+    if rel_s == rel_d:
+        debug_info["noop"] = True
+        return debug_info if return_debug else None
+
+    try:
+        await copy_func(root_s, rel_s, rel_d, overwrite=overwrite)
+        debug_info["copied"] = True
+    except FileNotFoundError:
+        raise HTTPException(404, detail="Source not found")
+    except FileExistsError:
+        raise HTTPException(
+            409, detail="Destination already exists (race condition)")
+    except Exception as e:
+        raise HTTPException(500, detail=f"Copy failed: {e}")
+
+    await LogService.action(
+        "virtual_fs", f"Copied {src} to {dst}", details=debug_info
+    )
+    return debug_info if return_debug else None
+
+
+async def process_file(path: str, processor_type: str, config: dict, save_to: str = None):
+    """
+    使用指定处理器处理文件，并可选择保存到新路径
+    :param path: 源文件路径
+    :param processor_type: 处理器类型
+    :param config: 处理器配置
+    :param save_to: 保存路径（可选），不指定则只返回处理结果
+    :return: 处理后的文件内容或保存结果
+    """
+    data = await read_file(path)
+    processor = get_processor(processor_type)
+    if not processor:
+        raise HTTPException(
+            400, detail=f"Processor {processor_type} not found")
+    result = await processor.process(data, path, config)
+    if save_to and getattr(processor, "produces_file", False):
+        if isinstance(result, Response):
+            result_bytes = result.body
+        else:
+            result_bytes = result
+        await write_file(save_to, result_bytes)
+        return {"saved_to": save_to}
+    return result
+
+
+async def get_temp_link_secret_key() -> bytes:
+    """Get the secret key for temporary links."""
+    return await ConfigCenter.get_secret_key(
+        "TEMP_LINK_SECRET_KEY", None
+    )
+
+
+async def generate_temp_link_token(path: str, expires_in: int = 3600) -> str:
+    """为文件路径生成一个有时效的令牌"""
+    expiration_time = int(time.time() + expires_in)
+    message = f"{path}:{expiration_time}".encode('utf-8')
+    secret_key = await get_temp_link_secret_key()
+    signature = hmac.new(secret_key, message, hashlib.sha256).digest()
+
+    token_data = f"{path}:{expiration_time}:{base64.urlsafe_b64encode(signature).decode('utf-8')}"
+    return base64.urlsafe_b64encode(token_data.encode('utf-8')).decode('utf-8')
+
+
+async def verify_temp_link_token(token: str) -> str:
+    """验证令牌并返回文件路径，如果无效或过期则抛出异常"""
+    try:
+        decoded_token = base64.urlsafe_b64decode(token).decode('utf-8')
+        path, expiration_time_str, signature_b64 = decoded_token.rsplit(':', 2)
+        expiration_time = int(expiration_time_str)
+        signature = base64.urlsafe_b64decode(signature_b64)
+    except (ValueError, TypeError, base64.binascii.Error):
+        raise HTTPException(status_code=400, detail="Invalid token format")
+
+    if time.time() > expiration_time:
+        raise HTTPException(status_code=410, detail="Link has expired")
+
+    message = f"{path}:{expiration_time}".encode('utf-8')
+    secret_key = await get_temp_link_secret_key()
+    expected_signature = hmac.new(secret_key, message, hashlib.sha256).digest()
+
+    if not hmac.compare_digest(signature, expected_signature):
+        raise HTTPException(status_code=400, detail="Invalid signature")
+
+    return path

web/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

web/README.md

@@ -0,0 +1,69 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default tseslint.config([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      ...tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      ...tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      ...tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default tseslint.config([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```

web/bun.lock

@@ -0,0 +1,934 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "web",
+      "dependencies": {
+        "@ant-design/icons": "5.x",
+        "@ant-design/v5-patch-for-react-19": "^1.0.3",
+        "@uiw/react-md-editor": "^4.0.8",
+        "antd": "^5.27.0",
+        "date-fns": "^4.1.0",
+        "react": "^19.1.1",
+        "react-dom": "^19.1.1",
+        "react-router": "^7.8.0",
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.33.0",
+        "@types/react": "^19.1.10",
+        "@types/react-dom": "^19.1.7",
+        "@vitejs/plugin-react": "^5.0.0",
+        "eslint": "^9.33.0",
+        "eslint-plugin-react-hooks": "^5.2.0",
+        "eslint-plugin-react-refresh": "^0.4.20",
+        "globals": "^16.3.0",
+        "typescript": "~5.8.3",
+        "typescript-eslint": "^8.39.1",
+        "vite": "^7.1.2",
+      },
+    },
+  },
+  "packages": {
+    "@ampproject/remapping": ["@ampproject/remapping@2.3.0", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw=="],
+
+    "@ant-design/colors": ["@ant-design/colors@7.2.1", "", { "dependencies": { "@ant-design/fast-color": "^2.0.6" } }, "sha512-lCHDcEzieu4GA3n8ELeZ5VQ8pKQAWcGGLRTQ50aQM2iqPpq2evTxER84jfdPvsPAtEcZ7m44NI45edFMo8oOYQ=="],
+
+    "@ant-design/cssinjs": ["@ant-design/cssinjs@1.24.0", "", { "dependencies": { "@babel/runtime": "^7.11.1", "@emotion/hash": "^0.8.0", "@emotion/unitless": "^0.7.5", "classnames": "^2.3.1", "csstype": "^3.1.3", "rc-util": "^5.35.0", "stylis": "^4.3.4" }, "peerDependencies": { "react": ">=16.0.0", "react-dom": ">=16.0.0" } }, "sha512-K4cYrJBsgvL+IoozUXYjbT6LHHNt+19a9zkvpBPxLjFHas1UpPM2A5MlhROb0BT8N8WoavM5VsP9MeSeNK/3mg=="],
+
+    "@ant-design/cssinjs-utils": ["@ant-design/cssinjs-utils@1.1.3", "", { "dependencies": { "@ant-design/cssinjs": "^1.21.0", "@babel/runtime": "^7.23.2", "rc-util": "^5.38.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-nOoQMLW1l+xR1Co8NFVYiP8pZp3VjIIzqV6D6ShYF2ljtdwWJn5WSsH+7kvCktXL/yhEtWURKOfH5Xz/gzlwsg=="],
+
+    "@ant-design/fast-color": ["@ant-design/fast-color@2.0.6", "", { "dependencies": { "@babel/runtime": "^7.24.7" } }, "sha512-y2217gk4NqL35giHl72o6Zzqji9O7vHh9YmhUVkPtAOpoTCH4uWxo/pr4VE8t0+ChEPs0qo4eJRC5Q1eXWo3vA=="],
+
+    "@ant-design/icons": ["@ant-design/icons@5.6.1", "", { "dependencies": { "@ant-design/colors": "^7.0.0", "@ant-design/icons-svg": "^4.4.0", "@babel/runtime": "^7.24.8", "classnames": "^2.2.6", "rc-util": "^5.31.1" }, "peerDependencies": { "react": ">=16.0.0", "react-dom": ">=16.0.0" } }, "sha512-0/xS39c91WjPAZOWsvi1//zjx6kAp4kxWwctR6kuU6p133w8RU0D2dSCvZC19uQyharg/sAvYxGYWl01BbZZfg=="],
+
+    "@ant-design/icons-svg": ["@ant-design/icons-svg@4.4.2", "", {}, "sha512-vHbT+zJEVzllwP+CM+ul7reTEfBR0vgxFe7+lREAsAA7YGsYpboiq2sQNeQeRvh09GfQgs/GyFEvZpJ9cLXpXA=="],
+
+    "@ant-design/react-slick": ["@ant-design/react-slick@1.1.2", "", { "dependencies": { "@babel/runtime": "^7.10.4", "classnames": "^2.2.5", "json2mq": "^0.2.0", "resize-observer-polyfill": "^1.5.1", "throttle-debounce": "^5.0.0" }, "peerDependencies": { "react": ">=16.9.0" } }, "sha512-EzlvzE6xQUBrZuuhSAFTdsr4P2bBBHGZwKFemEfq8gIGyIQCxalYfZW/T2ORbtQx5rU69o+WycP3exY/7T1hGA=="],
+
+    "@ant-design/v5-patch-for-react-19": ["@ant-design/v5-patch-for-react-19@1.0.3", "", { "peerDependencies": { "antd": ">=5.22.6", "react": ">=19.0.0", "react-dom": ">=19.0.0" } }, "sha512-iWfZuSUl5kuhqLUw7jJXUQFMMkM7XpW7apmKzQBQHU0cpifYW4A79xIBt9YVO5IBajKpPG5UKP87Ft7Yrw1p/w=="],
+
+    "@babel/code-frame": ["@babel/code-frame@7.27.1", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.27.1", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg=="],
+
+    "@babel/compat-data": ["@babel/compat-data@7.28.0", "", {}, "sha512-60X7qkglvrap8mn1lh2ebxXdZYtUcpd7gsmy9kLaBJ4i/WdY8PqTSdxyA8qraikqKQK5C1KRBKXqznrVapyNaw=="],
+
+    "@babel/core": ["@babel/core@7.28.3", "", { "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.3", "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-module-transforms": "^7.28.3", "@babel/helpers": "^7.28.3", "@babel/parser": "^7.28.3", "@babel/template": "^7.27.2", "@babel/traverse": "^7.28.3", "@babel/types": "^7.28.2", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-yDBHV9kQNcr2/sUr9jghVyz9C3Y5G2zUM2H2lo+9mKv4sFgbA8s8Z9t8D1jiTkGoO/NoIfKMyKWr4s6CN23ZwQ=="],
+
+    "@babel/generator": ["@babel/generator@7.28.3", "", { "dependencies": { "@babel/parser": "^7.28.3", "@babel/types": "^7.28.2", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" } }, "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw=="],
+
+    "@babel/helper-compilation-targets": ["@babel/helper-compilation-targets@7.27.2", "", { "dependencies": { "@babel/compat-data": "^7.27.2", "@babel/helper-validator-option": "^7.27.1", "browserslist": "^4.24.0", "lru-cache": "^5.1.1", "semver": "^6.3.1" } }, "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ=="],
+
+    "@babel/helper-globals": ["@babel/helper-globals@7.28.0", "", {}, "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw=="],
+
+    "@babel/helper-module-imports": ["@babel/helper-module-imports@7.27.1", "", { "dependencies": { "@babel/traverse": "^7.27.1", "@babel/types": "^7.27.1" } }, "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w=="],
+
+    "@babel/helper-module-transforms": ["@babel/helper-module-transforms@7.28.3", "", { "dependencies": { "@babel/helper-module-imports": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1", "@babel/traverse": "^7.28.3" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw=="],
+
+    "@babel/helper-plugin-utils": ["@babel/helper-plugin-utils@7.27.1", "", {}, "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw=="],
+
+    "@babel/helper-string-parser": ["@babel/helper-string-parser@7.27.1", "", {}, "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="],
+
+    "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
+
+    "@babel/helper-validator-option": ["@babel/helper-validator-option@7.27.1", "", {}, "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg=="],
+
+    "@babel/helpers": ["@babel/helpers@7.28.3", "", { "dependencies": { "@babel/template": "^7.27.2", "@babel/types": "^7.28.2" } }, "sha512-PTNtvUQihsAsDHMOP5pfobP8C6CM4JWXmP8DrEIt46c3r2bf87Ua1zoqevsMo9g+tWDwgWrFP5EIxuBx5RudAw=="],
+
+    "@babel/parser": ["@babel/parser@7.28.3", "", { "dependencies": { "@babel/types": "^7.28.2" }, "bin": "./bin/babel-parser.js" }, "sha512-7+Ey1mAgYqFAx2h0RuoxcQT5+MlG3GTV0TQrgr7/ZliKsm/MNDxVVutlWaziMq7wJNAz8MTqz55XLpWvva6StA=="],
+
+    "@babel/plugin-transform-react-jsx-self": ["@babel/plugin-transform-react-jsx-self@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw=="],
+
+    "@babel/plugin-transform-react-jsx-source": ["@babel/plugin-transform-react-jsx-source@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw=="],
+
+    "@babel/runtime": ["@babel/runtime@7.28.3", "", {}, "sha512-9uIQ10o0WGdpP6GDhXcdOJPJuDgFtIDtN/9+ArJQ2NAfAmiuhTQdzkaTGR33v43GYS2UrSA0eX2pPPHoFVvpxA=="],
+
+    "@babel/template": ["@babel/template@7.27.2", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/parser": "^7.27.2", "@babel/types": "^7.27.1" } }, "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw=="],
+
+    "@babel/traverse": ["@babel/traverse@7.28.3", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.28.3", "@babel/helper-globals": "^7.28.0", "@babel/parser": "^7.28.3", "@babel/template": "^7.27.2", "@babel/types": "^7.28.2", "debug": "^4.3.1" } }, "sha512-7w4kZYHneL3A6NP2nxzHvT3HCZ7puDZZjFMqDpBPECub79sTtSO5CGXDkKrTQq8ksAwfD/XI2MRFX23njdDaIQ=="],
+
+    "@babel/types": ["@babel/types@7.28.2", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ=="],
+
+    "@emotion/hash": ["@emotion/hash@0.8.0", "", {}, "sha512-kBJtf7PH6aWwZ6fka3zQ0p6SBYzx4fl1LoZXE2RrnYST9Xljm7WfKJrU4g/Xr3Beg72MLrp1AWNUmuYJTL7Cow=="],
+
+    "@emotion/unitless": ["@emotion/unitless@0.7.5", "", {}, "sha512-OWORNpfjMsSSUBVrRBVGECkhWcULOAJz9ZW8uK9qgxD+87M7jHRcvh/A96XXNhXTLmKcoYSQtBEX7lHMO7YRwg=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.9", "", { "os": "aix", "cpu": "ppc64" }, "sha512-OaGtL73Jck6pBKjNIe24BnFE6agGl+6KxDtTfHhy1HmhthfKouEcOhqpSL64K4/0WCtbKFLOdzD/44cJ4k9opA=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.9", "", { "os": "android", "cpu": "arm" }, "sha512-5WNI1DaMtxQ7t7B6xa572XMXpHAaI/9Hnhk8lcxF4zVN4xstUgTlvuGDorBguKEnZO70qwEcLpfifMLoxiPqHQ=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.9", "", { "os": "android", "cpu": "arm64" }, "sha512-IDrddSmpSv51ftWslJMvl3Q2ZT98fUSL2/rlUXuVqRXHCs5EUF1/f+jbjF5+NG9UffUDMCiTyh8iec7u8RlTLg=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.9", "", { "os": "android", "cpu": "x64" }, "sha512-I853iMZ1hWZdNllhVZKm34f4wErd4lMyeV7BLzEExGEIZYsOzqDWDf+y082izYUE8gtJnYHdeDpN/6tUdwvfiw=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.9", "", { "os": "darwin", "cpu": "arm64" }, "sha512-XIpIDMAjOELi/9PB30vEbVMs3GV1v2zkkPnuyRRURbhqjyzIINwj+nbQATh4H9GxUgH1kFsEyQMxwiLFKUS6Rg=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.9", "", { "os": "darwin", "cpu": "x64" }, "sha512-jhHfBzjYTA1IQu8VyrjCX4ApJDnH+ez+IYVEoJHeqJm9VhG9Dh2BYaJritkYK3vMaXrf7Ogr/0MQ8/MeIefsPQ=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.9", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-z93DmbnY6fX9+KdD4Ue/H6sYs+bhFQJNCPZsi4XWJoYblUqT06MQUdBCpcSfuiN72AbqeBFu5LVQTjfXDE2A6Q=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.9", "", { "os": "freebsd", "cpu": "x64" }, "sha512-mrKX6H/vOyo5v71YfXWJxLVxgy1kyt1MQaD8wZJgJfG4gq4DpQGpgTB74e5yBeQdyMTbgxp0YtNj7NuHN0PoZg=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.9", "", { "os": "linux", "cpu": "arm" }, "sha512-HBU2Xv78SMgaydBmdor38lg8YDnFKSARg1Q6AT0/y2ezUAKiZvc211RDFHlEZRFNRVhcMamiToo7bDx3VEOYQw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.9", "", { "os": "linux", "cpu": "arm64" }, "sha512-BlB7bIcLT3G26urh5Dmse7fiLmLXnRlopw4s8DalgZ8ef79Jj4aUcYbk90g8iCa2467HX8SAIidbL7gsqXHdRw=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.9", "", { "os": "linux", "cpu": "ia32" }, "sha512-e7S3MOJPZGp2QW6AK6+Ly81rC7oOSerQ+P8L0ta4FhVi+/j/v2yZzx5CqqDaWjtPFfYz21Vi1S0auHrap3Ma3A=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.9", "", { "os": "linux", "cpu": "none" }, "sha512-Sbe10Bnn0oUAB2AalYztvGcK+o6YFFA/9829PhOCUS9vkJElXGdphz0A3DbMdP8gmKkqPmPcMJmJOrI3VYB1JQ=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.9", "", { "os": "linux", "cpu": "none" }, "sha512-YcM5br0mVyZw2jcQeLIkhWtKPeVfAerES5PvOzaDxVtIyZ2NUBZKNLjC5z3/fUlDgT6w89VsxP2qzNipOaaDyA=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.9", "", { "os": "linux", "cpu": "ppc64" }, "sha512-++0HQvasdo20JytyDpFvQtNrEsAgNG2CY1CLMwGXfFTKGBGQT3bOeLSYE2l1fYdvML5KUuwn9Z8L1EWe2tzs1w=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.9", "", { "os": "linux", "cpu": "none" }, "sha512-uNIBa279Y3fkjV+2cUjx36xkx7eSjb8IvnL01eXUKXez/CBHNRw5ekCGMPM0BcmqBxBcdgUWuUXmVWwm4CH9kg=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.9", "", { "os": "linux", "cpu": "s390x" }, "sha512-Mfiphvp3MjC/lctb+7D287Xw1DGzqJPb/J2aHHcHxflUo+8tmN/6d4k6I2yFR7BVo5/g7x2Monq4+Yew0EHRIA=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.9", "", { "os": "linux", "cpu": "x64" }, "sha512-iSwByxzRe48YVkmpbgoxVzn76BXjlYFXC7NvLYq+b+kDjyyk30J0JY47DIn8z1MO3K0oSl9fZoRmZPQI4Hklzg=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.9", "", { "os": "none", "cpu": "arm64" }, "sha512-9jNJl6FqaUG+COdQMjSCGW4QiMHH88xWbvZ+kRVblZsWrkXlABuGdFJ1E9L7HK+T0Yqd4akKNa/lO0+jDxQD4Q=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.9", "", { "os": "none", "cpu": "x64" }, "sha512-RLLdkflmqRG8KanPGOU7Rpg829ZHu8nFy5Pqdi9U01VYtG9Y0zOG6Vr2z4/S+/3zIyOxiK6cCeYNWOFR9QP87g=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.9", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-YaFBlPGeDasft5IIM+CQAhJAqS3St3nJzDEgsgFixcfZeyGPCd6eJBWzke5piZuZ7CtL656eOSYKk4Ls2C0FRQ=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.9", "", { "os": "openbsd", "cpu": "x64" }, "sha512-1MkgTCuvMGWuqVtAvkpkXFmtL8XhWy+j4jaSO2wxfJtilVCi0ZE37b8uOdMItIHz4I6z1bWWtEX4CJwcKYLcuA=="],
+
+    "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.9", "", { "os": "none", "cpu": "arm64" }, "sha512-4Xd0xNiMVXKh6Fa7HEJQbrpP3m3DDn43jKxMjxLLRjWnRsfxjORYJlXPO4JNcXtOyfajXorRKY9NkOpTHptErg=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.9", "", { "os": "sunos", "cpu": "x64" }, "sha512-WjH4s6hzo00nNezhp3wFIAfmGZ8U7KtrJNlFMRKxiI9mxEK1scOMAaa9i4crUtu+tBr+0IN6JCuAcSBJZfnphw=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.9", "", { "os": "win32", "cpu": "arm64" }, "sha512-mGFrVJHmZiRqmP8xFOc6b84/7xa5y5YvR1x8djzXpJBSv/UsNK6aqec+6JDjConTgvvQefdGhFDAs2DLAds6gQ=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.9", "", { "os": "win32", "cpu": "ia32" }, "sha512-b33gLVU2k11nVx1OhX3C8QQP6UHQK4ZtN56oFWvVXvz2VkDoe6fbG8TOgHFxEvqeqohmRnIHe5A1+HADk4OQww=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.9", "", { "os": "win32", "cpu": "x64" }, "sha512-PPOl1mi6lpLNQxnGoyAfschAodRFYXJ+9fs6WHXz7CSWKbOqiMZsubC+BQsVKuul+3vKLuwTHsS2c2y9EoKwxQ=="],
+
+    "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.7.0", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw=="],
+
+    "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.1", "", {}, "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ=="],
+
+    "@eslint/config-array": ["@eslint/config-array@0.21.0", "", { "dependencies": { "@eslint/object-schema": "^2.1.6", "debug": "^4.3.1", "minimatch": "^3.1.2" } }, "sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ=="],
+
+    "@eslint/config-helpers": ["@eslint/config-helpers@0.3.1", "", {}, "sha512-xR93k9WhrDYpXHORXpxVL5oHj3Era7wo6k/Wd8/IsQNnZUTzkGS29lyn3nAT05v6ltUuTFVCCYDEGfy2Or/sPA=="],
+
+    "@eslint/core": ["@eslint/core@0.15.2", "", { "dependencies": { "@types/json-schema": "^7.0.15" } }, "sha512-78Md3/Rrxh83gCxoUc0EiciuOHsIITzLy53m3d9UyiW8y9Dj2D29FeETqyKA+BRK76tnTp6RXWb3pCay8Oyomg=="],
+
+    "@eslint/eslintrc": ["@eslint/eslintrc@3.3.1", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^10.0.1", "globals": "^14.0.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ=="],
+
+    "@eslint/js": ["@eslint/js@9.33.0", "", {}, "sha512-5K1/mKhWaMfreBGJTwval43JJmkip0RmM+3+IuqupeSKNC/Th2Kc7ucaq5ovTSra/OOKB9c58CGSz3QMVbWt0A=="],
+
+    "@eslint/object-schema": ["@eslint/object-schema@2.1.6", "", {}, "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA=="],
+
+    "@eslint/plugin-kit": ["@eslint/plugin-kit@0.3.5", "", { "dependencies": { "@eslint/core": "^0.15.2", "levn": "^0.4.1" } }, "sha512-Z5kJ+wU3oA7MMIqVR9tyZRtjYPr4OC004Q4Rw7pgOKUOKkJfZ3O24nz3WYfGRpMDNmcOi3TwQOmgm7B7Tpii0w=="],
+
+    "@humanfs/core": ["@humanfs/core@0.19.1", "", {}, "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA=="],
+
+    "@humanfs/node": ["@humanfs/node@0.16.6", "", { "dependencies": { "@humanfs/core": "^0.19.1", "@humanwhocodes/retry": "^0.3.0" } }, "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw=="],
+
+    "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="],
+
+    "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.30", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-GQ7Nw5G2lTu/BtHTKfXhKHok2WGetd4XYcVKGx00SjAk8GMwgJM3zr6zORiPGuOE+/vkc90KtTosSSvaCjKb2Q=="],
+
+    "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
+
+    "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
+
+    "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
+
+    "@rc-component/async-validator": ["@rc-component/async-validator@5.0.4", "", { "dependencies": { "@babel/runtime": "^7.24.4" } }, "sha512-qgGdcVIF604M9EqjNF0hbUTz42bz/RDtxWdWuU5EQe3hi7M8ob54B6B35rOsvX5eSvIHIzT9iH1R3n+hk3CGfg=="],
+
+    "@rc-component/color-picker": ["@rc-component/color-picker@2.0.1", "", { "dependencies": { "@ant-design/fast-color": "^2.0.6", "@babel/runtime": "^7.23.6", "classnames": "^2.2.6", "rc-util": "^5.38.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-WcZYwAThV/b2GISQ8F+7650r5ZZJ043E57aVBFkQ+kSY4C6wdofXgB0hBx+GPGpIU0Z81eETNoDUJMr7oy/P8Q=="],
+
+    "@rc-component/context": ["@rc-component/context@1.4.0", "", { "dependencies": { "@babel/runtime": "^7.10.1", "rc-util": "^5.27.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-kFcNxg9oLRMoL3qki0OMxK+7g5mypjgaaJp/pkOis/6rVxma9nJBF/8kCIuTYHUQNr0ii7MxqE33wirPZLJQ2w=="],
+
+    "@rc-component/mini-decimal": ["@rc-component/mini-decimal@1.1.0", "", { "dependencies": { "@babel/runtime": "^7.18.0" } }, "sha512-jS4E7T9Li2GuYwI6PyiVXmxTiM6b07rlD9Ge8uGZSCz3WlzcG5ZK7g5bbuKNeZ9pgUuPK/5guV781ujdVpm4HQ=="],
+
+    "@rc-component/mutate-observer": ["@rc-component/mutate-observer@1.1.0", "", { "dependencies": { "@babel/runtime": "^7.18.0", "classnames": "^2.3.2", "rc-util": "^5.24.4" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-QjrOsDXQusNwGZPf4/qRQasg7UFEj06XiCJ8iuiq/Io7CrHrgVi6Uuetw60WAMG1799v+aM8kyc+1L/GBbHSlw=="],
+
+    "@rc-component/portal": ["@rc-component/portal@1.1.2", "", { "dependencies": { "@babel/runtime": "^7.18.0", "classnames": "^2.3.2", "rc-util": "^5.24.4" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-6f813C0IsasTZms08kfA8kPAGxbbkYToa8ALaiDIGGECU4i9hj8Plgbx0sNJDrey3EtHO30hmdaxtT0138xZcg=="],
+
+    "@rc-component/qrcode": ["@rc-component/qrcode@1.0.0", "", { "dependencies": { "@babel/runtime": "^7.24.7", "classnames": "^2.3.2", "rc-util": "^5.38.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-L+rZ4HXP2sJ1gHMGHjsg9jlYBX/SLN2D6OxP9Zn3qgtpMWtO2vUfxVFwiogHpAIqs54FnALxraUy/BCO1yRIgg=="],
+
+    "@rc-component/tour": ["@rc-component/tour@1.15.1", "", { "dependencies": { "@babel/runtime": "^7.18.0", "@rc-component/portal": "^1.0.0-9", "@rc-component/trigger": "^2.0.0", "classnames": "^2.3.2", "rc-util": "^5.24.4" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-Tr2t7J1DKZUpfJuDZWHxyxWpfmj8EZrqSgyMZ+BCdvKZ6r1UDsfU46M/iWAAFBy961Ssfom2kv5f3UcjIL2CmQ=="],
+
+    "@rc-component/trigger": ["@rc-component/trigger@2.3.0", "", { "dependencies": { "@babel/runtime": "^7.23.2", "@rc-component/portal": "^1.1.0", "classnames": "^2.3.2", "rc-motion": "^2.0.0", "rc-resize-observer": "^1.3.1", "rc-util": "^5.44.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-iwaxZyzOuK0D7lS+0AQEtW52zUWxoGqTGkke3dRyb8pYiShmRpCjB/8TzPI4R6YySCH7Vm9BZj/31VPiiQTLBg=="],
+
+    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.30", "", {}, "sha512-whXaSoNUFiyDAjkUF8OBpOm77Szdbk5lGNqFe6CbVbJFrhCCPinCbRA3NjawwlNHla1No7xvXXh+CpSxnPfUEw=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.46.2", "", { "os": "android", "cpu": "arm" }, "sha512-Zj3Hl6sN34xJtMv7Anwb5Gu01yujyE/cLBDB2gnHTAHaWS1Z38L7kuSG+oAh0giZMqG060f/YBStXtMH6FvPMA=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.46.2", "", { "os": "android", "cpu": "arm64" }, "sha512-nTeCWY83kN64oQ5MGz3CgtPx8NSOhC5lWtsjTs+8JAJNLcP3QbLCtDDgUKQc/Ro/frpMq4SHUaHN6AMltcEoLQ=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.46.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-HV7bW2Fb/F5KPdM/9bApunQh68YVDU8sO8BvcW9OngQVN3HHHkw99wFupuUJfGR9pYLLAjcAOA6iO+evsbBaPQ=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.46.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-SSj8TlYV5nJixSsm/y3QXfhspSiLYP11zpfwp6G/YDXctf3Xkdnk4woJIF5VQe0of2OjzTt8EsxnJDCdHd2xMA=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.46.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-ZyrsG4TIT9xnOlLsSSi9w/X29tCbK1yegE49RYm3tu3wF1L/B6LVMqnEWyDB26d9Ecx9zrmXCiPmIabVuLmNSg=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.46.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-pCgHFoOECwVCJ5GFq8+gR8SBKnMO+xe5UEqbemxBpCKYQddRQMgomv1104RnLSg7nNvgKy05sLsY51+OVRyiVw=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.46.2", "", { "os": "linux", "cpu": "arm" }, "sha512-EtP8aquZ0xQg0ETFcxUbU71MZlHaw9MChwrQzatiE8U/bvi5uv/oChExXC4mWhjiqK7azGJBqU0tt5H123SzVA=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.46.2", "", { "os": "linux", "cpu": "arm" }, "sha512-qO7F7U3u1nfxYRPM8HqFtLd+raev2K137dsV08q/LRKRLEc7RsiDWihUnrINdsWQxPR9jqZ8DIIZ1zJJAm5PjQ=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.46.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-3dRaqLfcOXYsfvw5xMrxAk9Lb1f395gkoBYzSFcc/scgRFptRXL9DOaDpMiehf9CO8ZDRJW2z45b6fpU5nwjng=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.46.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-fhHFTutA7SM+IrR6lIfiHskxmpmPTJUXpWIsBXpeEwNgZzZZSg/q4i6FU4J8qOGyJ0TR+wXBwx/L7Ho9z0+uDg=="],
+
+    "@rollup/rollup-linux-loongarch64-gnu": ["@rollup/rollup-linux-loongarch64-gnu@4.46.2", "", { "os": "linux", "cpu": "none" }, "sha512-i7wfGFXu8x4+FRqPymzjD+Hyav8l95UIZ773j7J7zRYc3Xsxy2wIn4x+llpunexXe6laaO72iEjeeGyUFmjKeA=="],
+
+    "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.46.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-B/l0dFcHVUnqcGZWKcWBSV2PF01YUt0Rvlurci5P+neqY/yMKchGU8ullZvIv5e8Y1C6wOn+U03mrDylP5q9Yw=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.46.2", "", { "os": "linux", "cpu": "none" }, "sha512-32k4ENb5ygtkMwPMucAb8MtV8olkPT03oiTxJbgkJa7lJ7dZMr0GCFJlyvy+K8iq7F/iuOr41ZdUHaOiqyR3iQ=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.46.2", "", { "os": "linux", "cpu": "none" }, "sha512-t5B2loThlFEauloaQkZg9gxV05BYeITLvLkWOkRXogP4qHXLkWSbSHKM9S6H1schf/0YGP/qNKtiISlxvfmmZw=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.46.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-YKjekwTEKgbB7n17gmODSmJVUIvj8CX7q5442/CK80L8nqOUbMtf8b01QkG3jOqyr1rotrAnW6B/qiHwfcuWQA=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.46.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Jj5a9RUoe5ra+MEyERkDKLwTXVu6s3aACP51nkfnK9wJTraCC8IMe3snOfALkrjTYd2G1ViE1hICj0fZ7ALBPA=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.46.2", "", { "os": "linux", "cpu": "x64" }, "sha512-7kX69DIrBeD7yNp4A5b81izs8BqoZkCIaxQaOpumcJ1S/kmqNFjPhDu1LHeVXv0SexfHQv5cqHsxLOjETuqDuA=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.46.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-wiJWMIpeaak/jsbaq2HMh/rzZxHVW1rU6coyeNNpMwk5isiPjSTx0a4YLSlYDwBH/WBvLz+EtsNqQScZTLJy3g=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.46.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-gBgaUDESVzMgWZhcyjfs9QFK16D8K6QZpwAaVNJxYDLHWayOta4ZMjGm/vsAEy3hvlS2GosVFlBlP9/Wb85DqQ=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.46.2", "", { "os": "win32", "cpu": "x64" }, "sha512-CvUo2ixeIQGtF6WvuB87XWqPQkoFAFqW+HUo/WzHwuHDvIwZCtjdWXoYCcr06iKGydiqTclC4jU/TNObC/xKZg=="],
+
+    "@types/babel__core": ["@types/babel__core@7.20.5", "", { "dependencies": { "@babel/parser": "^7.20.7", "@babel/types": "^7.20.7", "@types/babel__generator": "*", "@types/babel__template": "*", "@types/babel__traverse": "*" } }, "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA=="],
+
+    "@types/babel__generator": ["@types/babel__generator@7.27.0", "", { "dependencies": { "@babel/types": "^7.0.0" } }, "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg=="],
+
+    "@types/babel__template": ["@types/babel__template@7.4.4", "", { "dependencies": { "@babel/parser": "^7.1.0", "@babel/types": "^7.0.0" } }, "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A=="],
+
+    "@types/babel__traverse": ["@types/babel__traverse@7.28.0", "", { "dependencies": { "@babel/types": "^7.28.2" } }, "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q=="],
+
+    "@types/debug": ["@types/debug@4.1.12", "", { "dependencies": { "@types/ms": "*" } }, "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ=="],
+
+    "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
+
+    "@types/estree-jsx": ["@types/estree-jsx@1.0.5", "", { "dependencies": { "@types/estree": "*" } }, "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg=="],
+
+    "@types/hast": ["@types/hast@3.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ=="],
+
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
+    "@types/mdast": ["@types/mdast@4.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA=="],
+
+    "@types/ms": ["@types/ms@2.1.0", "", {}, "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="],
+
+    "@types/prismjs": ["@types/prismjs@1.26.5", "", {}, "sha512-AUZTa7hQ2KY5L7AmtSiqxlhWxb4ina0yd8hNbl4TWuqnv/pFP0nDMb3YrfSBf4hJVGLh2YEIBfKaBW/9UEl6IQ=="],
+
+    "@types/react": ["@types/react@19.1.10", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-EhBeSYX0Y6ye8pNebpKrwFJq7BoQ8J5SO6NlvNwwHjSj6adXJViPQrKlsyPw7hLBLvckEMO1yxeGdR82YBBlDg=="],
+
+    "@types/react-dom": ["@types/react-dom@19.1.7", "", { "peerDependencies": { "@types/react": "^19.0.0" } }, "sha512-i5ZzwYpqjmrKenzkoLM2Ibzt6mAsM7pxB6BCIouEVVmgiqaMj1TjaK7hnA36hbW5aZv20kx7Lw6hWzPWg0Rurw=="],
+
+    "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
+
+    "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@8.39.1", "", { "dependencies": { "@eslint-community/regexpp": "^4.10.0", "@typescript-eslint/scope-manager": "8.39.1", "@typescript-eslint/type-utils": "8.39.1", "@typescript-eslint/utils": "8.39.1", "@typescript-eslint/visitor-keys": "8.39.1", "graphemer": "^1.4.0", "ignore": "^7.0.0", "natural-compare": "^1.4.0", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "@typescript-eslint/parser": "^8.39.1", "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-yYegZ5n3Yr6eOcqgj2nJH8cH/ZZgF+l0YIdKILSDjYFRjgYQMgv/lRjV5Z7Up04b9VYUondt8EPMqg7kTWgJ2g=="],
+
+    "@typescript-eslint/parser": ["@typescript-eslint/parser@8.39.1", "", { "dependencies": { "@typescript-eslint/scope-manager": "8.39.1", "@typescript-eslint/types": "8.39.1", "@typescript-eslint/typescript-estree": "8.39.1", "@typescript-eslint/visitor-keys": "8.39.1", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-pUXGCuHnnKw6PyYq93lLRiZm3vjuslIy7tus1lIQTYVK9bL8XBgJnCWm8a0KcTtHC84Yya1Q6rtll+duSMj0dg=="],
+
+    "@typescript-eslint/project-service": ["@typescript-eslint/project-service@8.39.1", "", { "dependencies": { "@typescript-eslint/tsconfig-utils": "^8.39.1", "@typescript-eslint/types": "^8.39.1", "debug": "^4.3.4" }, "peerDependencies": { "typescript": ">=4.8.4 <6.0.0" } }, "sha512-8fZxek3ONTwBu9ptw5nCKqZOSkXshZB7uAxuFF0J/wTMkKydjXCzqqga7MlFMpHi9DoG4BadhmTkITBcg8Aybw=="],
+
+    "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@8.39.1", "", { "dependencies": { "@typescript-eslint/types": "8.39.1", "@typescript-eslint/visitor-keys": "8.39.1" } }, "sha512-RkBKGBrjgskFGWuyUGz/EtD8AF/GW49S21J8dvMzpJitOF1slLEbbHnNEtAHtnDAnx8qDEdRrULRnWVx27wGBw=="],
+
+    "@typescript-eslint/tsconfig-utils": ["@typescript-eslint/tsconfig-utils@8.39.1", "", { "peerDependencies": { "typescript": ">=4.8.4 <6.0.0" } }, "sha512-ePUPGVtTMR8XMU2Hee8kD0Pu4NDE1CN9Q1sxGSGd/mbOtGZDM7pnhXNJnzW63zk/q+Z54zVzj44HtwXln5CvHA=="],
+
+    "@typescript-eslint/type-utils": ["@typescript-eslint/type-utils@8.39.1", "", { "dependencies": { "@typescript-eslint/types": "8.39.1", "@typescript-eslint/typescript-estree": "8.39.1", "@typescript-eslint/utils": "8.39.1", "debug": "^4.3.4", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-gu9/ahyatyAdQbKeHnhT4R+y3YLtqqHyvkfDxaBYk97EcbfChSJXyaJnIL3ygUv7OuZatePHmQvuH5ru0lnVeA=="],
+
+    "@typescript-eslint/types": ["@typescript-eslint/types@8.39.1", "", {}, "sha512-7sPDKQQp+S11laqTrhHqeAbsCfMkwJMrV7oTDvtDds4mEofJYir414bYKUEb8YPUm9QL3U+8f6L6YExSoAGdQw=="],
+
+    "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@8.39.1", "", { "dependencies": { "@typescript-eslint/project-service": "8.39.1", "@typescript-eslint/tsconfig-utils": "8.39.1", "@typescript-eslint/types": "8.39.1", "@typescript-eslint/visitor-keys": "8.39.1", "debug": "^4.3.4", "fast-glob": "^3.3.2", "is-glob": "^4.0.3", "minimatch": "^9.0.4", "semver": "^7.6.0", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "typescript": ">=4.8.4 <6.0.0" } }, "sha512-EKkpcPuIux48dddVDXyQBlKdeTPMmALqBUbEk38McWv0qVEZwOpVJBi7ugK5qVNgeuYjGNQxrrnoM/5+TI/BPw=="],
+
+    "@typescript-eslint/utils": ["@typescript-eslint/utils@8.39.1", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.7.0", "@typescript-eslint/scope-manager": "8.39.1", "@typescript-eslint/types": "8.39.1", "@typescript-eslint/typescript-estree": "8.39.1" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-VF5tZ2XnUSTuiqZFXCZfZs1cgkdd3O/sSYmdo2EpSyDlC86UM/8YytTmKnehOW3TGAlivqTDT6bS87B/GQ/jyg=="],
+
+    "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.39.1", "", { "dependencies": { "@typescript-eslint/types": "8.39.1", "eslint-visitor-keys": "^4.2.1" } }, "sha512-W8FQi6kEh2e8zVhQ0eeRnxdvIoOkAp/CPAahcNio6nO9dsIwb9b34z90KOlheoyuVf6LSOEdjlkxSkapNEc+4A=="],
+
+    "@uiw/copy-to-clipboard": ["@uiw/copy-to-clipboard@1.0.17", "", {}, "sha512-O2GUHV90Iw2VrSLVLK0OmNIMdZ5fgEg4NhvtwINsX+eZ/Wf6DWD0TdsK9xwV7dNRnK/UI2mQtl0a2/kRgm1m1A=="],
+
+    "@uiw/react-markdown-preview": ["@uiw/react-markdown-preview@5.1.5", "", { "dependencies": { "@babel/runtime": "^7.17.2", "@uiw/copy-to-clipboard": "~1.0.12", "react-markdown": "~9.0.1", "rehype-attr": "~3.0.1", "rehype-autolink-headings": "~7.1.0", "rehype-ignore": "^2.0.0", "rehype-prism-plus": "2.0.0", "rehype-raw": "^7.0.0", "rehype-rewrite": "~4.0.0", "rehype-slug": "~6.0.0", "remark-gfm": "~4.0.0", "remark-github-blockquote-alert": "^1.0.0", "unist-util-visit": "^5.0.0" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-DNOqx1a6gJR7Btt57zpGEKTfHRlb7rWbtctMRO2f82wWcuoJsxPBrM+JWebDdOD0LfD8oe2CQvW2ICQJKHQhZg=="],
+
+    "@uiw/react-md-editor": ["@uiw/react-md-editor@4.0.8", "", { "dependencies": { "@babel/runtime": "^7.14.6", "@uiw/react-markdown-preview": "^5.0.6", "rehype": "~13.0.0", "rehype-prism-plus": "~2.0.0" }, "peerDependencies": { "react": ">=16.8.0", "react-dom": ">=16.8.0" } }, "sha512-S3mOzZeGmJNhzdXJxRTCwsFMDp8nBWeQUf59cK3L6QHzDUHnRoHpcmWpfVRyKGKSg8zaI2+meU5cYWf8kYn3mQ=="],
+
+    "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="],
+
+    "@vitejs/plugin-react": ["@vitejs/plugin-react@5.0.0", "", { "dependencies": { "@babel/core": "^7.28.0", "@babel/plugin-transform-react-jsx-self": "^7.27.1", "@babel/plugin-transform-react-jsx-source": "^7.27.1", "@rolldown/pluginutils": "1.0.0-beta.30", "@types/babel__core": "^7.20.5", "react-refresh": "^0.17.0" }, "peerDependencies": { "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" } }, "sha512-Jx9JfsTa05bYkS9xo0hkofp2dCmp1blrKjw9JONs5BTHOvJCgLbaPSuZLGSVJW6u2qe0tc4eevY0+gSNNi0YCw=="],
+
+    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
+
+    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
+
+    "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "antd": ["antd@5.27.0", "", { "dependencies": { "@ant-design/colors": "^7.2.1", "@ant-design/cssinjs": "^1.23.0", "@ant-design/cssinjs-utils": "^1.1.3", "@ant-design/fast-color": "^2.0.6", "@ant-design/icons": "^5.6.1", "@ant-design/react-slick": "~1.1.2", "@babel/runtime": "^7.26.0", "@rc-component/color-picker": "~2.0.1", "@rc-component/mutate-observer": "^1.1.0", "@rc-component/qrcode": "~1.0.0", "@rc-component/tour": "~1.15.1", "@rc-component/trigger": "^2.3.0", "classnames": "^2.5.1", "copy-to-clipboard": "^3.3.3", "dayjs": "^1.11.11", "rc-cascader": "~3.34.0", "rc-checkbox": "~3.5.0", "rc-collapse": "~3.9.0", "rc-dialog": "~9.6.0", "rc-drawer": "~7.3.0", "rc-dropdown": "~4.2.1", "rc-field-form": "~2.7.0", "rc-image": "~7.12.0", "rc-input": "~1.8.0", "rc-input-number": "~9.5.0", "rc-mentions": "~2.20.0", "rc-menu": "~9.16.1", "rc-motion": "^2.9.5", "rc-notification": "~5.6.4", "rc-pagination": "~5.1.0", "rc-picker": "~4.11.3", "rc-progress": "~4.0.0", "rc-rate": "~2.13.1", "rc-resize-observer": "^1.4.3", "rc-segmented": "~2.7.0", "rc-select": "~14.16.8", "rc-slider": "~11.1.8", "rc-steps": "~6.0.1", "rc-switch": "~4.1.0", "rc-table": "~7.51.1", "rc-tabs": "~15.7.0", "rc-textarea": "~1.10.2", "rc-tooltip": "~6.4.0", "rc-tree": "~5.13.1", "rc-tree-select": "~5.27.0", "rc-upload": "~4.9.2", "rc-util": "^5.44.4", "scroll-into-view-if-needed": "^3.1.0", "throttle-debounce": "^5.0.2" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-o54dmpooLOc08RSGCkeEQBYAGPxUSmnhmYJKCNTHH46vzjOVxdteu+wPTRVkRbAkDTbs2VcNr5VL7Lu67rPIiA=="],
+
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
+
+    "bail": ["bail@2.0.2", "", {}, "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw=="],
+
+    "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
+
+    "bcp-47-match": ["bcp-47-match@2.0.3", "", {}, "sha512-JtTezzbAibu8G0R9op9zb3vcWZd9JF6M0xOYGPn0fNCd7wOpRB1mU2mH9T8gaBGbAAyIIVgB2G7xG0GP98zMAQ=="],
+
+    "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="],
+
+    "brace-expansion": ["brace-expansion@1.1.12", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg=="],
+
+    "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
+
+    "browserslist": ["browserslist@4.25.2", "", { "dependencies": { "caniuse-lite": "^1.0.30001733", "electron-to-chromium": "^1.5.199", "node-releases": "^2.0.19", "update-browserslist-db": "^1.1.3" }, "bin": { "browserslist": "cli.js" } }, "sha512-0si2SJK3ooGzIawRu61ZdPCO1IncZwS8IzuX73sPZsXW6EQ/w/DAfPyKI8l1ETTCr2MnvqWitmlCUxgdul45jA=="],
+
+    "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="],
+
+    "caniuse-lite": ["caniuse-lite@1.0.30001735", "", {}, "sha512-EV/laoX7Wq2J9TQlyIXRxTJqIw4sxfXS4OYgudGxBYRuTv0q7AM6yMEpU/Vo1I94thg9U6EZ2NfZx9GJq83u7w=="],
+
+    "ccount": ["ccount@2.0.1", "", {}, "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg=="],
+
+    "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "character-entities": ["character-entities@2.0.2", "", {}, "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ=="],
+
+    "character-entities-html4": ["character-entities-html4@2.1.0", "", {}, "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA=="],
+
+    "character-entities-legacy": ["character-entities-legacy@3.0.0", "", {}, "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ=="],
+
+    "character-reference-invalid": ["character-reference-invalid@2.0.1", "", {}, "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw=="],
+
+    "classnames": ["classnames@2.5.1", "", {}, "sha512-saHYOzhIQs6wy2sVxTM6bUDsQO4F50V9RQ22qBpEdCW+I+/Wmke2HOl6lS6dTpdxVhb88/I6+Hs+438c3lfUow=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "comma-separated-tokens": ["comma-separated-tokens@2.0.3", "", {}, "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg=="],
+
+    "compute-scroll-into-view": ["compute-scroll-into-view@3.1.1", "", {}, "sha512-VRhuHOLoKYOy4UbilLbUzbYg93XLjv2PncJC50EuTWPA3gaja1UjBsUP/D/9/juV3vQFr6XBEzn9KCAHdUvOHw=="],
+
+    "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="],
+
+    "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
+
+    "cookie": ["cookie@1.0.2", "", {}, "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA=="],
+
+    "copy-to-clipboard": ["copy-to-clipboard@3.3.3", "", { "dependencies": { "toggle-selection": "^1.0.6" } }, "sha512-2KV8NhB5JqC3ky0r9PMCAZKbUHSwtEo4CwCs0KXgruG43gX5PMqDEBbVU4OUzw2MuAWUfsuFmWvEKG5QRfSnJA=="],
+
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+
+    "css-selector-parser": ["css-selector-parser@3.1.3", "", {}, "sha512-gJMigczVZqYAk0hPVzx/M4Hm1D9QOtqkdQk9005TNzDIUGzo5cnHEDiKUT7jGPximL/oYb+LIitcHFQ4aKupxg=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "date-fns": ["date-fns@4.1.0", "", {}, "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg=="],
+
+    "dayjs": ["dayjs@1.11.13", "", {}, "sha512-oaMBel6gjolK862uaPQOVTA7q3TZhuSvuMQAAglQDOWYO9A91IrAOUJEyKVlqJlHE0vq5p5UXxzdPfMH/x6xNg=="],
+
+    "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+
+    "decode-named-character-reference": ["decode-named-character-reference@1.2.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q=="],
+
+    "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="],
+
+    "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
+
+    "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
+
+    "direction": ["direction@2.0.1", "", { "bin": { "direction": "cli.js" } }, "sha512-9S6m9Sukh1cZNknO1CWAr2QAWsbKLafQiyM5gZ7VgXHeuaoUwffKN4q6NC4A/Mf9iiPlOXQEKW/Mv/mh9/3YFA=="],
+
+    "electron-to-chromium": ["electron-to-chromium@1.5.201", "", {}, "sha512-ZG65vsrLClodGqywuigc+7m0gr4ISoTQttfVh7nfpLv0M7SIwF4WbFNEOywcqTiujs12AUeeXbFyQieDICAIxg=="],
+
+    "entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="],
+
+    "esbuild": ["esbuild@0.25.9", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.9", "@esbuild/android-arm": "0.25.9", "@esbuild/android-arm64": "0.25.9", "@esbuild/android-x64": "0.25.9", "@esbuild/darwin-arm64": "0.25.9", "@esbuild/darwin-x64": "0.25.9", "@esbuild/freebsd-arm64": "0.25.9", "@esbuild/freebsd-x64": "0.25.9", "@esbuild/linux-arm": "0.25.9", "@esbuild/linux-arm64": "0.25.9", "@esbuild/linux-ia32": "0.25.9", "@esbuild/linux-loong64": "0.25.9", "@esbuild/linux-mips64el": "0.25.9", "@esbuild/linux-ppc64": "0.25.9", "@esbuild/linux-riscv64": "0.25.9", "@esbuild/linux-s390x": "0.25.9", "@esbuild/linux-x64": "0.25.9", "@esbuild/netbsd-arm64": "0.25.9", "@esbuild/netbsd-x64": "0.25.9", "@esbuild/openbsd-arm64": "0.25.9", "@esbuild/openbsd-x64": "0.25.9", "@esbuild/openharmony-arm64": "0.25.9", "@esbuild/sunos-x64": "0.25.9", "@esbuild/win32-arm64": "0.25.9", "@esbuild/win32-ia32": "0.25.9", "@esbuild/win32-x64": "0.25.9" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-CRbODhYyQx3qp7ZEwzxOk4JBqmD/seJrzPa/cGjY1VtIn5E09Oi9/dB4JwctnfZ8Q8iT7rioVv5k/FNT/uf54g=="],
+
+    "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="],
+
+    "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
+
+    "eslint": ["eslint@9.33.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.12.1", "@eslint/config-array": "^0.21.0", "@eslint/config-helpers": "^0.3.1", "@eslint/core": "^0.15.2", "@eslint/eslintrc": "^3.3.1", "@eslint/js": "9.33.0", "@eslint/plugin-kit": "^0.3.5", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "@types/json-schema": "^7.0.15", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^8.4.0", "eslint-visitor-keys": "^4.2.1", "espree": "^10.4.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-TS9bTNIryDzStCpJN93aC5VRSW3uTx9sClUn4B87pwiCaJh220otoI0X8mJKr+VcPtniMdN8GKjlwgWGUv5ZKA=="],
+
+    "eslint-plugin-react-hooks": ["eslint-plugin-react-hooks@5.2.0", "", { "peerDependencies": { "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0" } }, "sha512-+f15FfK64YQwZdJNELETdn5ibXEUQmW1DZL6KXhNnc2heoy/sg9VJJeT7n8TlMWouzWqSWavFkIhHyIbIAEapg=="],
+
+    "eslint-plugin-react-refresh": ["eslint-plugin-react-refresh@0.4.20", "", { "peerDependencies": { "eslint": ">=8.40" } }, "sha512-XpbHQ2q5gUF8BGOX4dHe+71qoirYMhApEPZ7sfhF/dNnOF1UXnCMGZf79SFTBO7Bz5YEIT4TMieSlJBWhP9WBA=="],
+
+    "eslint-scope": ["eslint-scope@8.4.0", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg=="],
+
+    "eslint-visitor-keys": ["eslint-visitor-keys@4.2.1", "", {}, "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ=="],
+
+    "espree": ["espree@10.4.0", "", { "dependencies": { "acorn": "^8.15.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^4.2.1" } }, "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ=="],
+
+    "esquery": ["esquery@1.6.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg=="],
+
+    "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="],
+
+    "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
+
+    "estree-util-is-identifier-name": ["estree-util-is-identifier-name@3.0.0", "", {}, "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg=="],
+
+    "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="],
+
+    "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],
+
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
+
+    "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="],
+
+    "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="],
+
+    "fastq": ["fastq@1.19.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ=="],
+
+    "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="],
+
+    "file-entry-cache": ["file-entry-cache@8.0.0", "", { "dependencies": { "flat-cache": "^4.0.0" } }, "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ=="],
+
+    "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
+
+    "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="],
+
+    "flat-cache": ["flat-cache@4.0.1", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" } }, "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw=="],
+
+    "flatted": ["flatted@3.3.3", "", {}, "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "gensync": ["gensync@1.0.0-beta.2", "", {}, "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="],
+
+    "github-slugger": ["github-slugger@2.0.0", "", {}, "sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw=="],
+
+    "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
+
+    "globals": ["globals@16.3.0", "", {}, "sha512-bqWEnJ1Nt3neqx2q5SFfGS8r/ahumIakg3HcwtNlrVlwXIeNumWn/c7Pn/wKzGhf6SaW6H6uWXLqC30STCMchQ=="],
+
+    "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="],
+
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
+
+    "hast-util-from-html": ["hast-util-from-html@2.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "devlop": "^1.1.0", "hast-util-from-parse5": "^8.0.0", "parse5": "^7.0.0", "vfile": "^6.0.0", "vfile-message": "^4.0.0" } }, "sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw=="],
+
+    "hast-util-from-parse5": ["hast-util-from-parse5@8.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "devlop": "^1.0.0", "hastscript": "^9.0.0", "property-information": "^7.0.0", "vfile": "^6.0.0", "vfile-location": "^5.0.0", "web-namespaces": "^2.0.0" } }, "sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg=="],
+
+    "hast-util-has-property": ["hast-util-has-property@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-MNilsvEKLFpV604hwfhVStK0usFY/QmM5zX16bo7EjnAEGofr5YyI37kzopBlZJkHD4t887i+q/C8/tr5Q94cA=="],
+
+    "hast-util-heading-rank": ["hast-util-heading-rank@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-EJKb8oMUXVHcWZTDepnr+WNbfnXKFNf9duMesmr4S8SXTJBJ9M4Yok08pu9vxdJwdlGRhVumk9mEhkEvKGifwA=="],
+
+    "hast-util-is-element": ["hast-util-is-element@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g=="],
+
+    "hast-util-parse-selector": ["hast-util-parse-selector@3.1.1", "", { "dependencies": { "@types/hast": "^2.0.0" } }, "sha512-jdlwBjEexy1oGz0aJ2f4GKMaVKkA9jwjr4MjAAI22E5fM/TXVZHuS5OpONtdeIkRKqAaryQ2E9xNQxijoThSZA=="],
+
+    "hast-util-raw": ["hast-util-raw@9.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "hast-util-from-parse5": "^8.0.0", "hast-util-to-parse5": "^8.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "parse5": "^7.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0", "web-namespaces": "^2.0.0", "zwitch": "^2.0.0" } }, "sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw=="],
+
+    "hast-util-select": ["hast-util-select@6.0.4", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "bcp-47-match": "^2.0.0", "comma-separated-tokens": "^2.0.0", "css-selector-parser": "^3.0.0", "devlop": "^1.0.0", "direction": "^2.0.0", "hast-util-has-property": "^3.0.0", "hast-util-to-string": "^3.0.0", "hast-util-whitespace": "^3.0.0", "nth-check": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-RqGS1ZgI0MwxLaKLDxjprynNzINEkRHY2i8ln4DDjgv9ZhcYVIHN9rlpiYsqtFwrgpYU361SyWDQcGNIBVu3lw=="],
+
+    "hast-util-to-html": ["hast-util-to-html@9.0.5", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-whitespace": "^3.0.0", "html-void-elements": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "stringify-entities": "^4.0.0", "zwitch": "^2.0.4" } }, "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw=="],
+
+    "hast-util-to-jsx-runtime": ["hast-util-to-jsx-runtime@2.3.6", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/hast": "^3.0.0", "@types/unist": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "hast-util-whitespace": "^3.0.0", "mdast-util-mdx-expression": "^2.0.0", "mdast-util-mdx-jsx": "^3.0.0", "mdast-util-mdxjs-esm": "^2.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0", "style-to-js": "^1.0.0", "unist-util-position": "^5.0.0", "vfile-message": "^4.0.0" } }, "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg=="],
+
+    "hast-util-to-parse5": ["hast-util-to-parse5@8.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "devlop": "^1.0.0", "property-information": "^6.0.0", "space-separated-tokens": "^2.0.0", "web-namespaces": "^2.0.0", "zwitch": "^2.0.0" } }, "sha512-3KKrV5ZVI8if87DVSi1vDeByYrkGzg4mEfeu4alwgmmIeARiBLKCZS2uw5Gb6nU9x9Yufyj3iudm6i7nl52PFw=="],
+
+    "hast-util-to-string": ["hast-util-to-string@3.0.1", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A=="],
+
+    "hast-util-whitespace": ["hast-util-whitespace@3.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw=="],
+
+    "hastscript": ["hastscript@7.2.0", "", { "dependencies": { "@types/hast": "^2.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-parse-selector": "^3.0.0", "property-information": "^6.0.0", "space-separated-tokens": "^2.0.0" } }, "sha512-TtYPq24IldU8iKoJQqvZOuhi5CyCQRAbvDOX0x1eW6rsHSxa/1i2CCiptNTotGHJ3VoHRGmqiv6/D3q113ikkw=="],
+
+    "html-url-attributes": ["html-url-attributes@3.0.1", "", {}, "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ=="],
+
+    "html-void-elements": ["html-void-elements@3.0.0", "", {}, "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg=="],
+
+    "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
+
+    "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="],
+
+    "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="],
+
+    "inline-style-parser": ["inline-style-parser@0.2.4", "", {}, "sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q=="],
+
+    "is-alphabetical": ["is-alphabetical@2.0.1", "", {}, "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ=="],
+
+    "is-alphanumerical": ["is-alphanumerical@2.0.1", "", { "dependencies": { "is-alphabetical": "^2.0.0", "is-decimal": "^2.0.0" } }, "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw=="],
+
+    "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="],
+
+    "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
+
+    "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
+
+    "is-hexadecimal": ["is-hexadecimal@2.0.1", "", {}, "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg=="],
+
+    "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
+
+    "is-plain-obj": ["is-plain-obj@4.1.0", "", {}, "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg=="],
+
+    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
+
+    "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
+
+    "js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="],
+
+    "jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="],
+
+    "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="],
+
+    "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="],
+
+    "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="],
+
+    "json2mq": ["json2mq@0.2.0", "", { "dependencies": { "string-convert": "^0.2.0" } }, "sha512-SzoRg7ux5DWTII9J2qkrZrqV1gt+rTaoufMxEzXbS26Uid0NwaJd123HcoB80TgubEppxxIGdNxCx50fEoEWQA=="],
+
+    "json5": ["json5@2.2.3", "", { "bin": { "json5": "lib/cli.js" } }, "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg=="],
+
+    "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="],
+
+    "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=="],
+
+    "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="],
+
+    "longest-streak": ["longest-streak@3.1.0", "", {}, "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g=="],
+
+    "lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="],
+
+    "markdown-table": ["markdown-table@3.0.4", "", {}, "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw=="],
+
+    "mdast-util-find-and-replace": ["mdast-util-find-and-replace@3.0.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "escape-string-regexp": "^5.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg=="],
+
+    "mdast-util-from-markdown": ["mdast-util-from-markdown@2.0.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "mdast-util-to-string": "^4.0.0", "micromark": "^4.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA=="],
+
+    "mdast-util-gfm": ["mdast-util-gfm@3.1.0", "", { "dependencies": { "mdast-util-from-markdown": "^2.0.0", "mdast-util-gfm-autolink-literal": "^2.0.0", "mdast-util-gfm-footnote": "^2.0.0", "mdast-util-gfm-strikethrough": "^2.0.0", "mdast-util-gfm-table": "^2.0.0", "mdast-util-gfm-task-list-item": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ=="],
+
+    "mdast-util-gfm-autolink-literal": ["mdast-util-gfm-autolink-literal@2.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "ccount": "^2.0.0", "devlop": "^1.0.0", "mdast-util-find-and-replace": "^3.0.0", "micromark-util-character": "^2.0.0" } }, "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ=="],
+
+    "mdast-util-gfm-footnote": ["mdast-util-gfm-footnote@2.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.1.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0" } }, "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ=="],
+
+    "mdast-util-gfm-strikethrough": ["mdast-util-gfm-strikethrough@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg=="],
+
+    "mdast-util-gfm-table": ["mdast-util-gfm-table@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "markdown-table": "^3.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg=="],
+
+    "mdast-util-gfm-task-list-item": ["mdast-util-gfm-task-list-item@2.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ=="],
+
+    "mdast-util-mdx-expression": ["mdast-util-mdx-expression@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ=="],
+
+    "mdast-util-mdx-jsx": ["mdast-util-mdx-jsx@3.2.0", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "ccount": "^2.0.0", "devlop": "^1.1.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0", "parse-entities": "^4.0.0", "stringify-entities": "^4.0.0", "unist-util-stringify-position": "^4.0.0", "vfile-message": "^4.0.0" } }, "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q=="],
+
+    "mdast-util-mdxjs-esm": ["mdast-util-mdxjs-esm@2.0.1", "", { "dependencies": { "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "devlop": "^1.0.0", "mdast-util-from-markdown": "^2.0.0", "mdast-util-to-markdown": "^2.0.0" } }, "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg=="],
+
+    "mdast-util-phrasing": ["mdast-util-phrasing@4.1.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "unist-util-is": "^6.0.0" } }, "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w=="],
+
+    "mdast-util-to-hast": ["mdast-util-to-hast@13.2.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "@ungap/structured-clone": "^1.0.0", "devlop": "^1.0.0", "micromark-util-sanitize-uri": "^2.0.0", "trim-lines": "^3.0.0", "unist-util-position": "^5.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA=="],
+
+    "mdast-util-to-markdown": ["mdast-util-to-markdown@2.1.2", "", { "dependencies": { "@types/mdast": "^4.0.0", "@types/unist": "^3.0.0", "longest-streak": "^3.0.0", "mdast-util-phrasing": "^4.0.0", "mdast-util-to-string": "^4.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-decode-string": "^2.0.0", "unist-util-visit": "^5.0.0", "zwitch": "^2.0.0" } }, "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA=="],
+
+    "mdast-util-to-string": ["mdast-util-to-string@4.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0" } }, "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg=="],
+
+    "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+
+    "micromark": ["micromark@4.0.2", "", { "dependencies": { "@types/debug": "^4.0.0", "debug": "^4.0.0", "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA=="],
+
+    "micromark-core-commonmark": ["micromark-core-commonmark@2.0.3", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "devlop": "^1.0.0", "micromark-factory-destination": "^2.0.0", "micromark-factory-label": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-factory-title": "^2.0.0", "micromark-factory-whitespace": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-html-tag-name": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-subtokenize": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg=="],
+
+    "micromark-extension-gfm": ["micromark-extension-gfm@3.0.0", "", { "dependencies": { "micromark-extension-gfm-autolink-literal": "^2.0.0", "micromark-extension-gfm-footnote": "^2.0.0", "micromark-extension-gfm-strikethrough": "^2.0.0", "micromark-extension-gfm-table": "^2.0.0", "micromark-extension-gfm-tagfilter": "^2.0.0", "micromark-extension-gfm-task-list-item": "^2.0.0", "micromark-util-combine-extensions": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w=="],
+
+    "micromark-extension-gfm-autolink-literal": ["micromark-extension-gfm-autolink-literal@2.1.0", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw=="],
+
+    "micromark-extension-gfm-footnote": ["micromark-extension-gfm-footnote@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-core-commonmark": "^2.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-normalize-identifier": "^2.0.0", "micromark-util-sanitize-uri": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw=="],
+
+    "micromark-extension-gfm-strikethrough": ["micromark-extension-gfm-strikethrough@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-classify-character": "^2.0.0", "micromark-util-resolve-all": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw=="],
+
+    "micromark-extension-gfm-table": ["micromark-extension-gfm-table@2.1.1", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg=="],
+
+    "micromark-extension-gfm-tagfilter": ["micromark-extension-gfm-tagfilter@2.0.0", "", { "dependencies": { "micromark-util-types": "^2.0.0" } }, "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg=="],
+
+    "micromark-extension-gfm-task-list-item": ["micromark-extension-gfm-task-list-item@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw=="],
+
+    "micromark-factory-destination": ["micromark-factory-destination@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA=="],
+
+    "micromark-factory-label": ["micromark-factory-label@2.0.1", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg=="],
+
+    "micromark-factory-space": ["micromark-factory-space@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg=="],
+
+    "micromark-factory-title": ["micromark-factory-title@2.0.1", "", { "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw=="],
+
+    "micromark-factory-whitespace": ["micromark-factory-whitespace@2.0.1", "", { "dependencies": { "micromark-factory-space": "^2.0.0", "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ=="],
+
+    "micromark-util-character": ["micromark-util-character@2.1.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q=="],
+
+    "micromark-util-chunked": ["micromark-util-chunked@2.0.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA=="],
+
+    "micromark-util-classify-character": ["micromark-util-classify-character@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q=="],
+
+    "micromark-util-combine-extensions": ["micromark-util-combine-extensions@2.0.1", "", { "dependencies": { "micromark-util-chunked": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg=="],
+
+    "micromark-util-decode-numeric-character-reference": ["micromark-util-decode-numeric-character-reference@2.0.2", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw=="],
+
+    "micromark-util-decode-string": ["micromark-util-decode-string@2.0.1", "", { "dependencies": { "decode-named-character-reference": "^1.0.0", "micromark-util-character": "^2.0.0", "micromark-util-decode-numeric-character-reference": "^2.0.0", "micromark-util-symbol": "^2.0.0" } }, "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ=="],
+
+    "micromark-util-encode": ["micromark-util-encode@2.0.1", "", {}, "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw=="],
+
+    "micromark-util-html-tag-name": ["micromark-util-html-tag-name@2.0.1", "", {}, "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA=="],
+
+    "micromark-util-normalize-identifier": ["micromark-util-normalize-identifier@2.0.1", "", { "dependencies": { "micromark-util-symbol": "^2.0.0" } }, "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q=="],
+
+    "micromark-util-resolve-all": ["micromark-util-resolve-all@2.0.1", "", { "dependencies": { "micromark-util-types": "^2.0.0" } }, "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg=="],
+
+    "micromark-util-sanitize-uri": ["micromark-util-sanitize-uri@2.0.1", "", { "dependencies": { "micromark-util-character": "^2.0.0", "micromark-util-encode": "^2.0.0", "micromark-util-symbol": "^2.0.0" } }, "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ=="],
+
+    "micromark-util-subtokenize": ["micromark-util-subtokenize@2.1.0", "", { "dependencies": { "devlop": "^1.0.0", "micromark-util-chunked": "^2.0.0", "micromark-util-symbol": "^2.0.0", "micromark-util-types": "^2.0.0" } }, "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA=="],
+
+    "micromark-util-symbol": ["micromark-util-symbol@2.0.1", "", {}, "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q=="],
+
+    "micromark-util-types": ["micromark-util-types@2.0.2", "", {}, "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA=="],
+
+    "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
+
+    "minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="],
+
+    "node-releases": ["node-releases@2.0.19", "", {}, "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw=="],
+
+    "nth-check": ["nth-check@2.1.1", "", { "dependencies": { "boolbase": "^1.0.0" } }, "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w=="],
+
+    "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=="],
+
+    "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
+
+    "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="],
+
+    "parse-entities": ["parse-entities@4.0.2", "", { "dependencies": { "@types/unist": "^2.0.0", "character-entities-legacy": "^3.0.0", "character-reference-invalid": "^2.0.0", "decode-named-character-reference": "^1.0.0", "is-alphanumerical": "^2.0.0", "is-decimal": "^2.0.0", "is-hexadecimal": "^2.0.0" } }, "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw=="],
+
+    "parse-numeric-range": ["parse-numeric-range@1.3.0", "", {}, "sha512-twN+njEipszzlMJd4ONUYgSfZPDxgHhT9Ahed5uTigpQn90FggW4SA/AIPq/6a149fTbE9qBEcSwE3FAEp6wQQ=="],
+
+    "parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="],
+
+    "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
+
+    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="],
+
+    "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
+
+    "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="],
+
+    "property-information": ["property-information@7.1.0", "", {}, "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ=="],
+
+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
+    "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
+
+    "rc-cascader": ["rc-cascader@3.34.0", "", { "dependencies": { "@babel/runtime": "^7.25.7", "classnames": "^2.3.1", "rc-select": "~14.16.2", "rc-tree": "~5.13.0", "rc-util": "^5.43.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-KpXypcvju9ptjW9FaN2NFcA2QH9E9LHKq169Y0eWtH4e/wHQ5Wh5qZakAgvb8EKZ736WZ3B0zLLOBsrsja5Dag=="],
+
+    "rc-checkbox": ["rc-checkbox@3.5.0", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "^2.3.2", "rc-util": "^5.25.2" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-aOAQc3E98HteIIsSqm6Xk2FPKIER6+5vyEFMZfo73TqM+VVAIqOkHoPjgKLqSNtVLWScoaM7vY2ZrGEheI79yg=="],
+
+    "rc-collapse": ["rc-collapse@3.9.0", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "2.x", "rc-motion": "^2.3.4", "rc-util": "^5.27.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-swDdz4QZ4dFTo4RAUMLL50qP0EY62N2kvmk2We5xYdRwcRn8WcYtuetCJpwpaCbUfUt5+huLpVxhvmnK+PHrkA=="],
+
+    "rc-dialog": ["rc-dialog@9.6.0", "", { "dependencies": { "@babel/runtime": "^7.10.1", "@rc-component/portal": "^1.0.0-8", "classnames": "^2.2.6", "rc-motion": "^2.3.0", "rc-util": "^5.21.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-ApoVi9Z8PaCQg6FsUzS8yvBEQy0ZL2PkuvAgrmohPkN3okps5WZ5WQWPc1RNuiOKaAYv8B97ACdsFU5LizzCqg=="],
+
+    "rc-drawer": ["rc-drawer@7.3.0", "", { "dependencies": { "@babel/runtime": "^7.23.9", "@rc-component/portal": "^1.1.1", "classnames": "^2.2.6", "rc-motion": "^2.6.1", "rc-util": "^5.38.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-DX6CIgiBWNpJIMGFO8BAISFkxiuKitoizooj4BDyee8/SnBn0zwO2FHrNDpqqepj0E/TFTDpmEBCyFuTgC7MOg=="],
+
+    "rc-dropdown": ["rc-dropdown@4.2.1", "", { "dependencies": { "@babel/runtime": "^7.18.3", "@rc-component/trigger": "^2.0.0", "classnames": "^2.2.6", "rc-util": "^5.44.1" }, "peerDependencies": { "react": ">=16.11.0", "react-dom": ">=16.11.0" } }, "sha512-YDAlXsPv3I1n42dv1JpdM7wJ+gSUBfeyPK59ZpBD9jQhK9jVuxpjj3NmWQHOBceA1zEPVX84T2wbdb2SD0UjmA=="],
+
+    "rc-field-form": ["rc-field-form@2.7.0", "", { "dependencies": { "@babel/runtime": "^7.18.0", "@rc-component/async-validator": "^5.0.3", "rc-util": "^5.32.2" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-hgKsCay2taxzVnBPZl+1n4ZondsV78G++XVsMIJCAoioMjlMQR9YwAp7JZDIECzIu2Z66R+f4SFIRrO2DjDNAA=="],
+
+    "rc-image": ["rc-image@7.12.0", "", { "dependencies": { "@babel/runtime": "^7.11.2", "@rc-component/portal": "^1.0.2", "classnames": "^2.2.6", "rc-dialog": "~9.6.0", "rc-motion": "^2.6.2", "rc-util": "^5.34.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-cZ3HTyyckPnNnUb9/DRqduqzLfrQRyi+CdHjdqgsyDpI3Ln5UX1kXnAhPBSJj9pVRzwRFgqkN7p9b6HBDjmu/Q=="],
+
+    "rc-input": ["rc-input@1.8.0", "", { "dependencies": { "@babel/runtime": "^7.11.1", "classnames": "^2.2.1", "rc-util": "^5.18.1" }, "peerDependencies": { "react": ">=16.0.0", "react-dom": ">=16.0.0" } }, "sha512-KXvaTbX+7ha8a/k+eg6SYRVERK0NddX8QX7a7AnRvUa/rEH0CNMlpcBzBkhI0wp2C8C4HlMoYl8TImSN+fuHKA=="],
+
+    "rc-input-number": ["rc-input-number@9.5.0", "", { "dependencies": { "@babel/runtime": "^7.10.1", "@rc-component/mini-decimal": "^1.0.1", "classnames": "^2.2.5", "rc-input": "~1.8.0", "rc-util": "^5.40.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-bKaEvB5tHebUURAEXw35LDcnRZLq3x1k7GxfAqBMzmpHkDGzjAtnUL8y4y5N15rIFIg5IJgwr211jInl3cipag=="],
+
+    "rc-mentions": ["rc-mentions@2.20.0", "", { "dependencies": { "@babel/runtime": "^7.22.5", "@rc-component/trigger": "^2.0.0", "classnames": "^2.2.6", "rc-input": "~1.8.0", "rc-menu": "~9.16.0", "rc-textarea": "~1.10.0", "rc-util": "^5.34.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-w8HCMZEh3f0nR8ZEd466ATqmXFCMGMN5UFCzEUL0bM/nGw/wOS2GgRzKBcm19K++jDyuWCOJOdgcKGXU3fXfbQ=="],
+
+    "rc-menu": ["rc-menu@9.16.1", "", { "dependencies": { "@babel/runtime": "^7.10.1", "@rc-component/trigger": "^2.0.0", "classnames": "2.x", "rc-motion": "^2.4.3", "rc-overflow": "^1.3.1", "rc-util": "^5.27.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-ghHx6/6Dvp+fw8CJhDUHFHDJ84hJE3BXNCzSgLdmNiFErWSOaZNsihDAsKq9ByTALo/xkNIwtDFGIl6r+RPXBg=="],
+
+    "rc-motion": ["rc-motion@2.9.5", "", { "dependencies": { "@babel/runtime": "^7.11.1", "classnames": "^2.2.1", "rc-util": "^5.44.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-w+XTUrfh7ArbYEd2582uDrEhmBHwK1ZENJiSJVb7uRxdE7qJSYjbO2eksRXmndqyKqKoYPc9ClpPh5242mV1vA=="],
+
+    "rc-notification": ["rc-notification@5.6.4", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "2.x", "rc-motion": "^2.9.0", "rc-util": "^5.20.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-KcS4O6B4qzM3KH7lkwOB7ooLPZ4b6J+VMmQgT51VZCeEcmghdeR4IrMcFq0LG+RPdnbe/ArT086tGM8Snimgiw=="],
+
+    "rc-overflow": ["rc-overflow@1.4.1", "", { "dependencies": { "@babel/runtime": "^7.11.1", "classnames": "^2.2.1", "rc-resize-observer": "^1.0.0", "rc-util": "^5.37.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-3MoPQQPV1uKyOMVNd6SZfONi+f3st0r8PksexIdBTeIYbMX0Jr+k7pHEDvsXtR4BpCv90/Pv2MovVNhktKrwvw=="],
+
+    "rc-pagination": ["rc-pagination@5.1.0", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "^2.3.2", "rc-util": "^5.38.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-8416Yip/+eclTFdHXLKTxZvn70duYVGTvUUWbckCCZoIl3jagqke3GLsFrMs0bsQBikiYpZLD9206Ej4SOdOXQ=="],
+
+    "rc-picker": ["rc-picker@4.11.3", "", { "dependencies": { "@babel/runtime": "^7.24.7", "@rc-component/trigger": "^2.0.0", "classnames": "^2.2.1", "rc-overflow": "^1.3.2", "rc-resize-observer": "^1.4.0", "rc-util": "^5.43.0" }, "peerDependencies": { "date-fns": ">= 2.x", "dayjs": ">= 1.x", "luxon": ">= 3.x", "moment": ">= 2.x", "react": ">=16.9.0", "react-dom": ">=16.9.0" }, "optionalPeers": ["date-fns", "dayjs", "luxon", "moment"] }, "sha512-MJ5teb7FlNE0NFHTncxXQ62Y5lytq6sh5nUw0iH8OkHL/TjARSEvSHpr940pWgjGANpjCwyMdvsEV55l5tYNSg=="],
+
+    "rc-progress": ["rc-progress@4.0.0", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "^2.2.6", "rc-util": "^5.16.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-oofVMMafOCokIUIBnZLNcOZFsABaUw8PPrf1/y0ZBvKZNpOiu5h4AO9vv11Sw0p4Hb3D0yGWuEattcQGtNJ/aw=="],
+
+    "rc-rate": ["rc-rate@2.13.1", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "^2.2.5", "rc-util": "^5.0.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-QUhQ9ivQ8Gy7mtMZPAjLbxBt5y9GRp65VcUyGUMF3N3fhiftivPHdpuDIaWIMOTEprAjZPC08bls1dQB+I1F2Q=="],
+
+    "rc-resize-observer": ["rc-resize-observer@1.4.3", "", { "dependencies": { "@babel/runtime": "^7.20.7", "classnames": "^2.2.1", "rc-util": "^5.44.1", "resize-observer-polyfill": "^1.5.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-YZLjUbyIWox8E9i9C3Tm7ia+W7euPItNWSPX5sCcQTYbnwDb5uNpnLHQCG1f22oZWUhLw4Mv2tFmeWe68CDQRQ=="],
+
+    "rc-segmented": ["rc-segmented@2.7.0", "", { "dependencies": { "@babel/runtime": "^7.11.1", "classnames": "^2.2.1", "rc-motion": "^2.4.4", "rc-util": "^5.17.0" }, "peerDependencies": { "react": ">=16.0.0", "react-dom": ">=16.0.0" } }, "sha512-liijAjXz+KnTRVnxxXG2sYDGd6iLL7VpGGdR8gwoxAXy2KglviKCxLWZdjKYJzYzGSUwKDSTdYk8brj54Bn5BA=="],
+
+    "rc-select": ["rc-select@14.16.8", "", { "dependencies": { "@babel/runtime": "^7.10.1", "@rc-component/trigger": "^2.1.1", "classnames": "2.x", "rc-motion": "^2.0.1", "rc-overflow": "^1.3.1", "rc-util": "^5.16.1", "rc-virtual-list": "^3.5.2" }, "peerDependencies": { "react": "*", "react-dom": "*" } }, "sha512-NOV5BZa1wZrsdkKaiK7LHRuo5ZjZYMDxPP6/1+09+FB4KoNi8jcG1ZqLE3AVCxEsYMBe65OBx71wFoHRTP3LRg=="],
+
+    "rc-slider": ["rc-slider@11.1.8", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "^2.2.5", "rc-util": "^5.36.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-2gg/72YFSpKP+Ja5AjC5DPL1YnV8DEITDQrcc1eASrUYjl0esptaBVJBh5nLTXCCp15eD8EuGjwezVGSHhs9tQ=="],
+
+    "rc-steps": ["rc-steps@6.0.1", "", { "dependencies": { "@babel/runtime": "^7.16.7", "classnames": "^2.2.3", "rc-util": "^5.16.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-lKHL+Sny0SeHkQKKDJlAjV5oZ8DwCdS2hFhAkIjuQt1/pB81M0cA0ErVFdHq9+jmPmFw1vJB2F5NBzFXLJxV+g=="],
+
+    "rc-switch": ["rc-switch@4.1.0", "", { "dependencies": { "@babel/runtime": "^7.21.0", "classnames": "^2.2.1", "rc-util": "^5.30.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-TI8ufP2Az9oEbvyCeVE4+90PDSljGyuwix3fV58p7HV2o4wBnVToEyomJRVyTaZeqNPAp+vqeo4Wnj5u0ZZQBg=="],
+
+    "rc-table": ["rc-table@7.51.1", "", { "dependencies": { "@babel/runtime": "^7.10.1", "@rc-component/context": "^1.4.0", "classnames": "^2.2.5", "rc-resize-observer": "^1.1.0", "rc-util": "^5.44.3", "rc-virtual-list": "^3.14.2" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-5iq15mTHhvC42TlBLRCoCBLoCmGlbRZAlyF21FonFnS/DIC8DeRqnmdyVREwt2CFbPceM0zSNdEeVfiGaqYsKw=="],
+
+    "rc-tabs": ["rc-tabs@15.7.0", "", { "dependencies": { "@babel/runtime": "^7.11.2", "classnames": "2.x", "rc-dropdown": "~4.2.0", "rc-menu": "~9.16.0", "rc-motion": "^2.6.2", "rc-resize-observer": "^1.0.0", "rc-util": "^5.34.1" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-ZepiE+6fmozYdWf/9gVp7k56PKHB1YYoDsKeQA1CBlJ/POIhjkcYiv0AGP0w2Jhzftd3AVvZP/K+V+Lpi2ankA=="],
+
+    "rc-textarea": ["rc-textarea@1.10.2", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "^2.2.1", "rc-input": "~1.8.0", "rc-resize-observer": "^1.0.0", "rc-util": "^5.27.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-HfaeXiaSlpiSp0I/pvWpecFEHpVysZ9tpDLNkxQbMvMz6gsr7aVZ7FpWP9kt4t7DB+jJXesYS0us1uPZnlRnwQ=="],
+
+    "rc-tooltip": ["rc-tooltip@6.4.0", "", { "dependencies": { "@babel/runtime": "^7.11.2", "@rc-component/trigger": "^2.0.0", "classnames": "^2.3.1", "rc-util": "^5.44.3" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-kqyivim5cp8I5RkHmpsp1Nn/Wk+1oeloMv9c7LXNgDxUpGm+RbXJGL+OPvDlcRnx9DBeOe4wyOIl4OKUERyH1g=="],
+
+    "rc-tree": ["rc-tree@5.13.1", "", { "dependencies": { "@babel/runtime": "^7.10.1", "classnames": "2.x", "rc-motion": "^2.0.1", "rc-util": "^5.16.1", "rc-virtual-list": "^3.5.1" }, "peerDependencies": { "react": "*", "react-dom": "*" } }, "sha512-FNhIefhftobCdUJshO7M8uZTA9F4OPGVXqGfZkkD/5soDeOhwO06T/aKTrg0WD8gRg/pyfq+ql3aMymLHCTC4A=="],
+
+    "rc-tree-select": ["rc-tree-select@5.27.0", "", { "dependencies": { "@babel/runtime": "^7.25.7", "classnames": "2.x", "rc-select": "~14.16.2", "rc-tree": "~5.13.0", "rc-util": "^5.43.0" }, "peerDependencies": { "react": "*", "react-dom": "*" } }, "sha512-2qTBTzwIT7LRI1o7zLyrCzmo5tQanmyGbSaGTIf7sYimCklAToVVfpMC6OAldSKolcnjorBYPNSKQqJmN3TCww=="],
+
+    "rc-upload": ["rc-upload@4.9.2", "", { "dependencies": { "@babel/runtime": "^7.18.3", "classnames": "^2.2.5", "rc-util": "^5.2.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-nHx+9rbd1FKMiMRYsqQ3NkXUv7COHPBo3X1Obwq9SWS6/diF/A0aJ5OHubvwUAIDs+4RMleljV0pcrNUc823GQ=="],
+
+    "rc-util": ["rc-util@5.44.4", "", { "dependencies": { "@babel/runtime": "^7.18.3", "react-is": "^18.2.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-resueRJzmHG9Q6rI/DfK6Kdv9/Lfls05vzMs1Sk3M2P+3cJa+MakaZyWY8IPfehVuhPJFKrIY1IK4GqbiaiY5w=="],
+
+    "rc-virtual-list": ["rc-virtual-list@3.19.1", "", { "dependencies": { "@babel/runtime": "^7.20.0", "classnames": "^2.2.6", "rc-resize-observer": "^1.0.0", "rc-util": "^5.36.0" }, "peerDependencies": { "react": ">=16.9.0", "react-dom": ">=16.9.0" } }, "sha512-DCapO2oyPqmooGhxBuXHM4lFuX+sshQwWqqkuyFA+4rShLe//+GEPVwiDgO+jKtKHtbeYwZoNvetwfHdOf+iUQ=="],
+
+    "react": ["react@19.1.1", "", {}, "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ=="],
+
+    "react-dom": ["react-dom@19.1.1", "", { "dependencies": { "scheduler": "^0.26.0" }, "peerDependencies": { "react": "^19.1.1" } }, "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw=="],
+
+    "react-is": ["react-is@18.3.1", "", {}, "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg=="],
+
+    "react-markdown": ["react-markdown@9.0.3", "", { "dependencies": { "@types/hast": "^3.0.0", "devlop": "^1.0.0", "hast-util-to-jsx-runtime": "^2.0.0", "html-url-attributes": "^3.0.0", "mdast-util-to-hast": "^13.0.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" }, "peerDependencies": { "@types/react": ">=18", "react": ">=18" } }, "sha512-Yk7Z94dbgYTOrdk41Z74GoKA7rThnsbbqBTRYuxoe08qvfQ9tJVhmAKw6BJS/ZORG7kTy/s1QvYzSuaoBA1qfw=="],
+
+    "react-refresh": ["react-refresh@0.17.0", "", {}, "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ=="],
+
+    "react-router": ["react-router@7.8.0", "", { "dependencies": { "cookie": "^1.0.1", "set-cookie-parser": "^2.6.0" }, "peerDependencies": { "react": ">=18", "react-dom": ">=18" }, "optionalPeers": ["react-dom"] }, "sha512-r15M3+LHKgM4SOapNmsH3smAizWds1vJ0Z9C4mWaKnT9/wD7+d/0jYcj6LmOvonkrO4Rgdyp4KQ/29gWN2i1eg=="],
+
+    "refractor": ["refractor@4.9.0", "", { "dependencies": { "@types/hast": "^2.0.0", "@types/prismjs": "^1.0.0", "hastscript": "^7.0.0", "parse-entities": "^4.0.0" } }, "sha512-nEG1SPXFoGGx+dcjftjv8cAjEusIh6ED1xhf5DG3C0x/k+rmZ2duKnc3QLpt6qeHv5fPb8uwN3VWN2BT7fr3Og=="],
+
+    "rehype": ["rehype@13.0.2", "", { "dependencies": { "@types/hast": "^3.0.0", "rehype-parse": "^9.0.0", "rehype-stringify": "^10.0.0", "unified": "^11.0.0" } }, "sha512-j31mdaRFrwFRUIlxGeuPXXKWQxet52RBQRvCmzl5eCefn/KGbomK5GMHNMsOJf55fgo3qw5tST5neDuarDYR2A=="],
+
+    "rehype-attr": ["rehype-attr@3.0.3", "", { "dependencies": { "unified": "~11.0.0", "unist-util-visit": "~5.0.0" } }, "sha512-Up50Xfra8tyxnkJdCzLBIBtxOcB2M1xdeKe1324U06RAvSjYm7ULSeoM+b/nYPQPVd7jsXJ9+39IG1WAJPXONw=="],
+
+    "rehype-autolink-headings": ["rehype-autolink-headings@7.1.0", "", { "dependencies": { "@types/hast": "^3.0.0", "@ungap/structured-clone": "^1.0.0", "hast-util-heading-rank": "^3.0.0", "hast-util-is-element": "^3.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-rItO/pSdvnvsP4QRB1pmPiNHUskikqtPojZKJPPPAVx9Hj8i8TwMBhofrrAYRhYOOBZH9tgmG5lPqDLuIWPWmw=="],
+
+    "rehype-ignore": ["rehype-ignore@2.0.2", "", { "dependencies": { "hast-util-select": "^6.0.0", "unified": "^11.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-BpAT/3lU9DMJ2siYVD/dSR0A/zQgD6Fb+fxkJd4j+wDVy6TYbYpK+FZqu8eM9EuNKGvi4BJR7XTZ/+zF02Dq8w=="],
+
+    "rehype-parse": ["rehype-parse@9.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-from-html": "^2.0.0", "unified": "^11.0.0" } }, "sha512-ksCzCD0Fgfh7trPDxr2rSylbwq9iYDkSn8TCDmEJ49ljEUBxDVCzCHv7QNzZOfODanX4+bWQ4WZqLCRWYLfhag=="],
+
+    "rehype-prism-plus": ["rehype-prism-plus@2.0.1", "", { "dependencies": { "hast-util-to-string": "^3.0.0", "parse-numeric-range": "^1.3.0", "refractor": "^4.8.0", "rehype-parse": "^9.0.0", "unist-util-filter": "^5.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-Wglct0OW12tksTUseAPyWPo3srjBOY7xKlql/DPKi7HbsdZTyaLCAoO58QBKSczFQxElTsQlOY3JDOFzB/K++Q=="],
+
+    "rehype-raw": ["rehype-raw@7.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-raw": "^9.0.0", "vfile": "^6.0.0" } }, "sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww=="],
+
+    "rehype-rewrite": ["rehype-rewrite@4.0.2", "", { "dependencies": { "hast-util-select": "^6.0.0", "unified": "^11.0.3", "unist-util-visit": "^5.0.0" } }, "sha512-rjLJ3z6fIV11phwCqHp/KRo8xuUCO8o9bFJCNw5o6O2wlLk6g8r323aRswdGBQwfXPFYeSuZdAjp4tzo6RGqEg=="],
+
+    "rehype-slug": ["rehype-slug@6.0.0", "", { "dependencies": { "@types/hast": "^3.0.0", "github-slugger": "^2.0.0", "hast-util-heading-rank": "^3.0.0", "hast-util-to-string": "^3.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-lWyvf/jwu+oS5+hL5eClVd3hNdmwM1kAC0BUvEGD19pajQMIzcNUd/k9GsfQ+FfECvX+JE+e9/btsKH0EjJT6A=="],
+
+    "rehype-stringify": ["rehype-stringify@10.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "hast-util-to-html": "^9.0.0", "unified": "^11.0.0" } }, "sha512-k9ecfXHmIPuFVI61B9DeLPN0qFHfawM6RsuX48hoqlaKSF61RskNjSm1lI8PhBEM0MRdLxVVm4WmTqJQccH9mA=="],
+
+    "remark-gfm": ["remark-gfm@4.0.1", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-gfm": "^3.0.0", "micromark-extension-gfm": "^3.0.0", "remark-parse": "^11.0.0", "remark-stringify": "^11.0.0", "unified": "^11.0.0" } }, "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg=="],
+
+    "remark-github-blockquote-alert": ["remark-github-blockquote-alert@1.3.1", "", { "dependencies": { "unist-util-visit": "^5.0.0" } }, "sha512-OPNnimcKeozWN1w8KVQEuHOxgN3L4rah8geMOLhA5vN9wITqU4FWD+G26tkEsCGHiOVDbISx+Se5rGZ+D1p0Jg=="],
+
+    "remark-parse": ["remark-parse@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-from-markdown": "^2.0.0", "micromark-util-types": "^2.0.0", "unified": "^11.0.0" } }, "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA=="],
+
+    "remark-rehype": ["remark-rehype@11.1.2", "", { "dependencies": { "@types/hast": "^3.0.0", "@types/mdast": "^4.0.0", "mdast-util-to-hast": "^13.0.0", "unified": "^11.0.0", "vfile": "^6.0.0" } }, "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw=="],
+
+    "remark-stringify": ["remark-stringify@11.0.0", "", { "dependencies": { "@types/mdast": "^4.0.0", "mdast-util-to-markdown": "^2.0.0", "unified": "^11.0.0" } }, "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw=="],
+
+    "resize-observer-polyfill": ["resize-observer-polyfill@1.5.1", "", {}, "sha512-LwZrotdHOo12nQuZlHEmtuXdqGoOD0OhaxopaNFxWzInpEgaLWoVuAMbTzixuosCx2nEG58ngzW3vxdWoxIgdg=="],
+
+    "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
+
+    "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
+
+    "rollup": ["rollup@4.46.2", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.46.2", "@rollup/rollup-android-arm64": "4.46.2", "@rollup/rollup-darwin-arm64": "4.46.2", "@rollup/rollup-darwin-x64": "4.46.2", "@rollup/rollup-freebsd-arm64": "4.46.2", "@rollup/rollup-freebsd-x64": "4.46.2", "@rollup/rollup-linux-arm-gnueabihf": "4.46.2", "@rollup/rollup-linux-arm-musleabihf": "4.46.2", "@rollup/rollup-linux-arm64-gnu": "4.46.2", "@rollup/rollup-linux-arm64-musl": "4.46.2", "@rollup/rollup-linux-loongarch64-gnu": "4.46.2", "@rollup/rollup-linux-ppc64-gnu": "4.46.2", "@rollup/rollup-linux-riscv64-gnu": "4.46.2", "@rollup/rollup-linux-riscv64-musl": "4.46.2", "@rollup/rollup-linux-s390x-gnu": "4.46.2", "@rollup/rollup-linux-x64-gnu": "4.46.2", "@rollup/rollup-linux-x64-musl": "4.46.2", "@rollup/rollup-win32-arm64-msvc": "4.46.2", "@rollup/rollup-win32-ia32-msvc": "4.46.2", "@rollup/rollup-win32-x64-msvc": "4.46.2", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-WMmLFI+Boh6xbop+OAGo9cQ3OgX9MIg7xOQjn+pTCwOkk+FNDAeAemXkJ3HzDJrVXleLOFVa1ipuc1AmEx1Dwg=="],
+
+    "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
+
+    "scheduler": ["scheduler@0.26.0", "", {}, "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA=="],
+
+    "scroll-into-view-if-needed": ["scroll-into-view-if-needed@3.1.0", "", { "dependencies": { "compute-scroll-into-view": "^3.0.2" } }, "sha512-49oNpRjWRvnU8NyGVmUaYG4jtTkNonFZI86MmGRDqBphEK2EXT9gdEUoQPZhuBM8yWHxCWbobltqYO5M4XrUvQ=="],
+
+    "semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
+
+    "set-cookie-parser": ["set-cookie-parser@2.7.1", "", {}, "sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ=="],
+
+    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
+
+    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "space-separated-tokens": ["space-separated-tokens@2.0.2", "", {}, "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q=="],
+
+    "string-convert": ["string-convert@0.2.1", "", {}, "sha512-u/1tdPl4yQnPBjnVrmdLo9gtuLvELKsAoRapekWggdiQNvvvum+jYF329d84NAa660KQw7pB2n36KrIKVoXa3A=="],
+
+    "stringify-entities": ["stringify-entities@4.0.4", "", { "dependencies": { "character-entities-html4": "^2.0.0", "character-entities-legacy": "^3.0.0" } }, "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg=="],
+
+    "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
+
+    "style-to-js": ["style-to-js@1.1.17", "", { "dependencies": { "style-to-object": "1.0.9" } }, "sha512-xQcBGDxJb6jjFCTzvQtfiPn6YvvP2O8U1MDIPNfJQlWMYfktPy+iGsHE7cssjs7y84d9fQaK4UF3RIJaAHSoYA=="],
+
+    "style-to-object": ["style-to-object@1.0.9", "", { "dependencies": { "inline-style-parser": "0.2.4" } }, "sha512-G4qppLgKu/k6FwRpHiGiKPaPTFcG3g4wNVX/Qsfu+RqQM30E7Tyu/TEgxcL9PNLF5pdRLwQdE3YKKf+KF2Dzlw=="],
+
+    "stylis": ["stylis@4.3.6", "", {}, "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ=="],
+
+    "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "throttle-debounce": ["throttle-debounce@5.0.2", "", {}, "sha512-B71/4oyj61iNH0KeCamLuE2rmKuTO5byTOSVwECM5FA7TiAiAW+UqTKZ9ERueC4qvgSttUhdmq1mXC3kJqGX7A=="],
+
+    "tinyglobby": ["tinyglobby@0.2.14", "", { "dependencies": { "fdir": "^6.4.4", "picomatch": "^4.0.2" } }, "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ=="],
+
+    "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
+
+    "toggle-selection": ["toggle-selection@1.0.6", "", {}, "sha512-BiZS+C1OS8g/q2RRbJmy59xpyghNBqrr6k5L/uKBGRsTfxmu3ffiRnd8mlGPUVayg8pvfi5urfnu8TU7DVOkLQ=="],
+
+    "trim-lines": ["trim-lines@3.0.1", "", {}, "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg=="],
+
+    "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="],
+
+    "ts-api-utils": ["ts-api-utils@2.1.0", "", { "peerDependencies": { "typescript": ">=4.8.4" } }, "sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ=="],
+
+    "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="],
+
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
+
+    "typescript-eslint": ["typescript-eslint@8.39.1", "", { "dependencies": { "@typescript-eslint/eslint-plugin": "8.39.1", "@typescript-eslint/parser": "8.39.1", "@typescript-eslint/typescript-estree": "8.39.1", "@typescript-eslint/utils": "8.39.1" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <6.0.0" } }, "sha512-GDUv6/NDYngUlNvwaHM1RamYftxf782IyEDbdj3SeaIHHv8fNQVRC++fITT7kUJV/5rIA/tkoRSSskt6osEfqg=="],
+
+    "unified": ["unified@11.0.5", "", { "dependencies": { "@types/unist": "^3.0.0", "bail": "^2.0.0", "devlop": "^1.0.0", "extend": "^3.0.0", "is-plain-obj": "^4.0.0", "trough": "^2.0.0", "vfile": "^6.0.0" } }, "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA=="],
+
+    "unist-util-filter": ["unist-util-filter@5.0.1", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-pHx7D4Zt6+TsfwylH9+lYhBhzyhEnCXs/lbq/Hstxno5z4gVdyc2WEW0asfjGKPyG4pEKrnBv5hdkO6+aRnQJw=="],
+
+    "unist-util-is": ["unist-util-is@6.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw=="],
+
+    "unist-util-position": ["unist-util-position@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA=="],
+
+    "unist-util-stringify-position": ["unist-util-stringify-position@4.0.0", "", { "dependencies": { "@types/unist": "^3.0.0" } }, "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ=="],
+
+    "unist-util-visit": ["unist-util-visit@5.0.0", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0", "unist-util-visit-parents": "^6.0.0" } }, "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg=="],
+
+    "unist-util-visit-parents": ["unist-util-visit-parents@6.0.1", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-is": "^6.0.0" } }, "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw=="],
+
+    "update-browserslist-db": ["update-browserslist-db@1.1.3", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw=="],
+
+    "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
+
+    "vfile": ["vfile@6.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile-message": "^4.0.0" } }, "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q=="],
+
+    "vfile-location": ["vfile-location@5.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "vfile": "^6.0.0" } }, "sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg=="],
+
+    "vfile-message": ["vfile-message@4.0.3", "", { "dependencies": { "@types/unist": "^3.0.0", "unist-util-stringify-position": "^4.0.0" } }, "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw=="],
+
+    "vite": ["vite@7.1.2", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.6", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.14" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-J0SQBPlQiEXAF7tajiH+rUooJPo0l8KQgyg4/aMunNtrOa7bwuZJsJbDWzeljqQpgftxuq5yNJxQ91O9ts29UQ=="],
+
+    "web-namespaces": ["web-namespaces@2.0.1", "", {}, "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ=="],
+
+    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
+
+    "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
+
+    "yallist": ["yallist@3.1.1", "", {}, "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g=="],
+
+    "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
+
+    "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
+
+    "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
+
+    "@eslint/eslintrc/globals": ["globals@14.0.0", "", {}, "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ=="],
+
+    "@humanfs/node/@humanwhocodes/retry": ["@humanwhocodes/retry@0.3.1", "", {}, "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA=="],
+
+    "@typescript-eslint/eslint-plugin/ignore": ["ignore@7.0.5", "", {}, "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg=="],
+
+    "@typescript-eslint/typescript-estree/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="],
+
+    "@typescript-eslint/typescript-estree/semver": ["semver@7.7.2", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="],
+
+    "@uiw/react-markdown-preview/rehype-prism-plus": ["rehype-prism-plus@2.0.0", "", { "dependencies": { "hast-util-to-string": "^3.0.0", "parse-numeric-range": "^1.3.0", "refractor": "^4.8.0", "rehype-parse": "^9.0.0", "unist-util-filter": "^5.0.0", "unist-util-visit": "^5.0.0" } }, "sha512-FeM/9V2N7EvDZVdR2dqhAzlw5YI49m9Tgn7ZrYJeYHIahM6gcXpH0K1y2gNnKanZCydOMluJvX2cB9z3lhY8XQ=="],
+
+    "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+
+    "hast-util-from-parse5/hastscript": ["hastscript@9.0.1", "", { "dependencies": { "@types/hast": "^3.0.0", "comma-separated-tokens": "^2.0.0", "hast-util-parse-selector": "^4.0.0", "property-information": "^7.0.0", "space-separated-tokens": "^2.0.0" } }, "sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w=="],
+
+    "hast-util-parse-selector/@types/hast": ["@types/hast@2.3.10", "", { "dependencies": { "@types/unist": "^2" } }, "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw=="],
+
+    "hast-util-to-parse5/property-information": ["property-information@6.5.0", "", {}, "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig=="],
+
+    "hastscript/@types/hast": ["@types/hast@2.3.10", "", { "dependencies": { "@types/unist": "^2" } }, "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw=="],
+
+    "hastscript/property-information": ["property-information@6.5.0", "", {}, "sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig=="],
+
+    "mdast-util-find-and-replace/escape-string-regexp": ["escape-string-regexp@5.0.0", "", {}, "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw=="],
+
+    "micromatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="],
+
+    "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "refractor/@types/hast": ["@types/hast@2.3.10", "", { "dependencies": { "@types/unist": "^2" } }, "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw=="],
+
+    "@typescript-eslint/typescript-estree/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="],
+
+    "hast-util-from-parse5/hastscript/hast-util-parse-selector": ["hast-util-parse-selector@4.0.0", "", { "dependencies": { "@types/hast": "^3.0.0" } }, "sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A=="],
+
+    "hast-util-parse-selector/@types/hast/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "hastscript/@types/hast/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+
+    "refractor/@types/hast/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
+  }
+}

web/eslint.config.js

@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { globalIgnores } from 'eslint/config'
+
+export default tseslint.config([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs['recommended-latest'],
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])

web/index.html

@@ -0,0 +1,15 @@
+<!doctype html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Foxel</title>
+</head>
+
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+
+</html>

web/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "web",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@ant-design/icons": "5.x",
+    "@ant-design/v5-patch-for-react-19": "^1.0.3",
+    "@uiw/react-md-editor": "^4.0.8",
+    "antd": "^5.27.0",
+    "date-fns": "^4.1.0",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "react-router": "^7.8.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.33.0",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "@vitejs/plugin-react": "^5.0.0",
+    "eslint": "^9.33.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "globals": "^16.3.0",
+    "typescript": "~5.8.3",
+    "typescript-eslint": "^8.39.1",
+    "vite": "^7.1.2"
+  }
+}

web/src/App.tsx

@@ -0,0 +1,54 @@
+import { useState, useEffect } from 'react';
+import { AppRouter } from './router/index.tsx';
+import { AuthProvider } from './contexts/AuthContext.tsx';
+import { status as getStatus } from './api/config.ts';
+import type { SystemStatus } from './api/config.ts';
+import { SystemContext } from './contexts/SystemContext.tsx';
+import { Spin } from 'antd';
+import { Routes, Route, Navigate } from 'react-router';
+import SetupPage from './pages/SetupPage.tsx';
+
+function App() {
+  const [status, setStatus] = useState<SystemStatus | null>(null);
+  useEffect(() => {
+    async function checkInitialization() {
+      try {
+        const status = await getStatus();
+        setStatus(status);
+        document.title = status.title;
+        const favicon = document.querySelector("link[rel*='icon']") as HTMLLinkElement;
+        if (favicon) {
+          favicon.href = status.logo;
+        }
+      } catch (error) {
+        console.error("Failed to check initialization status:", error);
+      }
+    }
+    checkInitialization();
+  }, []);
+
+  if (status === null) {
+    return (
+      <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100vh' }}>
+        <Spin size="large" />
+      </div>
+    );
+  }
+
+  return (
+    <SystemContext.Provider value={status}>
+      <AuthProvider>
+        {!status.is_initialized ? (
+          <Routes>
+            <Route path="/setup" element={<SetupPage />} />
+            <Route path="*" element={<Navigate to="/setup" replace />} />
+          </Routes>
+        ) : (
+          <AppRouter />
+        )}
+      </AuthProvider>
+    </SystemContext.Provider>
+  );
+}
+
+export default App;

web/src/api/adapters.ts

@@ -0,0 +1,34 @@
+import request from './client';
+
+export interface AdapterItem {
+  id: number;
+  name: string;
+  type: string;
+  config: any;
+  enabled: boolean;
+  mount_path?: string | null;
+  sub_path?: string | null;
+}
+
+export interface AdapterTypeField {
+  key: string;
+  label: string;
+  type: 'string' | 'password' | 'number';
+  required?: boolean;
+  placeholder?: string;
+  default?: any;
+}
+
+export interface AdapterTypeMeta {
+  type: string;
+  name: string;
+  config_schema: AdapterTypeField[];
+}
+
+export const adaptersApi = {
+  list: () => request<AdapterItem[]>('/adapters'),
+  create: (payload: Omit<AdapterItem, 'id'>) => request<AdapterItem>('/adapters', { method: 'POST', json: payload }),
+  update: (id: number, payload: Omit<AdapterItem, 'id'>) => request<AdapterItem>(`/adapters/${id}`, { method: 'PUT', json: payload }),
+  remove: (id: number) => request<void>(`/adapters/${id}`, { method: 'DELETE' }),
+  available: () => request<AdapterTypeMeta[]>('/adapters/available'),
+};

web/src/api/auth.ts

@@ -0,0 +1,45 @@
+import request from './client';
+
+export interface LoginPayload {
+  username: string;
+  password: string;
+}
+
+export interface RegisterPayload {
+  username: string;
+  password: string;
+  email?: string;
+  full_name?: string;
+}
+
+export interface AuthResponse {
+  access_token: string;
+  token_type: string;
+}
+
+export const authApi = {
+  register: async (username: string, password: string, email?: string, full_name?: string): Promise<any> => {
+    return request('/auth/register', {
+      method: 'POST',
+      json: { username, password, email, full_name },
+    });
+  },
+  login: async (payload: LoginPayload) => {
+    const form = new URLSearchParams();
+    form.append('username', payload.username);
+    form.append('password', payload.password);
+    try {
+      return await request<AuthResponse>('/auth/login', {
+        method: 'POST',
+        body: form,
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+      });
+    } catch (e) {
+      console.error('[authApi.login] error:', e);
+      throw e;
+    }
+  },
+  logout: () => {
+    localStorage.removeItem('token');
+  },
+};

web/src/api/backup.ts

@@ -0,0 +1,38 @@
+import request from './client';
+
+export const backupApi = {
+  export: async () => {
+    const response = await request('/backup/export', {
+      method: 'GET',
+      rawResponse: true,
+    }) as Response;
+
+    const contentDisposition = response.headers.get('content-disposition');
+    let filename = 'backup.json';
+    if (contentDisposition) {
+      const filenameMatch = contentDisposition.match(/filename="?(.+)"?/);
+      if (filenameMatch && filenameMatch.length > 1) {
+        filename = filenameMatch[1];
+      }
+    }
+
+    const blob = await response.blob();
+    const url = window.URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.setAttribute('download', filename);
+    document.body.appendChild(link);
+    link.click();
+    link.remove();
+    window.URL.revokeObjectURL(url);
+  },
+
+  import: async (file: File) => {
+    const formData = new FormData();
+    formData.append('file', file);
+    return request('/backup/import', {
+      method: 'POST',
+      body: formData,
+    });
+  },
+};

web/src/api/client.ts

@@ -0,0 +1,76 @@
+export interface RequestOptions extends RequestInit {
+  json?: any;
+  formData?: FormData;
+  text?: string;
+  rawResponse?: boolean;
+}
+const BASE_URL = import.meta.env.PROD ? '/api' : 'http://127.0.0.1:8000/api';
+export const API_BASE_URL = BASE_URL;
+
+async function request<T = any>(url: string, options: RequestOptions = {}): Promise<T> {
+  const { json, formData, text, rawResponse, headers, ...rest } = options;
+  const finalHeaders: Record<string, string> = {
+    ...(headers as Record<string, string> || {})
+  };
+
+  const token = localStorage.getItem('token');
+  if (token) {
+    finalHeaders['Authorization'] = `Bearer ${token}`;
+  }
+
+  let body: BodyInit | undefined;
+  if (json !== undefined) {
+    body = JSON.stringify(json);
+    finalHeaders['Content-Type'] = 'application/json';
+  } else if (formData) {
+    body = formData; 
+  } else if (text !== undefined) {
+    body = text;
+    finalHeaders['Content-Type'] = 'text/plain;charset=utf-8';
+  } else if ((rest as any).body !== undefined) {
+    body = (rest as any).body;
+    delete (rest as any).body;
+  }
+
+  const resp = await fetch(BASE_URL + url, {
+    ...rest,
+    headers: finalHeaders,
+    body,
+  });
+
+  if (rawResponse) return resp as any;
+
+  if (!resp.ok) {
+    let errMsg = resp.statusText;
+    try {
+      const data = await resp.json();
+      if (Array.isArray(data?.detail)) {
+        errMsg = data.detail.map((e: any) => e.msg || JSON.stringify(e)).join('; ');
+      } else {
+        errMsg = (typeof data?.detail === 'string') ? data.detail : (data.detail ? JSON.stringify(data.detail) : JSON.stringify(data));
+      }
+    } catch (_) { }
+    throw new Error(errMsg || `Request failed: ${resp.status}`);
+  }
+
+  const contentType = resp.headers.get('content-type') || '';
+  if (contentType.includes('application/json')) {
+    const json = await resp.json();
+    if (json && typeof json === 'object' && 'code' in json && ('msg' in json || 'message' in json)) {
+      if (json.code !== 0) {
+        throw new Error(json.msg || json.message || 'Error');
+      }
+      return json.data as T;
+    }
+    return json;
+  }
+  if (contentType.startsWith('text/')) {
+    return await resp.text() as any;
+  }
+  return await resp.arrayBuffer() as any;
+}
+
+export { vfsApi, type VfsEntry, type DirListing } from './vfs';
+export { adaptersApi, type AdapterItem, type AdapterTypeField, type AdapterTypeMeta } from './adapters';
+export { shareApi } from './share';
+export default request;

web/src/api/config.ts

@@ -0,0 +1,27 @@
+import request from './client';
+
+export async function getConfig(key: string) {
+  return request<{ key: string; value: string }>('/config?key=' + encodeURIComponent(key));
+}
+
+export async function setConfig(key: string, value: string) {
+  const form = new FormData();
+  form.append('key', key);
+  form.append('value', value);
+  return request('/config', { method: 'POST', formData: form });
+}
+
+export async function getAllConfig() {
+  return request<Record<string, string>>('/config/all');
+}
+
+export interface SystemStatus {
+  version: string;
+  title: string;
+  logo: string;
+  is_initialized: boolean;
+}
+
+export async function status() {
+  return request<SystemStatus>('/config/status');
+}

web/src/api/logs.ts

@@ -0,0 +1,54 @@
+import request from './client';
+
+export interface LogItem {
+  id: number;
+  timestamp: string;
+  level: string;
+  source: string;
+  message: string;
+  details: Record<string, any>;
+  user_id?: number;
+}
+
+export interface PaginatedLogs {
+  items: LogItem[];
+  total: number;
+  page: number;
+  page_size: number;
+  pages: number;
+}
+
+export interface GetLogsParams {
+  page?: number;
+  page_size?: number;
+  level?: string;
+  source?: string;
+  start_time?: string;
+  end_time?: string;
+}
+
+export interface ClearLogsParams {
+  start_time?: string;
+  end_time?: string;
+}
+
+export const logsApi = {
+  list: (params: GetLogsParams = {}) => {
+    const query = new URLSearchParams();
+    if (params.page) query.append('page', params.page.toString());
+    if (params.page_size) query.append('page_size', params.page_size.toString());
+    if (params.level) query.append('level', params.level);
+    if (params.source) query.append('source', params.source);
+    if (params.start_time) query.append('start_time', params.start_time);
+    if (params.end_time) query.append('end_time', params.end_time);
+    return request<PaginatedLogs>(`/logs?${query.toString()}`);
+  },
+  clear: (params: ClearLogsParams = {}) => {
+    const query = new URLSearchParams();
+    if (params.start_time) query.append('start_time', params.start_time);
+    if (params.end_time) query.append('end_time', params.end_time);
+    return request<{ deleted_count: number }>(`/logs?${query.toString()}`, {
+      method: 'DELETE',
+    });
+  },
+};

web/src/api/processors.ts

@@ -0,0 +1,39 @@
+import request from './client';
+
+export interface ProcessorTypeField {
+  key: string;
+  label: string;
+  type: 'string' | 'password' | 'number' | 'select';
+  required?: boolean;
+  placeholder?: string;
+  default?: any;
+  options?: { label: string; value: string | number }[];
+}
+
+export interface ProcessorTypeMeta {
+  type: string;
+  name: string;
+  supported_exts: string[];
+  config_schema: ProcessorTypeField[];
+  produces_file:boolean;
+}
+
+export const processorsApi = {
+  list: () => request<ProcessorTypeMeta[]>('/processors', {
+    method: 'GET'
+  }),
+  process: (params: {
+    path: string;
+    processor_type: string;
+    config: any;
+    save_to?: string;
+    overwrite?: boolean;
+  }) =>
+    request<any>('/processors/process', {
+      method: 'POST',
+      body: JSON.stringify(params),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }),
+};

web/src/api/share.ts

@@ -0,0 +1,39 @@
+import request, { API_BASE_URL } from './client';
+import type { DirListing } from './vfs';
+
+export interface ShareInfo {
+  id: number;
+  token: string;
+  name: string;
+  paths: string[];
+  created_at: string;
+  expires_at?: string;
+  access_type: 'public' | 'password';
+}
+
+export interface ShareCreatePayload {
+  name: string;
+  paths: string[];
+  expires_in_days?: number;
+  access_type: 'public' | 'password';
+  password?: string;
+}
+
+export const shareApi = {
+  create: (payload: ShareCreatePayload) => request<ShareInfo>('/shares', { method: 'POST', json: payload }),
+  list: () => request<ShareInfo[]>('/shares'),
+  remove: (shareId: number) => request<void>(`/shares/${shareId}`, { method: 'DELETE' }),
+  get: (token: string) => request<ShareInfo>(`/s/${token}`),
+  verifyPassword: (token: string, password: string) => request<void>(`/s/${token}/verify`, { method: 'POST', json: { password } }),
+  listDir: (token: string, path: string = '/', password?: string) => {
+    const params: Record<string, string> = { path };
+    if (password) {
+      params.password = password;
+    }
+    return request<DirListing>(`/s/${token}/ls?${new URLSearchParams(params)}`);
+  },
+  downloadUrl: (token: string, path: string, password?: string) => {
+    const url = `${API_BASE_URL}/s/${token}/download?path=${encodeURIComponent(path)}`;
+    return password ? `${url}&password=${encodeURIComponent(password)}` : url;
+  },
+};

web/src/api/tasks.ts

@@ -0,0 +1,22 @@
+import request from './client';
+
+export interface AutomationTask {
+  id: number;
+  name: string;
+  event: string;
+  path_pattern?: string;
+  filename_regex?: string;
+  processor_type: string;
+  processor_config: Record<string, any>;
+  enabled: boolean;
+}
+
+export type AutomationTaskCreate = Omit<AutomationTask, 'id'>;
+export type AutomationTaskUpdate = Partial<AutomationTaskCreate>;
+
+export const tasksApi = {
+  list: () => request<AutomationTask[]>('/tasks/'),
+  create: (payload: AutomationTaskCreate) => request<AutomationTask>('/tasks', { method: 'POST', json: payload }),
+  update: (id: number, payload: AutomationTaskUpdate) => request<AutomationTask>(`/tasks/${id}`, { method: 'PUT', json: payload }),
+  remove: (id: number) => request<void>(`/tasks/${id}`, { method: 'DELETE' }),
+};

web/src/api/vfs.ts

@@ -0,0 +1,92 @@
+import request, { API_BASE_URL } from './client';
+
+export interface VfsEntry {
+  name: string;
+  is_dir: boolean;
+  size: number;
+  mtime: number;
+  type?: string; 
+  is_image?: boolean;
+}
+
+export interface DirListing {
+  path: string;
+  entries: VfsEntry[];
+  pagination?: {
+    total: number;
+    page: number;
+    page_size: number;
+    pages: number;
+  };
+}
+
+export interface SearchResultItem {
+  id: number;
+  path: string;
+  score: number;
+}
+
+export const vfsApi = {
+  list: (path: string, page: number = 1, pageSize: number = 50) => {
+    const cleaned = path.replace(/\\/g, '/');
+    const trimmed = cleaned === '/' ? '' : cleaned.replace(/^\/+/, '');
+    const params = new URLSearchParams({
+      page: page.toString(),
+      page_size: pageSize.toString()
+    });
+    return request<DirListing>(`/fs/${encodeURI(trimmed)}?${params}`);
+  },
+  readFile: (path: string) => request<ArrayBuffer>(`/fs/file/${encodeURI(path.replace(/^\/+/, ''))}`),
+  uploadFile: (fullPath: string, file: File | Blob) => {
+    const fd = new FormData();
+    fd.append('file', file);
+    return request(`/fs/file/${encodeURI(fullPath.replace(/^\/+/, ''))}`, { method: 'POST', formData: fd });
+  },
+  mkdir: (path: string) => request('/fs/mkdir', { method: 'POST', json: { path } }),
+  deletePath: (path: string) => request(`/fs/${encodeURI(path.replace(/^\/+/, ''))}`, { method: 'DELETE' }),
+  move: (src: string, dst: string) => request('/fs/move', { method: 'POST', json: { src, dst } }),
+  rename: (src: string, dst: string) => request('/fs/rename', { method: 'POST', json: { src, dst } }),
+  thumb: (path: string, w=256, h=256, fit='cover') =>
+    request<ArrayBuffer>(`/fs/thumb/${encodeURI(path.replace(/^\/+/, ''))}?w=${w}&h=${h}&fit=${fit}`),
+  streamUrl: (path: string) => `${API_BASE_URL}/fs/stream/${encodeURI(path.replace(/^\/+/, ''))}`,
+  stat: (path: string) => request(`/fs/stat/${encodeURI(path.replace(/^\/+/, ''))}`),
+  getTempLinkToken: (path: string) => request<{token: string}>(`/fs/temp-link/${encodeURI(path.replace(/^\/+/, ''))}`),
+  getTempPublicUrl: (token: string) => `${API_BASE_URL}/fs/public/${token}`,
+  uploadStream: (fullPath: string, file: File, overwrite: boolean = true, onProgress?: (loaded: number, total: number) => void) => {
+    const enc = encodeURI(fullPath.replace(/^\/+/, ''));
+    return new Promise<any>((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.open('POST', `${API_BASE_URL}/fs/upload/${enc}?overwrite=${overwrite}`);
+      const token = localStorage.getItem('token');
+      if (token) xhr.setRequestHeader('Authorization', `Bearer ${token}`);
+      xhr.upload.onprogress = (ev) => {
+        if (ev.lengthComputable && onProgress) onProgress(ev.loaded, ev.total);
+      };
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState === 4) {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            try {
+              const json = JSON.parse(xhr.responseText);
+              if (json.code === 0) return resolve(json.data);
+              return reject(new Error(json.msg || json.message || 'Upload failed'));
+            } catch (e) {
+              return reject(new Error('Invalid response'));
+            }
+          } else {
+            let err = 'Upload failed';
+            try {
+              const json = JSON.parse(xhr.responseText);
+              err = json.detail || json.msg || json.message || err;
+            } catch (_) {}
+            reject(new Error(err));
+          }
+        }
+      };
+      const fd = new FormData();
+      fd.append('file', file);
+      xhr.send(fd);
+    });
+  },
+  searchFiles: (q: string, top_k: number = 10, mode: 'vector' | 'filename' = 'vector') =>
+    request<{ items: SearchResultItem[]; query: string }>(`/search?q=${encodeURIComponent(q)}&top_k=${top_k}&mode=${mode}`),
+};

web/src/apps/AppWindowsLayer.tsx

@@ -0,0 +1,347 @@
+import React, { useRef, useEffect, useCallback } from 'react';
+import { Space, Button } from 'antd';
+import { FullscreenExitOutlined, FullscreenOutlined, CloseOutlined } from '@ant-design/icons';
+import type { AppDescriptor, AppComponentProps } from './types';
+import type { VfsEntry } from '../api/client';
+
+export interface AppWindowItem {
+  id: string;
+  app: AppDescriptor;
+  entry: VfsEntry;
+  filePath: string;
+  maximized: boolean;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+interface AppWindowsLayerProps {
+  windows: AppWindowItem[];
+  onClose: (id: string) => void;
+  onToggleMax: (id: string) => void;
+  onBringToFront: (id: string) => void;
+  onUpdateWindow: (id: string, patch: Partial<AppWindowItem>) => void;
+}
+
+export const AppWindowsLayer: React.FC<AppWindowsLayerProps> = ({ windows, onClose, onToggleMax, onBringToFront, onUpdateWindow }) => {
+  const dragRef = useRef<{
+    id: string;
+    startX: number;
+    startY: number;
+    originX: number;
+    originY: number;
+    newX: number;
+    newY: number;
+  } | null>(null);
+  const resizeRef = useRef<{
+    id: string;
+    dir: string;
+    startX: number;
+    startY: number;
+    origin: { x: number; y: number; w: number; h: number };
+    newX: number;
+    newY: number;
+    newW: number;
+    newH: number;
+  } | null>(null);
+
+  const windowEls = useRef<Record<string, HTMLDivElement | null>>({});
+
+  const onMouseMove = useCallback((e: MouseEvent) => {
+    if (dragRef.current) {
+      const { id, startX, startY, originX, originY } = dragRef.current;
+      const dx = e.clientX - startX;
+      const dy = e.clientY - startY;
+      let newX = Math.max(0, originX + dx);
+      let newY = Math.max(48, originY + dy);
+      dragRef.current.newX = newX;
+      dragRef.current.newY = newY;
+      const el = windowEls.current[id];
+      if (el) {
+        el.style.left = newX + 'px';
+        el.style.top = newY + 'px';
+      }
+      return;
+    }
+    if (resizeRef.current) {
+      const { id, dir, startX, startY, origin } = resizeRef.current;
+      let { x, y, w, h } = { x: origin.x, y: origin.y, w: origin.w, h: origin.h };
+      const dx = e.clientX - startX;
+      const dy = e.clientY - startY;
+      const minW = 360;
+      const minH = 240;
+      if (dir.includes('e')) w = Math.max(minW, origin.w + dx);
+      if (dir.includes('s')) h = Math.max(minH, origin.h + dy);
+      if (dir.includes('w')) { w = Math.max(minW, origin.w - dx); x = origin.x + (origin.w - w); }
+      if (dir.includes('n')) { h = Math.max(minH, origin.h - dy); y = origin.y + (origin.h - h); }
+      const vw = window.innerWidth;
+      const vh = window.innerHeight;
+      x = Math.min(Math.max(0, x), vw - 100);
+      y = Math.min(Math.max(0, y), vh - 60);
+      resizeRef.current.newX = x;
+      resizeRef.current.newY = y;
+      resizeRef.current.newW = w;
+      resizeRef.current.newH = h;
+      const el = windowEls.current[id];
+      if (el) {
+        el.style.left = x + 'px';
+        el.style.top = y + 'px';
+        el.style.width = w + 'px';
+        el.style.height = h + 'px';
+      }
+    }
+  }, []);
+
+  const onMouseUp = useCallback(() => {
+    if (dragRef.current) {
+      const { id, newX, newY, originX, originY } = dragRef.current;
+      if (newX !== undefined && newY !== undefined && (newX !== originX || newY !== originY)) {
+        onUpdateWindow(id, { x: newX, y: newY });
+      }
+      dragRef.current = null;
+    }
+    if (resizeRef.current) {
+      const { id, newX, newY, newW, newH } = resizeRef.current;
+      if (newW && newH) {
+        onUpdateWindow(id, { x: newX, y: newY, width: newW, height: newH });
+      }
+      resizeRef.current = null;
+    }
+  }, [onUpdateWindow]);
+
+  useEffect(() => {
+    window.addEventListener('mousemove', onMouseMove);
+    window.addEventListener('mouseup', onMouseUp);
+    return () => {
+      window.removeEventListener('mousemove', onMouseMove);
+      window.removeEventListener('mouseup', onMouseUp);
+    };
+  }, [onMouseMove, onMouseUp]);
+
+  const startDrag = (e: React.MouseEvent, w: AppWindowItem) => {
+    if (e.detail === 2) return; 
+    if (w.maximized) return;
+    if ((e.target as HTMLElement).closest('button')) return;
+    onBringToFront(w.id);
+    dragRef.current = {
+      id: w.id,
+      startX: e.clientX,
+      startY: e.clientY,
+      originX: w.x,
+      originY: w.y,
+      newX: w.x,
+      newY: w.y
+    };
+  };
+
+  const startResize = (e: React.MouseEvent, w: AppWindowItem, dir: string) => {
+    e.stopPropagation();
+    if (w.maximized) return;
+    onBringToFront(w.id);
+    resizeRef.current = {
+      id: w.id,
+      dir,
+      startX: e.clientX,
+      startY: e.clientY,
+      origin: { x: w.x, y: w.y, w: w.width, h: w.height },
+      newX: w.x,
+      newY: w.y,
+      newW: w.width,
+      newH: w.height
+    };
+  };
+
+  const isInteracting = (id: string) =>
+    dragRef.current?.id === id || resizeRef.current?.id === id;
+
+  const resizeHandles = (w: AppWindowItem) => {
+    const dirs = ['n','s','e','w','ne','nw','se','sw'];
+    const cursorMap: Record<string,string> = {
+      n:'ns-resize', s:'ns-resize', e:'ew-resize', w:'ew-resize',
+      ne:'nesw-resize', sw:'nesw-resize', nw:'nwse-resize', se:'nwse-resize'
+    };
+    const posStyle: Record<string, React.CSSProperties> = {
+      n:{ top:0, left:'50%', transform:'translate(-50%, -50%)', width:'calc(100% - 28px)', height:10 },
+      s:{ bottom:0, left:'50%', transform:'translate(-50%, 50%)', width:'calc(100% - 28px)', height:10 },
+      e:{ right:0, top:'50%', transform:'translate(50%,-50%)', width:10, height:'calc(100% - 28px)' },
+      w:{ left:0, top:'50%', transform:'translate(-50%, -50%)', width:10, height:'calc(100% - 28px)' },
+      ne:{ top:0, right:0, transform:'translate(50%,-50%)', width:14, height:14 },
+      nw:{ top:0, left:0, transform:'translate(-50%,-50%)', width:14, height:14 },
+      se:{ bottom:0, right:0, transform:'translate(50%,50%)', width:14, height:14 },
+      sw:{ bottom:0, left:0, transform:'translate(-50%,50%)', width:14, height:14 }
+    };
+    return dirs.map(d => (
+      <div
+        key={d}
+        onMouseDown={e => startResize(e, w, d)}
+        style={{
+          position:'absolute',
+          ...posStyle[d],
+          cursor: cursorMap[d],
+          zIndex: 10,
+          borderRadius: 4,
+          background: 'transparent'
+        }}
+      />
+    ));
+  };
+
+  return (
+    <>
+      {windows.map((w, idx) => {
+        const AppComp = w.app.component as React.FC<AppComponentProps>;
+        const useSystemWindow = w.app.useSystemWindow !== false; // 默认为 true
+        if (!useSystemWindow) {
+          return (
+            <div
+              key={w.id}
+              ref={el => { windowEls.current[w.id] = el; }}
+              style={{
+                position: 'fixed',
+                top: w.maximized ? 0 : w.y,
+                left: w.maximized ? 0 : w.x,
+                width: w.maximized ? '100vw' : w.width,
+                height: w.maximized ? '100vh' : w.height,
+                background: 'transparent',
+                border: 'none',
+                borderRadius: 0,
+                boxShadow: 'none',
+                display: 'flex',
+                flexDirection: 'column',
+                overflow: 'hidden',
+                zIndex: 3000 + idx
+              }}
+            >
+              <div
+                style={{
+                  flex: 1,
+                  position: 'relative',
+                  overflow: 'hidden',
+                  background: 'transparent'
+                }}
+              >
+                <AppComp
+                  filePath={w.filePath}
+                  entry={w.entry}
+                  onRequestClose={() => onClose(w.id)}
+                />
+              </div>
+            </div>
+          );
+        }
+        // 否则继续使用系统窗口渲染（不改动原有逻辑）
+        const interacting = isInteracting(w.id);
+        return (
+          <div
+            key={w.id}
+            ref={el => { windowEls.current[w.id] = el; }}
+            onMouseDown={() => onBringToFront(w.id)}
+            style={{
+              position: 'fixed',
+              top: w.maximized ? 0 : w.y,     
+              left: w.maximized ? 0 : w.x,    
+              width: w.maximized ? '100vw' : w.width,
+              height: w.maximized ? '100vh' : w.height,
+              background: 'rgba(240, 242, 245, 0.7)', // Semi-transparent background
+              border: '1px solid rgba(255, 255, 255, 0.18)',
+              borderRadius: w.maximized ? 0 : 12,
+              boxShadow: w.maximized
+                ? 'none'
+                : interacting
+                  ? '0 20px 50px -12px rgba(0,0,0,0.35)'
+                  : '0 12px 32px -8px rgba(0,0,0,0.25)',
+              display: 'flex',
+              flexDirection: 'column',
+              overflow: 'hidden',
+              backdropFilter: 'blur(20px) saturate(180%)', // Enhanced blur effect
+              zIndex: 3000 + idx,
+              willChange: 'left,top,width,height',
+              transition: interacting ? 'none' : 'top .15s,left .15s,width .15s,height .15s,box-shadow .25s'
+            }}
+          >
+            <div
+              onMouseDown={(e) => startDrag(e, w)}
+              onDoubleClick={() => onToggleMax(w.id)}
+              style={{
+                height: 40,
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'space-between',
+                padding: '0 12px',
+                background: 'rgba(0, 0, 0, 0.25)', // Lighter, transparent title bar
+                borderBottom: '1px solid rgba(255, 255, 255, 0.1)',
+                color: '#333', // Darker text for readability
+                fontSize: 13,
+                fontWeight: 600,
+                letterSpacing: .2,
+                userSelect: 'none',
+                cursor: w.maximized ? 'default' : 'grab'
+              }}
+            >
+              <span
+                style={{
+                  overflow: 'hidden',
+                  textOverflow: 'ellipsis',
+                  whiteSpace: 'nowrap',
+                  paddingRight: 8,
+                  flex: 1
+                }}
+              >
+                {w.app.name} - {w.entry.name}
+              </span>
+              <Space size={4}>
+                <Button
+                  type="text"
+                  size="small"
+                  aria-label={w.maximized ? '还原' : '最大化'}
+                  icon={w.maximized ? <FullscreenExitOutlined /> : <FullscreenOutlined />}
+                  onClick={() => onToggleMax(w.id)}
+                  style={{
+                    color: '#555',
+                    width: 30,
+                    height: 30,
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center'
+                  }}
+                />
+                <Button
+                  type="text"
+                  size="small"
+                  danger
+                  aria-label="关闭"
+                  icon={<CloseOutlined />}
+                  onClick={() => onClose(w.id)}
+                  style={{
+                    color: '#ff4d4f',
+                    width: 30,
+                    height: 30,
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center'
+                  }}
+                />
+              </Space>
+            </div>
+            <div
+              style={{
+                flex: 1,
+                background: 'transparent', // Let the app's own background show through
+                position: 'relative',
+                overflow: 'hidden'
+              }}
+            >
+              {!w.maximized && resizeHandles(w)}
+              <AppComp
+                filePath={w.filePath}
+                entry={w.entry}
+                onRequestClose={() => onClose(w.id)}
+              />
+            </div>
+          </div>
+        );
+      })}
+    </>
+  );
+};

web/src/apps/ImageViewer/ImageViewer.tsx

@@ -0,0 +1,394 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { vfsApi } from '../../api/client';
+import type { AppComponentProps } from '../types';
+import { Spin, Typography, Button, Tooltip } from 'antd';
+import { ZoomInOutlined, ZoomOutOutlined, ReloadOutlined, CompressOutlined, CloseOutlined, RotateRightOutlined } from '@ant-design/icons';
+
+export const ImageViewerApp: React.FC<AppComponentProps> = ({ filePath, entry, onRequestClose }) => {
+  const [url, setUrl] = useState<string>();
+  const [loading, setLoading] = useState(true);
+  const [err, setErr] = useState<string>();
+  const [scale, setScale] = useState(1);
+  const [offset, setOffset] = useState({ x: 0, y: 0 });
+  const [isDragging, setIsDragging] = useState(false);
+  const [rotate, setRotate] = useState(0);
+  const imgRef = useRef<HTMLImageElement | null>(null);
+  const containerRef = useRef<HTMLDivElement | null>(null);
+  const lastPointer = useRef<{ x: number; y: number } | null>(null);
+  const lastDistance = useRef<number | null>(null);
+  const transitionRef = useRef(false);
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true); setErr(undefined);
+    vfsApi.getTempLinkToken(filePath.replace(/^\/+/, ''))
+      .then(res => {
+        if (cancelled) return;
+        const publicUrl = vfsApi.getTempPublicUrl(res.token);
+        setUrl(publicUrl);
+      })
+      .catch(e => !cancelled && setErr(e.message || '加载失败'))
+      .finally(() => !cancelled && setLoading(false));
+    return () => { cancelled = true; };
+  }, [filePath]);
+
+  useEffect(() => {
+    setScale(1);
+    setOffset({ x: 0, y: 0 });
+    setRotate(0);
+  }, [url]);
+
+  const clamp = (v: number, a: number, b: number) => Math.max(a, Math.min(b, v));
+  const applyOffset = (next: { x: number; y: number }) => {
+    setOffset(next);
+  };
+
+  const onMouseDown = (e: React.MouseEvent) => {
+    if (e.button !== 0) return;
+    e.preventDefault();
+    setIsDragging(true);
+    lastPointer.current = { x: e.clientX, y: e.clientY };
+    transitionRef.current = false;
+  };
+  const onMouseMove = (e: React.MouseEvent) => {
+    if (!isDragging || !lastPointer.current) return;
+    e.preventDefault();
+    const dx = e.clientX - lastPointer.current.x;
+    const dy = e.clientY - lastPointer.current.y;
+    lastPointer.current = { x: e.clientX, y: e.clientY };
+    applyOffset({ x: offset.x + dx, y: offset.y + dy });
+  };
+  const onMouseUp = () => {
+    setIsDragging(false);
+    lastPointer.current = null;
+  };
+
+  const onDoubleClick = (e: React.MouseEvent) => {
+    e.preventDefault();
+    const cont = containerRef.current;
+    const img = imgRef.current;
+    if (!cont || !img) return;
+    const rect = cont.getBoundingClientRect();
+    const cx = e.clientX - rect.left - rect.width / 2;
+    const cy = e.clientY - rect.top - rect.height / 2;
+
+    const nextScale = scale > 1.5 ? 1 : 2.5;
+    const ratio = nextScale / scale;
+    const nextOffset = { x: offset.x - cx * (ratio - 1), y: offset.y - cy * (ratio - 1) };
+    setScale(nextScale);
+    transitionRef.current = true;
+    setTimeout(() => transitionRef.current = false, 200);
+    applyOffset(nextOffset);
+  };
+
+  const onWheel = (e: React.WheelEvent) => {
+    e.preventDefault();
+    const delta = -e.deltaY;
+    const zoomFactor = delta > 0 ? 1.12 : 0.88;
+    const cont = containerRef.current;
+    if (!cont) return;
+    const rect = cont.getBoundingClientRect();
+    const cx = e.clientX - rect.left - rect.width / 2;
+    const cy = e.clientY - rect.top - rect.height / 2;
+
+    const nextScale = clamp(scale * zoomFactor, 0.5, 5);
+    const ratio = nextScale / scale;
+    const nextOffset = { x: offset.x - cx * (ratio - 1), y: offset.y - cy * (ratio - 1) };
+    setScale(nextScale);
+    transitionRef.current = true;
+    setTimeout(() => transitionRef.current = false, 120);
+    applyOffset(nextOffset);
+  };
+
+  const getTouchDistance = (t1: { clientX: number; clientY: number }, t2: { clientX: number; clientY: number }) =>
+    Math.hypot(t1.clientX - t2.clientX, t1.clientY - t2.clientY);
+  const onTouchStart = (e: React.TouchEvent) => {
+    if (e.touches.length === 1) {
+      const t = e.touches[0];
+      lastPointer.current = { x: t.clientX, y: t.clientY };
+    } else if (e.touches.length === 2) {
+      lastDistance.current = getTouchDistance(e.touches[0], e.touches[1]);
+    }
+    transitionRef.current = false;
+  };
+  const onTouchMove = (e: React.TouchEvent) => {
+    if (e.touches.length === 1 && lastPointer.current) {
+      const t = e.touches[0];
+      const dx = t.clientX - lastPointer.current.x;
+      const dy = t.clientY - lastPointer.current.y;
+      lastPointer.current = { x: t.clientX, y: t.clientY };
+      applyOffset({ x: offset.x + dx, y: offset.y + dy });
+    } else if (e.touches.length === 2 && lastDistance.current) {
+      const d = getTouchDistance(e.touches[0], e.touches[1]);
+      const ratio = d / lastDistance.current;
+      const nextScale = clamp(scale * ratio, 0.5, 5);
+      setScale(nextScale);
+      lastDistance.current = d;
+    }
+  };
+  const onTouchEnd = (e: React.TouchEvent) => {
+    if (e.touches.length === 0) {
+      lastPointer.current = null;
+      lastDistance.current = null;
+    }
+  };
+  const doZoom = (factor: number) => {
+    const nextScale = clamp(scale * factor, 0.5, 5);
+    setScale(nextScale);
+    transitionRef.current = true;
+    setTimeout(() => transitionRef.current = false, 120);
+    applyOffset(offset);
+  };
+  const resetView = () => {
+    setScale(1);
+    setOffset({ x: 0, y: 0 });
+    setRotate(0);
+    transitionRef.current = true;
+    setTimeout(() => transitionRef.current = false, 150);
+  };
+  const fitToContainer = () => {
+    setScale(1);
+    setOffset({ x: 0, y: 0 });
+    setRotate(0);
+    transitionRef.current = true;
+    setTimeout(() => transitionRef.current = false, 150);
+  };
+  const doRotate = () => {
+    setRotate(r => (r + 90) % 360);
+    transitionRef.current = true;
+    setTimeout(() => transitionRef.current = false, 180);
+  };
+
+  if (loading) {
+    return (
+      <div style={{
+        width: '100%',
+        height: '100%',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        background: 'rgba(20,20,20,0.8)',
+        backdropFilter: 'blur(24px)'
+      }}>
+        <Spin />
+      </div>
+    );
+  }
+  if (err) {
+    return (
+      <div style={{
+        color: '#f5222d',
+        padding: 16,
+        background: 'rgba(20,20,20,0.8)',
+        backdropFilter: 'blur(24px)'
+      }}>
+        加载失败: {err}
+      </div>
+    );
+  }
+  if (!url) {
+    return (
+      <div style={{
+        padding: 16,
+        background: 'rgba(20,20,20,0.8)',
+        backdropFilter: 'blur(24px)'
+      }}>
+        无内容
+      </div>
+    );
+  }
+
+  return (
+    <div
+      ref={containerRef}
+      onWheel={onWheel}
+      onMouseMove={onMouseMove}
+      onMouseUp={onMouseUp}
+      onMouseLeave={onMouseUp}
+      onMouseDown={onMouseDown}
+      onDoubleClick={onDoubleClick}
+      onTouchStart={onTouchStart}
+      onTouchMove={onTouchMove}
+      onTouchEnd={onTouchEnd}
+      style={{
+        width: '100%',
+        height: '100%',
+        overflow: 'hidden',
+        position: 'relative',
+        background: 'rgba(20,20,20,0.8)',
+        backdropFilter: 'blur(24px)',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        userSelect: 'none',
+        touchAction: 'none'
+      }}
+    >
+      {/* 顶部栏：文件名和关闭按钮 */}
+      <div style={{
+        position: 'absolute',
+        top: 32,
+        left: 32,
+        right: 32,
+        zIndex: 100,
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        pointerEvents: 'none'
+      }}>
+        <Typography.Paragraph
+          style={{
+            color: '#fff',
+            margin: 0,
+            fontSize: 15,
+            background: 'rgba(0,0,0,0.32)',
+            padding: '7px 18px',
+            borderRadius: 8,
+            boxShadow: '0 2px 12px rgba(0,0,0,0.18)',
+            backdropFilter: 'blur(2px)',
+            maxWidth: '60vw',
+            textAlign: 'left',
+            pointerEvents: 'auto'
+          }}
+          ellipsis
+        >
+          {entry.name} <span style={{ opacity: 0.7, fontSize: 13 }}>({(entry.size / 1024).toFixed(1)} KB)</span>
+        </Typography.Paragraph>
+        <Tooltip title="关闭">
+          <Button
+            shape="circle"
+            size="large"
+            type="text"
+            onClick={() => onRequestClose && onRequestClose()}
+            icon={<CloseOutlined />}
+            style={{
+              color: '#fff',
+              background: 'rgba(30,30,30,0.55)',
+              boxShadow: '0 2px 12px rgba(0,0,0,0.18)',
+              border: 'none',
+              backdropFilter: 'blur(4px)',
+              pointerEvents: 'auto'
+            }}
+          />
+        </Tooltip>
+      </div>
+
+      {/* 图片居中显示 */}
+      <div style={{
+        position: 'relative',
+        width: '100%',
+        height: '100%',
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        flexDirection: 'column'
+      }}>
+        <img
+          ref={imgRef}
+          src={url}
+          alt={entry.name}
+          draggable={false}
+          onDragStart={e => e.preventDefault()}
+          style={{
+            transform: `translate(${offset.x}px, ${offset.y}px) scale(${scale}) rotate(${rotate}deg)`,
+            transition: transitionRef.current ? 'transform 0.18s cubic-bezier(.4,.8,.4,1)' : undefined,
+            maxWidth: '80vw',
+            maxHeight: '80vh',
+            objectFit: 'contain',
+            borderRadius: 18,
+            boxShadow: '0 8px 40px 0 rgba(0,0,0,0.45)',
+            cursor: isDragging ? 'grabbing' : (scale > 1 ? 'grab' : 'zoom-in'),
+            willChange: 'transform'
+          }}
+        />
+
+        {/* 操作按钮组 */}
+        <div style={{
+          position: 'absolute',
+          bottom: 32,
+          left: '50%',
+          transform: 'translateX(-50%)',
+          display: 'flex',
+          gap: 18,
+          zIndex: 80
+        }}>
+          <Tooltip title="缩小">
+            <Button
+              shape="circle"
+              size="large"
+              icon={<ZoomOutOutlined style={{ fontSize: 22 }} />}
+              onClick={() => doZoom(0.8)}
+              style={{
+                color: '#fff',
+                background: 'rgba(30,30,30,0.55)',
+                boxShadow: '0 2px 12px rgba(0,0,0,0.18)',
+                border: 'none',
+                backdropFilter: 'blur(4px)'
+              }}
+            />
+          </Tooltip>
+          <Tooltip title="放大">
+            <Button
+              shape="circle"
+              size="large"
+              icon={<ZoomInOutlined style={{ fontSize: 22 }} />}
+              onClick={() => doZoom(1.25)}
+              style={{
+                color: '#fff',
+                background: 'rgba(30,30,30,0.55)',
+                boxShadow: '0 2px 12px rgba(0,0,0,0.18)',
+                border: 'none',
+                backdropFilter: 'blur(4px)'
+              }}
+            />
+          </Tooltip>
+          <Tooltip title="旋转">
+            <Button
+              shape="circle"
+              size="large"
+              icon={<RotateRightOutlined style={{ fontSize: 20 }} />}
+              onClick={doRotate}
+              style={{
+                color: '#fff',
+                background: 'rgba(30,30,30,0.55)',
+                boxShadow: '0 2px 12px rgba(0,0,0,0.18)',
+                border: 'none',
+                backdropFilter: 'blur(4px)'
+              }}
+            />
+          </Tooltip>
+          <Tooltip title="重置">
+            <Button
+              shape="circle"
+              size="large"
+              icon={<ReloadOutlined style={{ fontSize: 20 }} />}
+              onClick={resetView}
+              style={{
+                color: '#fff',
+                background: 'rgba(30,30,30,0.55)',
+                boxShadow: '0 2px 12px rgba(0,0,0,0.18)',
+                border: 'none',
+                backdropFilter: 'blur(4px)'
+              }}
+            />
+          </Tooltip>
+          <Tooltip title="适应窗口">
+            <Button
+              shape="circle"
+              size="large"
+              icon={<CompressOutlined style={{ fontSize: 20 }} />}
+              onClick={fitToContainer}
+              style={{
+                color: '#fff',
+                background: 'rgba(30,30,30,0.55)',
+                boxShadow: '0 2px 12px rgba(0,0,0,0.18)',
+                border: 'none',
+                backdropFilter: 'blur(4px)'
+              }}
+            />
+          </Tooltip>
+        </div>
+      </div>
+    </div>
+  );
+};

web/src/apps/ImageViewer/index.ts

@@ -0,0 +1,17 @@
+import type { AppDescriptor } from '../types';
+import { ImageViewerApp } from './ImageViewer.tsx';
+
+export const descriptor: AppDescriptor = {
+  key: 'image-viewer',
+  name: '图片查看器',
+  supported: (entry) => {
+    if (entry.is_dir) return false;
+    const ext = entry.name.split('.').pop()?.toLowerCase() || '';
+    return ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif'].includes(ext);
+  },
+  component: ImageViewerApp,
+  default: true,
+  defaultMaximized:true,
+  useSystemWindow:false,
+  defaultBounds: { width: 820, height: 620, x: 140, y: 96 }
+};

web/src/apps/OfficeViewer/OfficeViewer.tsx

@@ -0,0 +1,80 @@
+import React, { useEffect, useState } from 'react';
+import { vfsApi } from '../../api/client';
+import type { AppComponentProps } from '../types';
+import { Spin, Result, Button } from 'antd';
+
+export const OfficeViewerApp: React.FC<AppComponentProps> = ({ filePath, onRequestClose }) => {
+  const [url, setUrl] = useState<string>();
+  const [loading, setLoading] = useState(true);
+  const [err, setErr] = useState<string>();
+
+  useEffect(() => {
+    let cancelled = false;
+    setLoading(true);
+    setErr(undefined);
+    setUrl(undefined);
+
+    vfsApi.getTempLinkToken(filePath.replace(/^\/+/, ''))
+      .then(res => {
+        if (cancelled) return;
+        // 注意：vfsApi.getTempPublicUrl 返回的是相对路径，我们需要构建完整的 URL
+        const fullUrl = new URL(vfsApi.getTempPublicUrl(res.token), window.location.origin).href;
+        const officeUrl = `https://view.officeapps.live.com/op/embed.aspx?src=${encodeURIComponent(fullUrl)}`;
+        setUrl(officeUrl);
+      })
+      .catch(e => {
+        if (!cancelled) {
+          setErr(e.message || '加载文档链接失败');
+        }
+      })
+      .finally(() => {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [filePath]);
+
+  if (loading) {
+    return (
+      <div style={{ width: '100%', height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
+        <Spin tip="正在准备文档..." />
+      </div>
+    );
+  }
+
+  if (err) {
+    return (
+      <Result
+        status="error"
+        title="无法加载文档"
+        subTitle={err}
+        extra={<Button type="primary" onClick={onRequestClose}>关闭</Button>}
+      />
+    );
+  }
+
+  return (
+    <div style={{ width: '100%', height: '100%', background: '#fff' }}>
+      {url ? (
+        <iframe
+          src={url}
+          width="100%"
+          height="100%"
+          frameBorder="0"
+          title="Office Document Viewer"
+        />
+      ) : (
+        <Result
+          status="warning"
+          title="文档链接无效"
+          subTitle="未能成功生成文档的在线查看链接。"
+          extra={<Button type="primary" onClick={onRequestClose}>关闭</Button>}
+        />
+      )}
+    </div>
+  );
+};

web/src/apps/OfficeViewer/index.ts

@@ -0,0 +1,15 @@
+import type { AppDescriptor } from '../types';
+import { OfficeViewerApp } from './OfficeViewer.tsx';
+
+export const descriptor: AppDescriptor = {
+  key: 'office-viewer',
+  name: 'Office 文档查看器',
+  supported: (entry) => {
+    if (entry.is_dir) return false;
+    const ext = entry.name.split('.').pop()?.toLowerCase() || '';
+    return ['docx', 'xlsx', 'pptx', 'doc', 'xls', 'ppt'].includes(ext);
+  },
+  component: OfficeViewerApp,
+  default: true,
+  defaultBounds: { width: 1024, height: 768, x: 150, y: 100 }
+};

web/src/apps/TextEditor/TextEditor.tsx

@@ -0,0 +1,104 @@
+import React, { useState, useEffect, useCallback, useRef } from 'react';
+import { Layout, Spin, Button, Space, message } from 'antd';
+import MDEditor from '@uiw/react-md-editor';
+import type { AppComponentProps } from '../types';
+import { vfsApi } from '../../api/vfs';
+
+const { Header, Content } = Layout;
+
+export const TextEditorApp: React.FC<AppComponentProps> = ({ filePath, entry, onRequestClose }) => {
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [content, setContent] = useState('');
+  const [initialContent, setInitialContent] = useState('');
+  const isDirty = content !== initialContent;
+
+  // 使用 ref 来持有最新的 onRequestClose 函数，避免它成为 effect 的依赖项
+  const onRequestCloseRef = useRef(onRequestClose);
+  onRequestCloseRef.current = onRequestClose;
+
+  useEffect(() => {
+    const loadFile = async () => {
+      try {
+        setLoading(true);
+        const data = await vfsApi.readFile(filePath);
+        const text = typeof data === 'string' ? data : new TextDecoder().decode(data);
+        setContent(text);
+        setInitialContent(text);
+      } catch (error) {
+        message.error(`加载文件失败: ${error instanceof Error ? error.message : '未知错误'}`);
+        onRequestCloseRef.current();
+      } finally {
+        setLoading(false);
+      }
+    };
+    loadFile();
+  }, [filePath]); // effect 只依赖 filePath，因此只在文件路径变化时执行一次
+
+  const handleSave = useCallback(async () => {
+    if (!isDirty) return;
+    try {
+      setSaving(true);
+      const blob = new Blob([content], { type: 'text/plain' });
+      await vfsApi.uploadFile(filePath, blob);
+      setInitialContent(content);
+      message.success('保存成功');
+    } catch (error) {
+      message.error(`保存文件失败: ${error instanceof Error ? error.message : '未知错误'}`);
+    } finally {
+      setSaving(false);
+    }
+  }, [content, filePath, isDirty]);
+
+  useEffect(() => {
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if ((event.ctrlKey || event.metaKey) && event.key === 's') {
+        event.preventDefault();
+        handleSave();
+      }
+    };
+    window.addEventListener('keydown', handleKeyDown);
+    return () => {
+      window.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [handleSave]);
+
+  return (
+    <Layout style={{ height: '100%', background: '#ffffff' }}>
+      <Header
+        style={{
+          background: '#f0f2f5',
+          padding: '0 16px',
+          height: 40,
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'space-between',
+          borderBottom: '1px solid #d9d9d9'
+        }}
+      >
+        <span style={{ color: 'rgba(0, 0, 0, 0.88)' }}>
+          {entry.name} {isDirty && '*'}
+        </span>
+        <Space>
+          <Button type="primary" size="small" onClick={handleSave} loading={saving} disabled={!isDirty}>
+            保存
+          </Button>
+        </Space>
+      </Header>
+      <Content style={{ position: 'relative', overflow: 'auto', height: 'calc(100% - 40px)' }}>
+        {loading ? (
+          <div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center', height: '100%' }}>
+            <Spin />
+          </div>
+        ) : (
+          <MDEditor
+            value={content}
+            onChange={(val) => setContent(val || '')}
+            height="100%"
+            preview="live"
+          />
+        )}
+      </Content>
+    </Layout>
+  );
+};

web/src/apps/TextEditor/index.ts

@@ -0,0 +1,16 @@
+import type { AppDescriptor } from '../types';
+import { TextEditorApp } from './TextEditor.tsx';
+
+export const descriptor: AppDescriptor = {
+  key: 'text-editor',
+  name: '文本编辑器',
+  supported: (entry) => {
+    if (entry.is_dir) return false;
+    const ext = entry.name.split('.').pop()?.toLowerCase() || '';
+    // Supports common text and markdown formats
+    return ['txt', 'md', 'markdown', 'json', 'yaml', 'yml', 'xml', 'html', 'css', 'js', 'ts', 'py', 'sh', 'log'].includes(ext);
+  },
+  component: TextEditorApp,
+  default: true,
+  defaultBounds: { width: 1024, height: 768, x: 120, y: 80 }
+};

web/src/apps/VideoPlayer/VideoPlayer.tsx

@@ -0,0 +1,408 @@
+import React, { useEffect, useRef, useState } from 'react';
+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);
+      }
+    };
+  }, []);
+
+  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]);
+
+  // 处理视频事件
+  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);
+
+    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);
+      }
+    }, 3000);
+  };
+
+  const handleMouseMove = () => {
+    resetControlsTimer();
+  };
+
+  const retry = () => setRetryKey(k => k + 1);
+
+  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>
+  );
+};

web/src/apps/VideoPlayer/index.ts

@@ -0,0 +1,15 @@
+import type { AppDescriptor } from '../types';
+import { VideoPlayerApp } from './VideoPlayer.tsx';
+
+export const descriptor: AppDescriptor = {
+  key: 'video-player',
+  name: '视频播放器',
+  supported: (entry) => {
+    if (entry.is_dir) return false;
+    const ext = entry.name.split('.').pop()?.toLowerCase() || '';
+    return ['mp4','webm','ogg','m4v','mov'].includes(ext);
+  },
+  component: VideoPlayerApp,
+  default: true,
+  defaultBounds: { width: 960, height: 600, x: 180, y: 120 }
+};

web/src/apps/registry.ts

@@ -0,0 +1,41 @@
+import type { VfsEntry } from '../api/client';
+import type { AppDescriptor } from './types';
+const apps: AppDescriptor[] = [];
+
+// 使用 import.meta.glob 动态导入所有应用
+// vite-glob-ignore
+const appModules = import.meta.glob('./*/index.ts');
+
+async function loadApps() {
+  for (const path in appModules) {
+    const module = await appModules[path]();
+    if (module && typeof module === 'object' && 'descriptor' in module) {
+      const descriptor = (module as { descriptor: AppDescriptor }).descriptor;
+      if (!apps.find(a => a.key === descriptor.key)) {
+        apps.push(descriptor);
+      }
+    }
+  }
+}
+
+// 立即加载并注册所有应用
+loadApps();
+
+
+export function getAppsForEntry(entry: VfsEntry): AppDescriptor[] {
+  return apps.filter(a => a.supported(entry));
+}
+
+export function getDefaultAppForEntry(entry: VfsEntry): AppDescriptor | undefined {
+  if (entry.is_dir) return;
+  const ext = entry.name.split('.').pop()?.toLowerCase() || '';
+  if (!ext) return apps.find(a => a.supported(entry) && a.default);
+  const saved = localStorage.getItem(`app.default.${ext}`);
+  if (saved) {
+    return apps.find(a => a.key === saved && a.supported(entry)) || undefined;
+  }
+  return apps.find(a => a.supported(entry) && a.default);
+}
+
+export type { AppDescriptor };
+export type { AppComponentProps } from './types';

web/src/apps/types.ts

@@ -0,0 +1,29 @@
+import type { VfsEntry } from '../api/client';
+
+export interface AppComponentProps {
+  filePath: string;
+  entry: VfsEntry;
+  onRequestClose: () => void;
+}
+
+export interface AppDescriptor {
+  key: string;
+  name: string;
+  supported: (entry: VfsEntry) => boolean;
+  component: React.ComponentType<AppComponentProps>;
+  default?: boolean;
+  defaultMaximized?: boolean;
+  /**
+   * 应用窗口的默认位置与尺寸（非最大化时生效）
+   * 任意字段缺省则按系统默认/级联偏移。
+   */
+  defaultBounds?: {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+  };
+  // 新增：是否使用系统窗口（带标题栏、拖拽与缩放）
+  // 默认为 true；若设为 false 则渲染为无壳的嵌入式视图。
+  useSystemWindow?: boolean;
+}

web/src/components/ProcessorConfigForm.tsx

@@ -0,0 +1,61 @@
+import React from 'react';
+import { Form, Input, Select, Typography } from 'antd';
+import type { ProcessorTypeMeta } from '../api/processors';
+
+interface ProcessorConfigFormProps {
+  processorMeta: ProcessorTypeMeta | undefined;
+  form: any;
+  configPath: string[]; 
+}
+
+export const ProcessorConfigForm: React.FC<ProcessorConfigFormProps> = ({ processorMeta, configPath }) => {
+  if (!processorMeta) {
+    return <Typography.Text type="secondary">请先选择处理器</Typography.Text>;
+  }
+  if (!processorMeta.config_schema?.length) {
+    return <Typography.Text type="secondary">该处理器无配置项</Typography.Text>;
+  }
+
+  return (
+    <>
+      {processorMeta.config_schema.map(field => {
+        const rules = field.required ? [{ required: true, message: `请输入${field.label}` }] : [];
+        let inputNode: React.ReactNode;
+
+        switch (field.type) {
+          case 'password':
+            inputNode = <Input.Password placeholder={field.placeholder} />;
+            break;
+          case 'number':
+            inputNode = <Input type="number" placeholder={field.placeholder} />;
+            break;
+          case 'select':
+            inputNode = (
+              <Select placeholder={field.placeholder || '请选择'}>
+                {field.options?.map((opt: any) => (
+                  <Select.Option key={String(opt.value)} value={opt.value}>
+                    {opt.label}
+                  </Select.Option>
+                ))}
+              </Select>
+            );
+            break;
+          default:
+            inputNode = <Input placeholder={field.placeholder} />;
+        }
+
+        return (
+          <Form.Item
+            key={field.key}
+            name={[...configPath, field.key]}
+            label={field.label}
+            rules={rules}
+            initialValue={field.default}
+          >
+            {inputNode}
+          </Form.Item>
+        );
+      })}
+    </>
+  );
+};

web/src/contexts/AuthContext.tsx

@@ -0,0 +1,46 @@
+import React, { createContext, useContext, useState, useEffect } from 'react';
+import { authApi } from '../api/auth';
+
+interface AuthContextType {
+    token: string | null;
+    isAuthenticated: boolean;
+    login: (username: string, password: string) => Promise<void>;
+    logout: () => void;
+    register: (username: string, password: string, email?: string, full_name?: string) => Promise<void>;
+}
+
+const AuthContext = createContext<AuthContextType>({} as any);
+
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+    const [token, setToken] = useState<string | null>(() => localStorage.getItem('token'));
+    const isAuthenticated = !!token;
+
+    useEffect(() => {
+        if (token) localStorage.setItem('token', token);
+        else localStorage.removeItem('token');
+    }, [token]);
+
+    const login = async (username: string, password: string) => {
+        const res = await authApi.login({ username, password });
+        if (res)
+            setToken(res.access_token);
+    };
+
+    const logout = () => {
+        setToken(null);
+    };
+
+    const register = async (username: string, password: string, email?: string, full_name?: string) => {
+        await authApi.register(username, password, email, full_name);
+    };
+
+    return (
+        <AuthContext.Provider value={{ token, isAuthenticated, login, logout, register }}>
+            {children}
+        </AuthContext.Provider>
+    );
+}
+
+export function useAuth() {
+    return useContext(AuthContext);
+}

web/src/contexts/SystemContext.tsx

@@ -0,0 +1,12 @@
+import { createContext, useContext } from 'react';
+import type { SystemStatus } from '../api/config';
+
+export const SystemContext = createContext<SystemStatus | null>(null);
+
+export const useSystemStatus = () => {
+  const context = useContext(SystemContext);
+  if (context === undefined) {
+    throw new Error('useSystemStatus must be used within a SystemProvider');
+  }
+  return context;
+};

web/src/global.css

@@ -0,0 +1,41 @@
+html,body,#root { height: 100%; }
+body { font-family: system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,'Helvetica Neue',Arial,'Noto Sans',sans-serif; background:#f9f9f9; }
+
+::-webkit-scrollbar { width: 8px; height: 8px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: #d9d9d9; border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: #bfbfbf; }
+
+.fx-surface { background:#fff; border:1px solid #eaeaea; border-radius:12px; }
+.fx-card { background:linear-gradient(#fff,#fafafa); border:1px solid #eaeaea; border-radius:14px; box-shadow:0 1px 2px rgba(0,0,0,.04),0 4px 10px -2px rgba(0,0,0,.03); }
+.fx-fade-text { color:#555; }
+
+.fx-quiet-btn.ant-btn-text:not(:hover) { color:#666; }
+
+.ant-layout { background:#f9f9f9; }
+
+/* Menu compact spacing adjustments */
+.ant-menu-inline .ant-menu-item { margin-block:2px; }
+
+/* Sidebar high-contrast selection */
+.sider-menu .ant-menu-item-selected {
+	background:#111 !important;
+	color:#fff !important;
+}
+.sider-menu .ant-menu-item-selected .ant-menu-item-icon, 
+.sider-menu .ant-menu-item-selected .anticon { color:#fff !important; }
+.sider-menu .ant-menu-item:not(.ant-menu-item-selected):hover { background:#f2f2f2; }
+
+.row-selected td { background: rgba(24,144,255,0.12) !important; }
+.row-selected:hover td { background: rgba(24,144,255,0.2) !important; }
+
+.fx-grid { display:flex; flex-wrap:wrap; gap:20px; }
+.fx-grid-item { width:160px; cursor:pointer; border-radius:14px; padding:12px 12px 10px; background:#f5f5f5; position:relative; display:flex; flex-direction:column; align-items:stretch; gap:6px; transition:.18s box-shadow,.18s background; }
+.fx-grid-item.dir { background:#f3f3f3; }
+.fx-grid-item.selected { box-shadow:0 0 0 2px var(--ant-color-primary); background:#acc0c0; }
+.fx-grid-item:hover { background:#d2d1d1a7; box-shadow:0 1px 4px rgba(0,0,0,.06); }
+.fx-grid-item .thumb { height:120px; border-radius:10px; background:#fff; display:flex; align-items:center; justify-content:center; overflow:hidden; position:relative; box-shadow: inset 0 0 0 1px #eee; }
+.fx-grid-item .thumb img { width:100%; height:100%; object-fit:cover; }
+.fx-grid-item .thumb .badge { position:absolute; top:6px; left:6px; background:#111; color:#fff; font-size:10px; padding:2px 4px; border-radius:6px; line-height:1; letter-spacing:.5px; }
+.fx-grid-item .name { font-weight:600; font-size:13px; }
+.ellipsis { overflow:hidden; white-space:nowrap; text-overflow:ellipsis; }

web/src/layout/SearchDialog.tsx

@@ -0,0 +1,128 @@
+import { Modal, Input, List, Divider, Spin, Select, Space } from 'antd';
+import { SearchOutlined, FileTextOutlined } from '@ant-design/icons';
+import React, { useState } from 'react';
+import { vfsApi, type SearchResultItem } from '../api/vfs';
+import { useNavigate } from 'react-router';
+
+
+interface SearchDialogProps {
+  open: boolean;
+  onClose: () => void;
+}
+
+const SEARCH_MODES = [
+  { label: '智能搜索', value: 'vector' },
+  { label: '名称搜索', value: 'filename' },
+];
+
+const SearchDialog: React.FC<SearchDialogProps> = ({ open, onClose }) => {
+  const [search, setSearch] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [results, setResults] = useState<SearchResultItem[]>([]);
+  const [searched, setSearched] = useState(false);
+  const [searchMode, setSearchMode] = useState<'vector' | 'filename'>('vector');
+  const navigate = useNavigate();
+
+  const handleSearch = async () => {
+    if (!search.trim()) return;
+    setLoading(true);
+    setSearched(true);
+    try {
+      const res = await vfsApi.searchFiles(search, 10, searchMode);
+      setResults(res.items);
+    } catch (e) {
+      setResults([]);
+    }
+    setLoading(false);
+  };
+
+  return (
+    <Modal
+      open={open}
+      onCancel={onClose}
+      footer={null}
+      width={600}
+      centered
+      title={null}
+      closable={false}
+    >
+      <Space.Compact style={{ marginBottom: 0, width: '100%' }}>
+        <Select
+          options={SEARCH_MODES}
+          value={searchMode}
+          onChange={v => setSearchMode(v as 'vector' | 'filename')}
+          style={{
+            width: 120,
+            fontSize: 18,
+            height: 40,
+            lineHeight: '40px',
+            borderTopRightRadius: 0,
+            borderBottomRightRadius: 0,
+            borderRight: 0,
+            verticalAlign: 'top',
+          }}
+          styles={{ popup: { root: { fontSize: 18 } } }}
+          popupMatchSelectWidth={false}
+        />
+        <Input
+          allowClear
+          prefix={<SearchOutlined />}
+          placeholder="搜索文件 / 标签 / 类型"
+          value={search}
+          onChange={e => setSearch(e.target.value)}
+          style={{
+            fontSize: 18,
+            height: 40,
+            width: 'calc(100% - 120px)',
+            borderTopLeftRadius: 0,
+            borderBottomLeftRadius: 0,
+            verticalAlign: 'top',
+          }}
+          autoFocus
+          onPressEnter={handleSearch}
+        />
+      </Space.Compact>
+      {searched && (
+        <>
+          <Divider style={{ margin: '12px 0' }}>搜索结果</Divider>
+          {loading ? (
+            <Spin />
+          ) : (
+            <List
+              itemLayout="horizontal"
+              dataSource={results}
+              locale={{ emptyText: '未找到相关文件' }}
+              renderItem={item => {
+                const fullPath = item.path || '';
+                const trimmed = fullPath.replace(/\/+$/, '');
+                const parts = trimmed.split('/');
+                const filename = parts.pop() || '';
+                const dir = parts.length ? '/' + parts.join('/') : '/';
+                return (
+                  <List.Item>
+                    <List.Item.Meta
+                      avatar={<FileTextOutlined />}
+                      title={
+                        <a
+                          onClick={() => {
+                            navigate(`/files${dir === '/' ? '' : dir}`, { state: { highlight: { name: filename } } });
+                            onClose();
+                          }}
+                        >
+                          {fullPath}
+                        </a>
+                      }
+                      description={`相关度: ${item.score.toFixed(2)}`}
+                    />
+                  </List.Item>
+                );
+              }}
+            />
+          )}
+        </>
+      )}
+    </Modal>
+  );
+};
+
+export default SearchDialog;

web/src/layout/SideNav.tsx

@@ -0,0 +1,97 @@
+import { Layout, Menu, theme, Button } from 'antd';
+import { navGroups } from './nav.ts';
+import type { NavItem, NavGroup } from './nav.ts';
+import { memo } from 'react';
+import { useSystemStatus } from '../contexts/SystemContext.tsx';
+import { MenuFoldOutlined } from '@ant-design/icons';
+import '../styles/sider-menu.css';
+
+const { Sider } = Layout;
+
+export interface SideNavProps {
+  collapsed: boolean;
+  onToggle(): void;
+  activeKey: string;
+  onChange(key: string): void;
+}
+
+const SideNav = memo(function SideNav({ collapsed, activeKey, onChange, onToggle }: SideNavProps) {
+  const status = useSystemStatus();
+  const { token } = theme.useToken();
+  return (
+    <Sider
+      collapsedWidth={60}
+      collapsible
+      trigger={null}
+      collapsed={collapsed}
+      width={208}
+      style={{ background: token.colorBgContainer, borderRight: `1px solid ${token.colorBorderSecondary}` }}
+    >
+      <div style={{
+        height: 56,
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: collapsed ? 'center' : 'space-between',
+        padding: '0 14px',
+        fontWeight: 600,
+        fontSize: 18,
+        letterSpacing: .5
+      }}>
+        <div style={{ display: 'flex', alignItems: 'center' }}>
+          <img
+            src={status?.logo}
+            alt="Foxel"
+            style={{
+              width: 24,
+              height: 24,
+              objectFit: 'contain',
+              marginRight: collapsed ? 0 : 8,
+              ...(status?.logo?.endsWith('.svg') && { filter: 'brightness(0) saturate(100%)' })
+            }}
+          />
+          {!collapsed && <span style={{ fontWeight: 700 }}>{status?.title}</span>}
+        </div>
+        {/* 展开时显示收缩按钮 */}
+        {!collapsed && (
+          <Button
+            type="text"
+            icon={<MenuFoldOutlined />}
+            onClick={onToggle}
+            style={{ fontSize: 18 }}
+          />
+        )}
+      </div>
+      {/* 分组渲染 */}
+      <div style={{ overflowY: 'auto', height: 'calc(100% - 56px)', padding: '4px 4px 8px' }}>
+        {navGroups.map((group: NavGroup) => (
+          <div key={group.key} style={{ marginBottom: 12 }}>
+            {group.title && (
+              <div
+                style={{
+                  fontSize: 11,
+                  fontWeight: 600,
+                  letterSpacing: .5,
+                  padding: '6px 10px 4px',
+                  color: token.colorTextTertiary,
+                  textTransform: 'uppercase'
+                }}
+              >{group.title}</div>
+            )}
+            <Menu
+              mode="inline"
+              selectable
+              inlineIndent={12}
+              selectedKeys={[activeKey]}
+              onClick={(e) => onChange(e.key)}
+              items={group.children.map((i: NavItem) => ({ key: i.key, icon: i.icon, label: i.label }))}
+              style={{ borderInline: 'none', background: 'transparent' }}
+              className="sider-menu-group foxel-sider-menu"
+            />
+          </div>
+        ))}
+      </div>
+    </Sider>
+  );
+});
+
+export default SideNav;

web/src/layout/TopHeader.tsx

@@ -0,0 +1,58 @@
+import { Layout, Button, Dropdown, theme, Flex } from 'antd';
+import { SearchOutlined, UserOutlined, MenuUnfoldOutlined, LogoutOutlined } from '@ant-design/icons';
+import { memo, useState } from 'react';
+import SearchDialog from './SearchDialog.tsx';
+import { authApi } from '../api/auth.ts';
+import { useNavigate } from 'react-router';
+
+const { Header } = Layout;
+
+export interface TopHeaderProps {
+  collapsed: boolean;
+  onToggle(): void;
+}
+
+const TopHeader = memo(function TopHeader({ collapsed, onToggle }: TopHeaderProps) {
+  const { token } = theme.useToken();
+  const [searchOpen, setSearchOpen] = useState(false);
+  const navigate = useNavigate();
+
+  const handleLogout = () => {
+    authApi.logout();
+    navigate('/login', { replace: true });
+  };
+
+  return (
+    <Header style={{ background: token.colorBgContainer, borderBottom: `1px solid ${token.colorBorderSecondary}`, display: 'flex', alignItems: 'center', gap: 16, backdropFilter: 'saturate(180%) blur(8px)' }}>
+      {collapsed && (
+        <Button
+          type="text"
+          icon={<MenuUnfoldOutlined />}
+          onClick={onToggle}
+          style={{ fontSize: 18, marginRight: 8 }}
+        />
+      )}
+      <Button
+        icon={<SearchOutlined />}
+        style={{ maxWidth: 420 }}
+        onClick={() => setSearchOpen(true)}
+      >
+        搜索文件 / 标签 / 类型
+      </Button>
+      <SearchDialog open={searchOpen} onClose={() => setSearchOpen(false)} />
+      <Flex style={{ marginLeft: 'auto' }} align="center" gap={12}>
+        <Dropdown
+          menu={{
+            items: [
+              { key: 'logout', label: '退出登录', icon: <LogoutOutlined />, onClick: handleLogout }
+            ]
+          }}
+        >
+          <Button icon={<UserOutlined />}>管理员</Button>
+        </Dropdown>
+      </Flex>
+    </Header>
+  );
+});
+
+export default TopHeader;

web/src/layout/nav.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import {
+  FolderOpenOutlined,
+  ApiOutlined,
+  ShareAltOutlined,
+  CloudDownloadOutlined,
+  SettingOutlined,
+  RobotOutlined,
+  BugOutlined,
+  DatabaseOutlined,
+} from '@ant-design/icons';
+import type { ReactNode } from 'react';
+
+export interface NavItem { key: string; icon: ReactNode; label: string; }
+export interface NavGroup { key: string; title?: string; children: NavItem[]; }
+
+export const navGroups: NavGroup[] = [
+  {
+    key: 'library',
+    title: '',
+    children: [
+      { key: 'files', icon: React.createElement(FolderOpenOutlined), label: '全部文件' },
+    ]
+  },
+  {
+    key: 'manage',
+    title: '管理',
+    children: [
+      { key: 'tasks', icon: React.createElement(RobotOutlined), label: '自动化' },
+      { key: 'share', icon: React.createElement(ShareAltOutlined), label: '我的分享' },
+      { key: 'offline', icon: React.createElement(CloudDownloadOutlined), label: '离线下载' },
+      { key: 'adapters', icon: React.createElement(ApiOutlined), label: '存储挂载' },
+    ]
+  },
+  {
+    key: 'system',
+    title: '系统',
+    children: [
+      { key: 'settings', icon: React.createElement(SettingOutlined), label: '系统设置' },
+      { key: 'backup', icon: React.createElement(DatabaseOutlined), label: '备份恢复' },
+      { key: 'logs', icon: React.createElement(BugOutlined), label: '系统日志' }
+    ]
+  }
+];
+
+export const primaryNav: NavItem[] = navGroups.flatMap(g => g.children);

web/src/main.tsx

@@ -0,0 +1,17 @@
+import { createRoot } from 'react-dom/client';
+import App from './App.tsx';
+import '@ant-design/v5-patch-for-react-19';
+import { ConfigProvider } from 'antd';
+import zhCN from 'antd/locale/zh_CN';
+import 'antd/dist/reset.css';
+import foxelTheme from './theme';
+import './global.css';
+import { BrowserRouter } from 'react-router';
+
+createRoot(document.getElementById('root')!).render(
+  <ConfigProvider locale={zhCN} theme={foxelTheme}>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </ConfigProvider>
+);

web/src/pages/AdaptersPage.tsx

@@ -0,0 +1,281 @@
+import { memo, useState, useEffect, useCallback } from 'react';
+import { Table, Button, Space, Drawer, Form, Input, Switch, message, Typography, Popconfirm, Select, Card } from 'antd';
+import { adaptersApi } 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;
+  label: string;
+  type: 'string' | 'password' | 'number';
+  required?: boolean;
+  placeholder?: string;
+  default?: any;
+}
+interface AdapterTypeMeta {
+  type: string;
+  name: string;
+  config_schema: AdapterTypeField[];
+}
+
+const AdaptersPage = memo(function AdaptersPage() {
+  const [loading, setLoading] = useState(false);
+  const [data, setData] = useState<AdapterItem[]>([]);
+  const [open, setOpen] = useState(false);
+  const [editing, setEditing] = useState<AdapterItem | null>(null);
+  const [form] = Form.useForm();
+  const [availableTypes, setAvailableTypes] = useState<AdapterTypeMeta[]>([]);
+
+  const fetchList = useCallback(async () => {
+    setLoading(true);
+    try {
+      const [list, types] = await Promise.all([
+        adaptersApi.list(),
+        adaptersApi.available()
+      ]);
+      setData(list);
+      setAvailableTypes(types);
+    } catch (e: any) {
+      message.error(e.message || '加载失败');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => { fetchList(); }, [fetchList]);
+
+  const openCreate = () => {
+    setEditing(null);
+    form.resetFields();
+    const defaultType = availableTypes[0]?.type || 'local';
+    const typeMeta = availableTypes.find(t => t.type === defaultType);
+    const cfgDefaults: Record<string, any> = {};
+    typeMeta?.config_schema.forEach(f => {
+      if (f.default !== undefined) cfgDefaults[f.key] = f.default;
+    });
+    form.setFieldsValue({
+      name: '',
+      type: defaultType,
+      mount_path: '/',
+      sub_path: '',
+      enabled: true,
+      config: cfgDefaults
+    });
+    setOpen(true);
+  };
+
+  const openEdit = (rec: AdapterItem) => {
+    setEditing(rec);
+    form.resetFields();
+    form.setFieldsValue({
+      name: rec.name,
+      type: rec.type,
+      mount_path: rec.mount_path || '/',
+      sub_path: rec.sub_path || '',
+      enabled: rec.enabled,
+      config: rec.config || {}
+    });
+    setOpen(true);
+  };
+
+  const submit = async () => {
+    try {
+      const values = await form.validateFields();
+      const cfg = values.config || {};
+      const typeMeta = availableTypes.find(t => t.type === values.type);
+      const miss: string[] = [];
+      typeMeta?.config_schema.forEach(f => {
+        if (f.required && (cfg[f.key] === undefined || cfg[f.key] === null || cfg[f.key] === '')) {
+          miss.push(f.label || f.key);
+        }
+      });
+      if (miss.length) {
+        message.error('缺少必填配置: ' + miss.join(', '));
+        return;
+      }
+      const body = {
+        name: values.name.trim(),
+        type: values.type,
+        mount_path: values.mount_path || '/',
+        sub_path: values.sub_path?.trim() || null,
+        enabled: values.enabled,
+        config: cfg
+      };
+      setLoading(true);
+      if (editing) {
+        await adaptersApi.update(editing.id, body as any);
+        message.success('更新成功');
+      } else {
+        await adaptersApi.create(body as any);
+        message.success('创建成功');
+      }
+      setOpen(false);
+      setEditing(null);
+      fetchList();
+    } catch (e: any) {
+      if (e?.errorFields) return; // 表单校验
+      message.error(e.message || '操作失败');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const doDelete = async (rec: AdapterItem) => {
+    try {
+      await adaptersApi.remove(rec.id);
+      message.success('已删除');
+      fetchList();
+    } catch (e: any) {
+      message.error(e.message || '删除失败');
+    }
+  };
+
+  const handleToggleEnabled = async (rec: AdapterItem, checked: boolean) => {
+    try {
+      setLoading(true);
+      await adaptersApi.update(rec.id, { ...rec, enabled: checked });
+      message.success('状态已更新');
+      fetchList();
+    } catch (e: any) {
+      message.error(e.message || '更新失败');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const columns = [
+    { title: '名称', dataIndex: 'name' },
+    { title: '类型', dataIndex: 'type', width: 100 },
+    { title: '挂载路径', dataIndex: 'mount_path', width: 140, render: (v: string) => v || '-' },
+    { title: '子路径', dataIndex: 'sub_path', width: 140, render: (v: string) => v || '-' },
+    {
+      title: '启用',
+      dataIndex: 'enabled',
+      width: 80,
+      render: (v: boolean, rec: AdapterItem) => (
+        <Switch
+          checked={v}
+          size="small"
+          loading={loading}
+          onChange={checked => handleToggleEnabled(rec, checked)}
+        />
+      )
+    },
+    {
+      title: '操作',
+      width: 160,
+      render: (_: any, rec: AdapterItem) => (
+        <Space size="small">
+          <Button size="small" onClick={() => openEdit(rec)}>编辑</Button>
+          <Popconfirm title="确认删除?" onConfirm={() => doDelete(rec)}>
+            <Button size="small" danger>删除</Button>
+          </Popconfirm>
+        </Space>
+      )
+    }
+  ];
+
+  const selectedType = Form.useWatch('type', form);
+  const currentTypeMeta = availableTypes.find(t => t.type === selectedType);
+
+  function renderConfigFields() {
+    if (!currentTypeMeta) return <Typography.Text type="secondary">无配置项</Typography.Text>;
+    return currentTypeMeta.config_schema.map(field => {
+      const rules = field.required ? [{ required: true, message: `请输入${field.label}` }] : [];
+      let inputNode: any = <Input placeholder={field.placeholder} />;
+      if (field.type === 'password') inputNode = <Input.Password placeholder={field.placeholder} />;
+      if (field.type === 'number') inputNode = <Input type="number" placeholder={field.placeholder} />;
+      return (
+        <Form.Item
+          key={field.key}
+          name={['config', field.key]}
+          label={field.label}
+          rules={rules}
+        >
+          {inputNode}
+        </Form.Item>
+      );
+    });
+  }
+
+  return (
+    <Card
+      title="存储适配器"
+      style={{ margin: 0 }}
+      extra={
+        <Space>
+          <Button onClick={fetchList} loading={loading}>刷新</Button>
+          <Button type="primary" onClick={openCreate}>新建适配器</Button>
+        </Space>
+      }
+    >
+      <Table
+        rowKey="id"
+        dataSource={data}
+        columns={columns as any}
+        loading={loading}
+        pagination={false}
+        style={{ marginBottom: 0 }}
+      />
+      <Drawer
+        title={editing ? `编辑: ${editing.name}` : '新建适配器'}
+        width={480}
+        open={open}
+        onClose={() => { setOpen(false); setEditing(null); }}
+        destroyOnClose
+        extra={
+          <Space>
+            <Button onClick={() => { setOpen(false); setEditing(null); }}>取消</Button>
+            <Button type="primary" onClick={submit} loading={loading}>提交</Button>
+          </Space>
+        }
+      >
+        <Form
+          form={form}
+          layout="vertical"
+          initialValues={{ enabled: true }}
+        >
+          <Form.Item name="name" label="名称" rules={[{ required: true, message: '请输入名称' }]}>
+            <Input placeholder="唯一名称" />
+          </Form.Item>
+          <Form.Item name="type" label="类型" rules={[{ required: true }]}>
+            <Select
+              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 => {
+                  if (f.default !== undefined) cfgDefaults[f.key] = f.default;
+                });
+                form.setFieldsValue({ config: cfgDefaults });
+              }}
+            />
+          </Form.Item>
+          <Form.Item name="mount_path" label="挂载路径" rules={[{ required: true, message: '请输入挂载路径' }]}>
+            <Input placeholder="/或/drive" />
+          </Form.Item>
+          <Form.Item name="sub_path" label="子路径(可选)">
+            <Input placeholder="适配器内部子目录" />
+          </Form.Item>
+          <Form.Item name="enabled" label="启用" valuePropName="checked">
+            <Switch />
+          </Form.Item>
+          <Typography.Title level={5} style={{ marginTop: 8, fontSize: 14 }}>适配器配置</Typography.Title>
+          {renderConfigFields()}
+        </Form>
+      </Drawer>
+    </Card>
+  );
+});
+
+export default AdaptersPage;

web/src/pages/FileExplorerPage/FileExplorerPage.tsx

@@ -0,0 +1,204 @@
+import { memo, useEffect, useState } from 'react';
+import { useParams } from 'react-router';
+import { theme, Pagination } from 'antd';
+import { AppWindowsLayer } from '../../apps/AppWindowsLayer';
+import { useFileExplorer } from './hooks/useFileExplorer';
+import { useFileSelection } from './hooks/useFileSelection';
+import { useFileActions } from './hooks/useFileActions.tsx';
+import { useAppWindows } from './hooks/useAppWindows.tsx';
+import { useContextMenu } from './hooks/useContextMenu';
+import { useProcessor } from './hooks/useProcessor';
+import { useThumbnails } from './hooks/useThumbnails';
+import { Header } from './components/Header';
+import { GridView } from './components/GridView';
+import { FileListView } from './components/FileListView';
+import { EmptyState } from './components/EmptyState';
+import { ContextMenu } from './components/ContextMenu';
+import { CreateDirModal } from './components/Modals/CreateDirModal';
+import { RenameModal } from './components/Modals/RenameModal';
+import { ProcessorModal } from './components/Modals/ProcessorModal';
+import { ShareModal } from './components/Modals/ShareModal';
+import { FileDetailModal } from './components/FileDetailModal';
+import type { ViewMode } from './types';
+import { vfsApi, type VfsEntry } from '../../api/client';
+
+const FileExplorerPage = memo(function FileExplorerPage() {
+  const { navKey = 'files', '*': restPath = '' } = useParams();
+  const { token } = theme.useToken();
+  const [viewMode, setViewMode] = useState<ViewMode>('grid');
+
+  // --- Hooks ---
+  const { path, entries, loading, pagination, processorTypes, load, navigateTo, goUp, handlePaginationChange, refresh } = useFileExplorer(navKey);
+  const { selectedEntries, handleSelect, handleSelectRange, clearSelection } = useFileSelection();
+  const { uploading, fileInputRef, doCreateDir, doDelete, doRename, doDownload, doShare, handleUploadClick, handleFilesSelected } = useFileActions({ path, refresh, clearSelection, onShare: (entries) => setSharingEntries(entries) });
+  const { appWindows, openFileWithDefaultApp, confirmOpenWithApp, closeWindow, toggleMax, bringToFront, updateWindow } = useAppWindows(path);
+  const { ctxMenu, blankCtxMenu, openContextMenu, openBlankContextMenu, closeContextMenus } = useContextMenu();
+  const processorHook = useProcessor({ path, processorTypes, refresh });
+  const { thumbs } = useThumbnails(entries, path);
+
+  // --- State for Modals ---
+  const [creatingDir, setCreatingDir] = useState(false);
+  const [renaming, setRenaming] = useState<VfsEntry | null>(null);
+  const [sharingEntries, setSharingEntries] = useState<VfsEntry[]>([]);
+  const [detailEntry, setDetailEntry] = useState<VfsEntry | null>(null);
+  const [detailData, setDetailData] = useState<any>(null);
+  const [detailLoading, setDetailLoading] = useState(false);
+
+  // --- Effects ---
+  useEffect(() => {
+    const routeP = '/' + (restPath || '').replace(/^\/+/, '');
+    load(routeP, 1, pagination.pageSize);
+  }, [restPath, navKey, load, pagination.pageSize]);
+
+  // --- Handlers ---
+  const handleOpenEntry = (entry: VfsEntry) => {
+    if (entry.is_dir) {
+      const next = (path === '/' ? '' : path) + '/' + entry.name;
+      navigateTo(next.replace(/\/+/g, '/'));
+    } else {
+      openFileWithDefaultApp(entry);
+    }
+  };
+
+  const openDetail = async (entry: VfsEntry) => {
+    setDetailEntry(entry);
+    setDetailLoading(true);
+    try {
+      const fullPath = (path === '/' ? '' : path) + '/' + entry.name;
+      const stat = await vfsApi.stat(fullPath);
+      setDetailData(stat);
+    } catch (e: any) {
+      setDetailData({ error: e.message });
+    } finally {
+      setDetailLoading(false);
+    }
+  };
+
+  return (
+    <div
+      style={{
+        background: token.colorBgContainer,
+        border: `1px solid ${token.colorBorderSecondary}`,
+        borderRadius: token.borderRadius,
+        height: 'calc(100vh - 88px)',
+        display: 'flex',
+        flexDirection: 'column',
+        position: 'relative'
+      }}
+      onClick={closeContextMenus}
+    >
+      <Header
+        navKey={navKey}
+        path={path}
+        loading={loading}
+        uploading={uploading}
+        viewMode={viewMode}
+        onGoUp={goUp}
+        onNavigate={navigateTo}
+        onRefresh={refresh}
+        onCreateDir={() => setCreatingDir(true)}
+        onUpload={handleUploadClick}
+        onSetViewMode={setViewMode}
+      />
+
+      <input ref={fileInputRef} type="file" style={{ display: 'none' }} multiple onChange={handleFilesSelected} />
+
+      <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>
+        ) : viewMode === 'grid' ? (
+          <GridView
+            entries={entries}
+            thumbs={thumbs}
+            selectedEntries={selectedEntries}
+            loading={loading}
+            path={path}
+            onSelect={handleSelect}
+            onSelectRange={handleSelectRange}
+            onOpen={handleOpenEntry}
+            onContextMenu={openContextMenu}
+            onCreateDir={() => setCreatingDir(true)}
+            onGoUp={goUp}
+          />
+        ) : (
+          <FileListView
+            entries={entries}
+            loading={loading}
+            selectedEntries={selectedEntries}
+            onRowClick={(r, e) => handleSelect(r, e.ctrlKey || e.metaKey)}
+            onOpen={handleOpenEntry}
+            onOpenWith={(entry, appKey) => confirmOpenWithApp(entry, { key: appKey, name: '' } as any)}
+            onRename={setRenaming}
+            onDelete={(entry) => doDelete([entry])}
+            onContextMenu={openContextMenu}
+          />
+        )}
+      </div>
+
+      {pagination.total > 0 && (
+        <div style={{ position: 'absolute', bottom: 0, left: 0, right: 0, padding: '12px 16px', background: token.colorBgContainer, borderTop: `1px solid ${token.colorBorderSecondary}`, textAlign: 'center', zIndex: 10 }}>
+          <Pagination {...pagination} onChange={handlePaginationChange} onShowSizeChange={handlePaginationChange} />
+        </div>
+      )}
+
+      {/* --- Modals & Context Menus --- */}
+      <CreateDirModal open={creatingDir} onOk={(name) => { doCreateDir(name); setCreatingDir(false); }} onCancel={() => setCreatingDir(false)} />
+      <RenameModal entry={renaming} onOk={(entry, newName) => { doRename(entry, newName); setRenaming(null); }} onCancel={() => setRenaming(null)} />
+      <FileDetailModal entry={detailEntry} loading={detailLoading} data={detailData} onClose={() => setDetailEntry(null)} />
+      {sharingEntries.length > 0 && (
+        <ShareModal
+          path={path}
+          entries={sharingEntries}
+          open={sharingEntries.length > 0}
+          onOk={() => setSharingEntries([])}
+          onCancel={() => setSharingEntries([])}
+        />
+      )}
+      <ProcessorModal
+        entry={processorHook.processorModal.entry}
+        visible={processorHook.processorModal.visible}
+        loading={processorHook.processorLoading}
+        processorTypes={processorTypes}
+        selectedProcessor={processorHook.selectedProcessor}
+        config={processorHook.processorConfig}
+        savingPath={processorHook.processorSavingPath}
+        overwrite={processorHook.processorOverwrite}
+        onOk={processorHook.handleProcessorOk}
+        onCancel={processorHook.handleProcessorCancel}
+        onSelectedProcessorChange={processorHook.setSelectedProcessor}
+        onConfigChange={processorHook.setProcessorConfig}
+        onSavingPathChange={processorHook.setProcessorSavingPath}
+        onOverwriteChange={processorHook.setProcessorOverwrite}
+      />
+
+      {(ctxMenu || blankCtxMenu) && (
+        <ContextMenu
+          x={ctxMenu?.x || blankCtxMenu!.x}
+          y={ctxMenu?.y || blankCtxMenu!.y}
+          entry={ctxMenu?.entry}
+          entries={entries}
+          selectedEntries={selectedEntries}
+          processorTypes={processorTypes}
+          onClose={closeContextMenus}
+          onOpen={handleOpenEntry}
+          onOpenWith={(entry, appKey) => confirmOpenWithApp(entry, { key: appKey, name: '' } as any)}
+          onDownload={doDownload}
+          onRename={setRenaming}
+          onDelete={(entriesToDelete) => doDelete(entriesToDelete)}
+          onDetail={openDetail}
+          onProcess={(entry, type) => {
+            processorHook.setSelectedProcessor(type);
+            processorHook.openProcessorModal(entry);
+          }}
+          onUpload={handleUploadClick}
+          onCreateDir={() => setCreatingDir(true)}
+          onShare={doShare}
+        />
+      )}
+
+      <AppWindowsLayer windows={appWindows} onClose={closeWindow} onToggleMax={toggleMax} onBringToFront={bringToFront} onUpdateWindow={updateWindow} />
+    </div>
+  );
+});
+
+export default FileExplorerPage;

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

@@ -0,0 +1,143 @@
+import React from 'react';
+import { Menu, theme } from 'antd';
+import type { VfsEntry } from '../../../api/client';
+import { getAppsForEntry, getDefaultAppForEntry } from '../../../apps/registry';
+import {
+  FolderFilled, AppstoreOutlined, AppstoreAddOutlined, DownloadOutlined,
+  EditOutlined, DeleteOutlined, InfoCircleOutlined, UploadOutlined, PlusOutlined, ShareAltOutlined
+} from '@ant-design/icons';
+
+interface ContextMenuProps {
+  x: number;
+  y: number;
+  entry?: VfsEntry;
+  entries: VfsEntry[];
+  selectedEntries: string[];
+  processorTypes: any[];
+  onClose: () => void;
+  onOpen: (entry: VfsEntry) => void;
+  onOpenWith: (entry: VfsEntry, appKey: string) => void;
+  onDownload: (entry: VfsEntry) => void;
+  onRename: (entry: VfsEntry) => void;
+  onDelete: (entries: VfsEntry[]) => void;
+  onDetail: (entry: VfsEntry) => void;
+  onProcess: (entry: VfsEntry, processorType: string) => void;
+  onUpload: () => void;
+  onCreateDir: () => void;
+  onShare: (entries: VfsEntry[]) => void;
+}
+
+export const ContextMenu: React.FC<ContextMenuProps> = (props) => {
+  const { token } = theme.useToken();
+  const { x, y, entry, entries, selectedEntries, processorTypes, onClose, ...actions } = props;
+
+  const getContextMenuItems = () => {
+    if (!entry) { // Blank context menu
+      return [
+        { key: 'upload', label: '上传文件', icon: <UploadOutlined />, onClick: actions.onUpload },
+        { key: 'mkdir', label: '新建目录', icon: <PlusOutlined />, onClick: actions.onCreateDir },
+      ];
+    }
+
+    // Entry context menu
+    const apps = getAppsForEntry(entry);
+    const defaultApp = getDefaultAppForEntry(entry);
+    const targetNames = selectedEntries.includes(entry.name) ? selectedEntries : [entry.name];
+    const targetEntries = entries.filter(e => targetNames.includes(e.name));
+
+    let processorSubMenu: any[] = [];
+    if (!entry.is_dir && processorTypes.length > 0) {
+      const ext = entry.name.split('.').pop()?.toLowerCase() || '';
+      processorSubMenu = processorTypes
+        .filter(pt => pt.supported_exts.includes(ext))
+        .map(pt => ({
+          key: 'processor-' + pt.type,
+          label: pt.name,
+          onClick: () => actions.onProcess(entry, pt.type),
+        }));
+    }
+
+    return [
+      (entry.is_dir || apps.length > 0) ? {
+        key: 'open',
+        label: defaultApp ? `打开 (${defaultApp.name})` : '打开',
+        icon: <FolderFilled />,
+        onClick: () => actions.onOpen(entry),
+      } : null,
+      !entry.is_dir && apps.length > 0 ? {
+        key: 'openWith',
+        label: '打开方式',
+        icon: <AppstoreOutlined />,
+        children: apps.map(a => ({
+          key: 'openWith-' + a.key,
+          label: a.name + (a.key === defaultApp?.key ? ' (默认)' : ''),
+          onClick: () => actions.onOpenWith(entry, a.key),
+        })),
+      } : null,
+      !entry.is_dir && processorSubMenu.length > 0 ? {
+        key: 'process',
+        label: '处理器',
+        icon: <AppstoreAddOutlined />,
+        children: processorSubMenu,
+      } : null,
+      {
+        key: 'share',
+        label: '分享',
+        icon: <ShareAltOutlined />,
+        onClick: () => actions.onShare(targetEntries),
+      },
+      {
+        key: 'download',
+        label: '下载',
+        icon: <DownloadOutlined />,
+        disabled: targetEntries.some(t => t.is_dir) || targetEntries.length > 1,
+        onClick: () => actions.onDownload(targetEntries[0]),
+      },
+      {
+        key: 'rename',
+        label: '重命名',
+        icon: <EditOutlined />,
+        disabled: targetEntries.length !== 1 || targetEntries[0].type === 'mount',
+        onClick: () => actions.onRename(targetEntries[0]),
+      },
+      {
+        key: 'delete',
+        label: '删除',
+        icon: <DeleteOutlined />,
+        danger: true,
+        disabled: targetEntries.some(t => t.type === 'mount'),
+        onClick: () => actions.onDelete(targetEntries),
+      },
+      {
+        key: 'detail',
+        label: '详情',
+        icon: <InfoCircleOutlined />,
+        onClick: () => actions.onDetail(entry),
+      },
+    ].filter(Boolean);
+  };
+
+  const items = getContextMenuItems()
+    .filter(item => item !== null) // Ensure no null items
+    .map(item => ({
+      ...item,
+      onClick: () => {
+        if (item.onClick) item.onClick();
+        onClose();
+      }
+    }));
+
+  return (
+    <div
+      style={{ position: 'fixed', top: y, left: x, zIndex: 9999, boxShadow: '0 4px 16px rgba(0,0,0,.15)', borderRadius: token.borderRadius, background: token.colorBgElevated }}
+      onContextMenu={(e) => e.preventDefault()}
+      onClick={onClose} // Close on any click inside the menu area
+    >
+      <Menu
+        items={items as any[]}
+        selectable={false}
+        style={{ width: 160, borderRadius: token.borderRadius, background: 'transparent' }}
+      />
+    </div>
+  );
+};

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

@@ -0,0 +1,33 @@
+import React from 'react';
+import { Button, Space, Typography, theme } from 'antd';
+import { PlusOutlined, CloudUploadOutlined, ArrowUpOutlined, FolderOpenOutlined } from '@ant-design/icons';
+
+interface Props {
+  isRoot: boolean;
+  onCreateDir: () => void;
+  onGoUp: () => void;
+}
+
+export const EmptyState: React.FC<Props> = ({ isRoot, onCreateDir, onGoUp }) => {
+  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 }}>
+      <FolderOpenOutlined style={{ fontSize:64, color: token.colorTextQuaternary, marginBottom:16 }} />
+      <Typography.Title level={4} style={{ color: token.colorTextSecondary, marginBottom:8, fontWeight:400 }}>
+        {isRoot ? '这里还没有任何文件' : '此目录为空'}
+      </Typography.Title>
+      <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/FileDetailModal.tsx

@@ -0,0 +1,249 @@
+import React from 'react';
+import { Modal, Typography, Spin, theme, Card, Descriptions, Divider, Badge, Space, message } from 'antd';
+import { FileOutlined, FolderOutlined, CameraOutlined, InfoCircleOutlined } from '@ant-design/icons';
+import type { VfsEntry } from '../../../api/client';
+
+interface Props {
+  entry: VfsEntry | null;
+  loading: boolean;
+  data: any;
+  onClose: () => void;
+}
+
+const exifFieldMap: Record<string, { label: string; format?: (v: any) => string }> = {
+  '271': { label: '设备品牌' },
+  '272': { label: '设备型号' },
+  '306': { label: '拍摄时间' },
+  '282': { label: '水平分辨率', format: v => `${v} dpi` },
+  '283': { label: '垂直分辨率', format: v => `${v} dpi` },
+  '33434': { label: '曝光时间', format: v => `${v} 秒` },
+  '33437': { label: '光圈值', format: v => `f/${v}` },
+  '34855': { label: 'ISO' },
+  '37377': { label: '焦距', format: v => `${v} mm` },
+  '40962': { label: '宽度', format: v => `${v} px` },
+  '40963': { label: '高度', format: v => `${v} px` },
+};
+
+function renderExif(exif: Record<string, any>) {
+  const items = Object.entries(exifFieldMap)
+    .filter(([key]) => exif[key] !== undefined)
+    .map(([key, { label, format }]) => ({
+      key,
+      label,
+      value: format ? format(exif[key]) : exif[key]
+    }));
+
+  if (items.length === 0) {
+    return (
+      <div style={{ textAlign: 'center', padding: 24, color: '#999' }}>
+        <InfoCircleOutlined style={{ fontSize: 20, marginBottom: 8 }} />
+        <div>无常见EXIF信息</div>
+      </div>
+    );
+  }
+
+  return (
+    <Descriptions
+      size="small"
+      column={1}
+      bordered
+      items={items.map(item => ({
+        key: item.key,
+        label: <span style={{ fontWeight: 500, color: '#595959' }}>{item.label}</span>,
+        children: <span style={{ color: '#262626' }}>{item.value}</span>
+      }))}
+      contentStyle={{ padding: '8px 12px' }}
+      labelStyle={{ padding: '8px 12px', backgroundColor: '#fafafa', width: '30%' }}
+    />
+  );
+}
+
+function formatFileSize(size: number | string): string {
+  if (typeof size !== 'number') return String(size);
+  
+  const units = ['字节', 'KB', 'MB', 'GB'];
+  let index = 0;
+  let fileSize = size;
+  
+  while (fileSize >= 1024 && index < units.length - 1) {
+    fileSize /= 1024;
+    index++;
+  }
+  
+  return `${fileSize.toFixed(index === 0 ? 0 : 1)} ${units[index]}`;
+}
+
+export const FileDetailModal: React.FC<Props> = ({ entry, loading, data, onClose }) => {
+  const { token } = theme.useToken();
+  
+  return (
+    <Modal
+      title={
+        <Space>
+          <InfoCircleOutlined style={{ color: token.colorPrimary }} />
+          <span>文件属性</span>
+          {entry && (
+            <Typography.Text type="secondary" style={{ fontSize: 14 }}>
+              - {entry.name}
+            </Typography.Text>
+          )}
+        </Space>
+      }
+      open={!!entry}
+      onCancel={onClose}
+      footer={null}
+      width={800}
+      styles={{
+        body: { padding: '20px 0px' }
+      }}
+    >
+      {loading ? (
+        <div style={{ textAlign: 'center', padding: 48 }}>
+          <Spin size="large" />
+          <div style={{ marginTop: 16, color: token.colorTextSecondary }}>加载文件信息...</div>
+        </div>
+      ) : data ? (
+        data.error ? (
+          <div style={{ textAlign: 'center', padding: 32 }}>
+            <Typography.Text type="danger" style={{ fontSize: 16 }}>
+              {data.error}
+            </Typography.Text>
+          </div>
+        ) : (
+          <div style={{ display: 'flex', gap: 16, alignItems: 'flex-start' }}>
+            {/* 左侧：基本信息 */}
+            <div style={{ flex: 1 }}>
+              <Card 
+                size="small"
+                title={
+                  <Space>
+                    {data.is_dir ? <FolderOutlined /> : <FileOutlined />}
+                    基本信息
+                  </Space>
+                }
+                style={{ borderRadius: 8, height: 'fit-content' }}
+              >
+                <Descriptions
+                  column={1}
+                  size="small"
+                  items={[
+                    {
+                      key: 'name',
+                      label: '名称',
+                      children: <Typography.Text strong>{data.name}</Typography.Text>
+                    },
+                    {
+                      key: 'type',
+                      label: '类型',
+                      children: (
+                        <Badge 
+                          status={data.is_dir ? 'processing' : 'default'} 
+                          text={data.type || (data.is_dir ? '文件夹' : '文件')}
+                        />
+                      )
+                    },
+                    {
+                      key: 'size',
+                      label: '大小',
+                      children: formatFileSize(data.size)
+                    },
+                    {
+                      key: 'mtime',
+                      label: '修改时间',
+                      children: data.mtime ? (
+                        typeof data.mtime === 'number' 
+                          ? new Date(data.mtime * 1000).toLocaleString('zh-CN')
+                          : data.mtime
+                      ) : '-'
+                    },
+                    {
+                      key: 'path',
+                      label: '路径',
+                      children: (
+                        <Typography.Text style={{ display: 'block', marginTop: 4 }}>
+                          <a
+                            href="#"
+                            onClick={(e) => {
+                              e.preventDefault();
+                              try {
+                                if (navigator.clipboard) {
+                                  navigator.clipboard.writeText(data.path).then(() => {
+                                    message.success('路径已复制到剪贴板');
+                                  }).catch(() => {
+                                    message.error('复制失败');
+                                  });
+                                } else {
+                                  const textarea = document.createElement('textarea');
+                                  textarea.value = data.path;
+                                  document.body.appendChild(textarea);
+                                  textarea.select();
+                                  const ok = document.execCommand('copy');
+                                  document.body.removeChild(textarea);
+                                  message[ok ? 'success' : 'error'](ok ? '路径已复制到剪贴板' : '复制失败');
+                                }
+                              } catch {
+                                message.error('复制失败');
+                              }
+                            }}
+                            style={{
+                              fontSize: 12,
+                              wordBreak: 'break-all',
+                              backgroundColor: token.colorFillAlter,
+                              padding: '4px 8px',
+                              borderRadius: 4,
+                              display: 'inline-block'
+                            }}
+                          >
+                            {data.path}
+                          </a>
+                        </Typography.Text>
+                      )
+                    }
+                  ]}
+                  contentStyle={{ 
+                    fontSize: 14,
+                    color: token.colorText
+                  }}
+                  labelStyle={{ 
+                    fontWeight: 500,
+                    color: token.colorTextSecondary,
+                    width: '30%'
+                  }}
+                />
+                {data.mode !== undefined && (
+                  <>
+                    <Divider style={{ margin: '12px 0' }} />
+                    <div>
+                      <span style={{ fontWeight: 500, color: token.colorTextSecondary }}>权限：</span>
+                      <Typography.Text code>{data.mode.toString(8)}</Typography.Text>
+                    </div>
+                  </>
+                )}
+              </Card>
+            </div>
+
+            {/* 右侧：EXIF 信息 */}
+            {data.exif && (
+              <div style={{ flex: 1 }}>
+                <Card 
+                  size="small"
+                  title={
+                    <Space>
+                      <CameraOutlined />
+                      EXIF信息
+                    </Space>
+                  }
+                  style={{ borderRadius: 8, height: 'fit-content' }}
+                >
+                  {renderExif(data.exif)}
+                </Card>
+              </div>
+            )}
+          </div>
+        )
+      ) : null}
+    </Modal>
+  );
+};
+
+export default FileDetailModal;

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

@@ -0,0 +1,41 @@
+import React from 'react';
+import { 
+  FileOutlined,
+  FileImageOutlined,
+  VideoCameraOutlined,
+  AudioOutlined,
+  FileTextOutlined,
+  FilePdfOutlined,
+  FileWordOutlined,
+  FileExcelOutlined,
+  FilePptOutlined,
+  FileZipOutlined,
+  CodeOutlined,
+  FileMarkdownOutlined,
+  SettingOutlined,
+  DatabaseOutlined,
+  FontSizeOutlined,
+} from '@ant-design/icons';
+
+export const getFileIcon = (fileName: string, size: number = 16) => {
+  const ext = fileName.split('.').pop()?.toLowerCase() || '';
+  const iconStyle: React.CSSProperties = { fontSize: size, marginRight: size === 16 ? 6 : 0 };
+
+  const make = (node: React.ReactNode, color: string) => React.cloneElement(node as any, { style: { ...iconStyle, color } });
+
+  if (['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico', 'tiff'].includes(ext)) return make(<FileImageOutlined />, '#52c41a');
+  if (['mp4', 'avi', 'mov', 'wmv', 'flv', 'mkv', 'webm', 'm4v', '3gp'].includes(ext)) return make(<VideoCameraOutlined />, '#fa541c');
+  if (['mp3', 'wav', 'flac', 'aac', 'ogg', 'wma', 'm4a'].includes(ext)) return make(<AudioOutlined />, '#722ed1');
+  if (['pdf'].includes(ext)) return make(<FilePdfOutlined />, '#f5222d');
+  if (['doc', 'docx'].includes(ext)) return make(<FileWordOutlined />, '#1890ff');
+  if (['xls', 'xlsx'].includes(ext)) return make(<FileExcelOutlined />, '#52c41a');
+  if (['ppt', 'pptx'].includes(ext)) return make(<FilePptOutlined />, '#fa8c16');
+  if (['zip', 'rar', '7z', 'tar', 'gz', 'bz2', 'xz'].includes(ext)) return make(<FileZipOutlined />, '#faad14');
+  if (['js','jsx','ts','tsx','vue','html','css','scss','less','json','xml','yaml','yml','py','java','cpp','c','h','php','rb','go','rs','swift','kt'].includes(ext)) return make(<CodeOutlined />, '#13c2c2');
+  if (['md', 'markdown'].includes(ext)) return make(<FileMarkdownOutlined />, '#1890ff');
+  if (['txt', 'log', 'ini', 'cfg', 'conf'].includes(ext)) return make(<FileTextOutlined />, '#8c8c8c');
+  if (['ttf', 'otf', 'woff', 'woff2', 'eot'].includes(ext)) return make(<FontSizeOutlined />, '#eb2f96');
+  if (['db', 'sqlite', 'sql'].includes(ext)) return make(<DatabaseOutlined />, '#fa541c');
+  if (['env', 'config', 'properties', 'toml'].includes(ext)) return make(<SettingOutlined />, '#faad14');
+  return make(<FileOutlined />, '#8c8c8c');
+};

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

@@ -0,0 +1,107 @@
+import React from 'react';
+import { Table, Dropdown, Button, Tooltip, theme } from 'antd';
+import { FolderFilled, MoreOutlined, EditOutlined, DeleteOutlined, AppstoreOutlined, FolderOpenOutlined } from '@ant-design/icons';
+import type { VfsEntry } from '../../../api/client';
+import { getFileIcon } from './FileIcons';
+import { getAppsForEntry, getDefaultAppForEntry } from '../../../apps/registry';
+
+interface FileListViewProps {
+  entries: VfsEntry[];
+  loading: boolean;
+  selectedEntries: string[];
+  onRowClick: (entry: VfsEntry, e: React.MouseEvent) => void;
+  onOpen: (entry: VfsEntry) => void;
+  onOpenWith: (entry: VfsEntry, appKey: string) => void;
+  onRename: (entry: VfsEntry) => void;
+  onDelete: (entry: VfsEntry) => void;
+  onContextMenu: (e: React.MouseEvent, entry: VfsEntry) => void;
+}
+
+export const FileListView: React.FC<FileListViewProps> = ({
+  entries,
+  loading,
+  selectedEntries,
+  onRowClick,
+  onOpen,
+  onOpenWith,
+  onRename,
+  onDelete,
+  onContextMenu,
+}) => {
+  const { token } = theme.useToken();
+
+  const columns = [
+    {
+      title: '名称',
+      dataIndex: 'name',
+      key: 'name',
+      render: (_: any, r: VfsEntry) => (
+        <span style={{ cursor: 'pointer', userSelect: 'none' }} onDoubleClick={() => onOpen(r)}>
+          {r.is_dir ? (
+            <FolderFilled style={{ color: token.colorPrimary, marginRight: 6 }} />
+          ) : (
+            getFileIcon(r.name, 16)
+          )}
+          {r.name}
+          {r.type === 'mount' && <Tooltip title="挂载点"><span style={{ marginLeft: 6, fontSize: 10, padding: '0 4px', border: `1px solid ${token.colorBorderSecondary}`, borderRadius: 4 }}>MOUNT</span></Tooltip>}
+        </span>
+      )
+    },
+    { title: '大小', dataIndex: 'size', width: 100, render: (v: number, r: VfsEntry) => r.is_dir ? '-' : v },
+    { title: '修改时间', dataIndex: 'mtime', width: 160, render: (v: number) => v ? new Date(v * 1000).toLocaleString() : '-' },
+    {
+      title: '操作',
+      key: 'actions',
+      width: 110,
+      render: (_: any, r: VfsEntry) => {
+        const apps = getAppsForEntry(r);
+        const defaultApp = getDefaultAppForEntry(r);
+        return (
+          <Dropdown
+            menu={{
+              items: [
+                (r.is_dir || apps.length > 0) ? { key: 'open', label: defaultApp ? `打开(${defaultApp.name})` : '打开', icon: <FolderOpenOutlined />, onClick: () => onOpen(r) } : null,
+                !r.is_dir && apps.length > 0 ? {
+                  key: 'openWith',
+                  label: '打开方式',
+                  icon: <AppstoreOutlined />,
+                  children: apps.map(a => ({
+                    key: 'openWith-' + a.key,
+                    label: a.name + (a.key === defaultApp?.key ? ' (默认)' : ''),
+                    onClick: () => onOpenWith(r, a.key)
+                  }))
+                } : null,
+                { key: 'rename', label: '重命名', icon: <EditOutlined />, disabled: r.type === 'mount', onClick: () => onRename(r) },
+                { key: 'delete', label: '删除', icon: <DeleteOutlined />, danger: true, disabled: r.type === 'mount', onClick: () => onDelete(r) }
+              ].filter(Boolean) as any[]
+            }}
+          >
+            <Button size="small" icon={<MoreOutlined />} />
+          </Dropdown>
+        );
+      }
+    }
+  ];
+
+  return (
+    <Table
+      className="fx-file-table"
+      rowKey={r => r.name}
+      dataSource={entries}
+      columns={columns as any}
+      loading={loading}
+      pagination={false}
+      onRow={(r) => ({
+        onClick: (e: any) => onRowClick(r, e),
+        onDoubleClick: () => onOpen(r),
+        onContextMenu: (e) => onContextMenu(e, r)
+      })}
+      rowClassName={(r) => selectedEntries.includes(r.name) ? 'row-selected' : ''}
+      rowSelection={{
+        selectedRowKeys: selectedEntries,
+        onChange: () => {
+        }
+      }}
+    />
+  );
+};

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

@@ -0,0 +1,155 @@
+import React, { useRef, useState, useEffect } from 'react';
+import { Tooltip, Spin, theme } from 'antd';
+import { FolderFilled, PictureOutlined } from '@ant-design/icons';
+import type { VfsEntry } from '../../../api/client';
+import { getFileIcon } from './FileIcons';
+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
+  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) => {
+  if (size < 1024) return size + ' B';
+  if (size < 1024 * 1024) return (size / 1024).toFixed(1) + ' KB';
+  if (size < 1024 * 1024 * 1024) return (size / 1024 / 1024).toFixed(1) + ' MB';
+  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 }) => {
+  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 [selecting, setSelecting] = useState(false);
+
+  useEffect(() => {
+    const onMove = (ev: MouseEvent) => {
+      if (!startRef.current) return;
+      const cx = ev.clientX;
+      const cy = ev.clientY;
+      const s = startRef.current;
+      const left = Math.min(s.x, cx);
+      const top = Math.min(s.y, cy);
+      const width = Math.abs(cx - s.x);
+      const height = Math.abs(cy - s.y);
+      setRect({ left, top, width, height });
+    };
+    const onUp = () => { // 不需要 MouseEvent 参数，避免未使用警告
+      if (!startRef.current) return;
+      setSelecting(false);
+      const r = rect;
+      if (r) {
+        // compute intersecting items
+        const container = containerRef.current;
+        if (container) {
+          const sel: string[] = [];
+          entries.forEach(ent => {
+            const el = itemRefs.current[ent.name];
+            if (!el) return;
+            const br = el.getBoundingClientRect();
+            const rr = { left: r.left, top: r.top, right: r.left + r.width, bottom: r.top + r.height };
+            const br2 = { left: br.left, top: br.top, right: br.right, bottom: br.bottom };
+            const intersect = !(br2.left > rr.right || br2.right < rr.left || br2.top > rr.bottom || br2.bottom < rr.top);
+            if (intersect) sel.push(ent.name);
+          });
+          if (sel.length > 0) onSelectRange(sel);
+        }
+      }
+      startRef.current = null;
+      setRect(null);
+      window.removeEventListener('mousemove', onMove);
+      window.removeEventListener('mouseup', onUp);
+    };
+    if (selecting) {
+      window.addEventListener('mousemove', onMove);
+      window.addEventListener('mouseup', onUp);
+    }
+    return () => {
+      window.removeEventListener('mousemove', onMove);
+      window.removeEventListener('mouseup', onUp);
+    };
+  }, [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
+    }
+    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();
+  };
+
+  return (
+    <div className="fx-grid" style={{ padding: 16 }} ref={containerRef} onMouseDown={handleMouseDown}>
+      {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 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(' ')}
+            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' }}
+          >
+            <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.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>
+          </div>
+        )
+      })}
+      {rect && (
+        <div
+          style={{
+            position: 'fixed',
+            left: rect.left,
+            top: rect.top,
+            width: rect.width,
+            height: rect.height,
+            border: '1px dashed rgba(0,0,0,0.4)',
+            background: 'rgba(0, 120, 212, 0.08)',
+            zIndex: 999
+          }}
+        />
+      )}
+      {loading && <div style={{ width:'100%', textAlign:'center', padding:40 }}><Spin /></div>}
+      {!loading && entries.length === 0 && <EmptyState isRoot={path==='/' } onCreateDir={onCreateDir} onGoUp={onGoUp} />}
+    </div>
+  );
+};

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

@@ -0,0 +1,118 @@
+import React, { useState } from 'react';
+import { Flex, Typography, Divider, Button, Space, Tooltip, Segmented, Breadcrumb, Input, theme } from 'antd';
+import { ArrowUpOutlined, ReloadOutlined, PlusOutlined, UploadOutlined, AppstoreOutlined, UnorderedListOutlined } from '@ant-design/icons';
+import type { ViewMode } from '../types';
+
+interface HeaderProps {
+  navKey: string;
+  path: string;
+  loading: boolean;
+  uploading: boolean;
+  viewMode: ViewMode;
+  onGoUp: () => void;
+  onNavigate: (path: string) => void;
+  onRefresh: () => void;
+  onCreateDir: () => void;
+  onUpload: () => void;
+  onSetViewMode: (mode: ViewMode) => void;
+}
+
+export const Header: React.FC<HeaderProps> = ({
+  navKey,
+  path,
+  loading,
+  uploading,
+  viewMode,
+  onGoUp,
+  onNavigate,
+  onRefresh,
+  onCreateDir,
+  onUpload,
+  onSetViewMode,
+}) => {
+  const { token } = theme.useToken();
+  const [editingPath, setEditingPath] = useState(false);
+  const [pathInputValue, setPathInputValue] = useState('');
+
+  const handlePathEdit = () => {
+    setEditingPath(true);
+    setPathInputValue(path);
+  };
+
+  const handlePathSubmit = () => {
+    const trimmed = pathInputValue.trim();
+    if (trimmed && trimmed !== path) {
+      onNavigate(trimmed);
+    }
+    setEditingPath(false);
+  };
+
+  const handlePathCancel = () => {
+    setEditingPath(false);
+    setPathInputValue('');
+  };
+
+  const renderBreadcrumb = () => {
+    if (editingPath) {
+      return (
+        <Input
+          size="small"
+          value={pathInputValue}
+          onChange={(e) => setPathInputValue(e.target.value)}
+          onPressEnter={handlePathSubmit}
+          onBlur={handlePathCancel}
+          onKeyDown={(e) => e.key === 'Escape' && handlePathCancel()}
+          autoFocus
+          style={{ flex: 1 }}
+        />
+      );
+    }
+
+    const breadcrumbItems = [
+      { key: 'root', title: <span style={{ cursor: 'pointer' }} onClick={() => onNavigate('/')}>Home</span> },
+      ...path.split('/').filter(Boolean).map((segment, index, arr) => {
+        const segmentPath = '/' + arr.slice(0, index + 1).join('/');
+        return {
+          key: segmentPath,
+          title: <span style={{ cursor: 'pointer' }} onClick={() => onNavigate(segmentPath)}>{segment}</span>
+        };
+      })
+    ];
+
+    return (
+      <div
+        style={{ cursor: 'pointer', padding: '4px 8px', borderRadius: token.borderRadius, transition: 'background-color 0.2s', flex: 1, overflow: 'hidden' }}
+        onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = token.colorFillTertiary; }}
+        onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent'; }}
+        onClick={handlePathEdit}
+      >
+        <Breadcrumb items={breadcrumbItems} separator="/" style={{ fontSize: 12 }} />
+      </div>
+    );
+  };
+
+  return (
+    <Flex align="center" justify="space-between" style={{ padding: '10px 16px', borderBottom: `1px solid ${token.colorBorderSecondary}`, gap: 12 }}>
+      <Flex align="center" gap={8} style={{ flexWrap: 'wrap', flex: 1, overflow: 'hidden' }}>
+        <Button size="small" icon={<ArrowUpOutlined />} onClick={onGoUp} disabled={path === '/'} />
+        <Typography.Text strong>{navKey}</Typography.Text>
+        <Divider type="vertical" />
+        {renderBreadcrumb()}
+      </Flex>
+      <Space size={8} wrap>
+        <Button size="small" icon={<ReloadOutlined />} onClick={onRefresh} loading={loading}>刷新</Button>
+        <Button size="small" icon={<PlusOutlined />} onClick={onCreateDir}>新建目录</Button>
+        <Button size="small" icon={<UploadOutlined />} loading={uploading} onClick={onUpload}>上传</Button>
+        <Segmented
+          size="small"
+          value={viewMode}
+          onChange={v => onSetViewMode(v as any)}
+          options={[
+            { label: <Tooltip title="网格"><AppstoreOutlined /></Tooltip>, value: 'grid' },
+            { label: <Tooltip title="列表"><UnorderedListOutlined /></Tooltip>, value: 'list' }
+          ]}
+        />
+      </Space>
+    </Flex>
+  );
+};

web/src/pages/FileExplorerPage/components/Modals/CreateDirModal.tsx

@@ -0,0 +1,41 @@
+import React, { useState, useEffect } from 'react';
+import { Modal, Input } from 'antd';
+
+interface CreateDirModalProps {
+  open: boolean;
+  onOk: (name: string) => void;
+  onCancel: () => void;
+}
+
+export const CreateDirModal: React.FC<CreateDirModalProps> = ({ open, onOk, onCancel }) => {
+  const [name, setName] = useState('');
+
+  useEffect(() => {
+    if (open) {
+      setName('');
+    }
+  }, [open]);
+
+  const handleOk = () => {
+    onOk(name);
+  };
+
+  return (
+    <Modal
+      title="新建目录"
+      open={open}
+      onOk={handleOk}
+      onCancel={onCancel}
+      okButtonProps={{ disabled: !name.trim() }}
+      destroyOnClose
+    >
+      <Input
+        placeholder="目录名称"
+        value={name}
+        onChange={e => setName(e.target.value)}
+        onPressEnter={handleOk}
+        autoFocus
+      />
+    </Modal>
+  );
+};