功能: Docker 一键自动更新 (#32)

功能: Docker 一键自动更新

.dockerignore

@@ -0,0 +1,26 @@
+# Dependencies
+web/node_modules/
+
+# Build artifacts
+server/bin/
+web/dist/
+
+# Data & logs
+data/
+*.db
+*.log
+
+# IDE & OS
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+
+# Git
+.git/
+.github/
+
+# Docker
+Dockerfile
+docker-compose*.yml

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.25'
           cache-dependency-path: server/go.sum
 
       - name: Build
@@ -36,7 +36,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: '18'
+          node-version: '20'
           cache: 'npm'
           cache-dependency-path: web/package-lock.json
 

.github/workflows/release.yml

@@ -1,63 +1,154 @@
+# 自动化发版流水线
+#
+# 触发方式：
+#   1. 推送 tag：git tag v1.2.3 && git push --tags
+#   2. 手动触发：GitHub Actions 页面 → Run workflow → 输入版本号
+#
+# 产出物：
+#   - GitHub Release：linux/amd64 + linux/arm64 预编译 tar.gz
+#   - Docker Hub：awuqing/backupx:latest + awuqing/backupx:v1.2.3（多架构）
+#
+# 前置配置：
+#   在仓库 Settings → Secrets → Actions 添加：
+#   - DOCKERHUB_USERNAME（Docker Hub 用户名）
+#   - DOCKERHUB_TOKEN（Docker Hub Access Token）
+
 name: Release
 
 on:
   push:
     tags:
       - 'v*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: '版本号（如 v1.2.3）'
+        required: true
+        type: string
 
 permissions:
   contents: write
+  packages: write
+
+# 统一版本号：tag 推送取 ref_name，手动触发取 inputs.version
+env:
+  VERSION: ${{ github.event.inputs.version || github.ref_name }}
 
 jobs:
-  release:
-    name: Build & Release
+  # ─── Job 1: 构建前端 ───
+  build-web:
+    name: Build Frontend
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+          cache-dependency-path: web/package-lock.json
+
+      - name: Install & Build
+        working-directory: web
+        run: |
+          npm ci
+          npm run build
+
+      - name: Upload frontend artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: web-dist
+          path: web/dist
+          retention-days: 1
+
+  # ─── Job 2: 预编译二进制 → GitHub Release ───
+  build-release:
+    name: Build ${{ matrix.goarch }}
+    needs: build-web
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        goos: [linux]
-        goarch: [amd64, arm64]
+        include:
+          - goos: linux
+            goarch: amd64
+          - goos: linux
+            goarch: arm64
     steps:
       - uses: actions/checkout@v4
 
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.25'
           cache-dependency-path: server/go.sum
 
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
+      - name: Download frontend artifact
+        uses: actions/download-artifact@v4
         with:
-          node-version: '18'
-          cache: 'npm'
-          cache-dependency-path: web/package-lock.json
+          name: web-dist
+          path: web/dist
 
-      - name: Build frontend
-        working-directory: web
-        run: |
-          npm ci
-          npm run build
-
-      - name: Build backend
+      - name: Build binary
         working-directory: server
         env:
           GOOS: ${{ matrix.goos }}
           GOARCH: ${{ matrix.goarch }}
-          CGO_ENABLED: 1
+          CGO_ENABLED: '0'
         run: |
-          go build -ldflags "-s -w -X main.version=${{ github.ref_name }}" -o ../backupx-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/backupx
+          go build \
+            -trimpath \
+            -ldflags "-s -w -X main.version=${{ env.VERSION }}" \
+            -o ../backupx \
+            ./cmd/backupx
 
       - name: Package release
         run: |
-          mkdir -p release
-          cp backupx-${{ matrix.goos }}-${{ matrix.goarch }} release/
-          cp -r web/dist release/web
-          cp server/config.example.yaml release/
-          cp deploy/install.sh release/ 2>/dev/null || true
-          cd release && tar czf ../backupx-${{ github.ref_name }}-${{ matrix.goos }}-${{ matrix.goarch }}.tar.gz .
+          ARCHIVE_NAME="backupx-${{ env.VERSION }}-${{ matrix.goos }}-${{ matrix.goarch }}"
+          mkdir -p "${ARCHIVE_NAME}"
+          cp backupx "${ARCHIVE_NAME}/"
+          cp -r web/dist "${ARCHIVE_NAME}/web"
+          cp server/config.example.yaml "${ARCHIVE_NAME}/"
+          cp deploy/install.sh "${ARCHIVE_NAME}/" 2>/dev/null || true
+          tar czf "${ARCHIVE_NAME}.tar.gz" "${ARCHIVE_NAME}"
 
-      - name: Upload Release Asset
+      - name: Upload to GitHub Release
         uses: softprops/action-gh-release@v2
         with:
-          files: backupx-${{ github.ref_name }}-${{ matrix.goos }}-${{ matrix.goarch }}.tar.gz
+          tag_name: ${{ env.VERSION }}
+          files: backupx-${{ env.VERSION }}-${{ matrix.goos }}-${{ matrix.goarch }}.tar.gz
           generate_release_notes: true
+
+  # ─── Job 3: Docker 多架构 → Docker Hub ───
+  build-docker:
+    name: Build & Push Docker
+    needs: build-web
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build & Push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          build-args: |
+            VERSION=${{ env.VERSION }}
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/backupx:latest
+            ${{ secrets.DOCKERHUB_USERNAME }}/backupx:${{ env.VERSION }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

Dockerfile

@@ -0,0 +1,93 @@
+# BackupX 多阶段构建
+#
+# 用法：
+#   国际构建（默认）：docker build -t backupx .
+#   国内加速构建：    docker build --build-arg USE_CHINA_MIRROR=true -t backupx .
+#   注入版本号：      docker build --build-arg VERSION=v1.2.3 -t backupx .
+
+# 全局构建参数
+ARG USE_CHINA_MIRROR=false
+
+
+# ---- Stage 1: Build frontend ----
+FROM node:20-alpine AS web-builder
+ARG USE_CHINA_MIRROR
+
+# 国内镜像：npm 使用淘宝源
+RUN if [ "$USE_CHINA_MIRROR" = "true" ]; then \
+      npm config set registry https://registry.npmmirror.com; \
+    fi
+
+WORKDIR /build/web
+COPY web/package.json web/package-lock.json ./
+RUN npm ci
+COPY web/ ./
+RUN npm run build
+
+
+# ---- Stage 2: Build backend ----
+FROM golang:1.25-alpine AS server-builder
+ARG USE_CHINA_MIRROR
+ARG VERSION=dev
+
+# 国内镜像：Go 模块使用七牛代理
+RUN if [ "$USE_CHINA_MIRROR" = "true" ]; then \
+      go env -w GOPROXY=https://goproxy.cn,direct; \
+    fi
+
+WORKDIR /build/server
+COPY server/go.mod server/go.sum ./
+RUN go mod download
+COPY server/ ./
+RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w -X main.version=${VERSION}" -o backupx ./cmd/backupx
+
+
+# ---- Stage 3: Production image ----
+FROM alpine:3.21
+ARG USE_CHINA_MIRROR
+
+# 国内镜像：Alpine apk 使用阿里云源
+RUN if [ "$USE_CHINA_MIRROR" = "true" ]; then \
+      sed -i 's|dl-cdn.alpinelinux.org|mirrors.aliyun.com|g' /etc/apk/repositories; \
+    fi
+
+RUN apk add --no-cache \
+    nginx \
+    tzdata \
+    ca-certificates \
+    docker-cli docker-cli-compose \
+    # Required by mysql/postgresql backup tasks
+    mysql-client \
+    postgresql16-client \
+    && rm -rf /var/cache/apk/*
+
+# Create app user
+RUN addgroup -S backupx && adduser -S -G backupx -h /app backupx
+
+# Copy backend binary
+COPY --from=server-builder /build/server/backupx /app/bin/backupx
+
+# Copy frontend static files
+COPY --from=web-builder /build/web/dist /app/web
+
+# Copy nginx config
+COPY deploy/docker/nginx.conf /etc/nginx/http.d/default.conf
+
+# Copy entrypoint
+COPY deploy/docker/entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+# Create data directories
+RUN mkdir -p /app/data /tmp/backupx && \
+    chown -R backupx:backupx /app /tmp/backupx
+
+# Nginx needs to write to these dirs
+RUN mkdir -p /var/lib/nginx/tmp /var/log/nginx && \
+    chown -R backupx:backupx /var/lib/nginx /var/log/nginx /run/nginx
+
+WORKDIR /app
+EXPOSE 8340
+
+VOLUME ["/app/data"]
+
+ENTRYPOINT ["/app/entrypoint.sh"]

Makefile

@@ -1,22 +1,25 @@
-.PHONY: build dev test clean
+.PHONY: build dev test clean docker docker-cn
 
-# 一次性构建前后端
+# 自动获取版本号（从 git tag 或 commit hash）
+VERSION ?= $(shell git describe --tags --always --dirty 2>/dev/null || echo dev)
+
+# ── 一键构建 ──
 build: build-server build-web
 
 build-server:
-	cd server && go build -o bin/backupx ./cmd/backupx
+	cd server && CGO_ENABLED=0 go build -trimpath -ldflags "-s -w -X main.version=$(VERSION)" -o bin/backupx ./cmd/backupx
 
 build-web:
 	cd web && npm run build
 
-# 开发模式（分别在两个终端运行）
+# ── 开发模式（分别在两个终端运行）──
 dev-server:
 	cd server && go run ./cmd/backupx
 
 dev-web:
 	cd web && npm run dev
 
-# 运行所有测试
+# ── 测试 ──
 test: test-server test-web
 
 test-server:
@@ -25,6 +28,14 @@ test-server:
 test-web:
 	cd web && npm run test
 
-# 清理构建产物
+# ── Docker 构建 ──
+docker:
+	docker build --build-arg VERSION=$(VERSION) -t backupx:$(VERSION) -t backupx:latest .
+
+# 国内加速构建（使用国内镜像源）
+docker-cn:
+	docker build --build-arg VERSION=$(VERSION) --build-arg USE_CHINA_MIRROR=true -t backupx:$(VERSION) -t backupx:latest .
+
+# ── 清理 ──
 clean:
 	rm -rf server/bin web/dist

README.md

@@ -2,405 +2,197 @@
   <a href="README_EN.md">English</a> | <strong>中文</strong>
 </p>
 <p align="center">
-  <h1 align="center">🛡️ BackupX</h1>
+  <h1 align="center">BackupX</h1>
   <p align="center">
-    <strong>Self-hosted Server Backup Management Platform with Web UI</strong>
-  </p>
-  <p align="center">
-    <a href="#features">Features</a> •
-    <a href="#quick-start">Quick Start</a> •
-    <a href="#configuration">Configuration</a> •
-    <a href="#architecture">Architecture</a> •
-    <a href="#cluster-mode">Cluster</a> •
-    <a href="#development">Development</a> •
-    <a href="#api-reference">API</a>
+    <strong>自托管服务器备份管理平台</strong><br>
+    一个二进制，一条命令，管好你所有服务器的备份。
   </p>
   <p align="center">
     <a href="https://github.com/Awuqing/BackupX/stargazers"><img src="https://img.shields.io/github/stars/Awuqing/BackupX?style=flat-square&color=f5c542" alt="Stars"></a>
     <a href="https://github.com/Awuqing/BackupX/releases"><img src="https://img.shields.io/github/v/release/Awuqing/BackupX?style=flat-square&color=brightgreen" alt="Release"></a>
-    <img src="https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat-square&logo=go" alt="Go">
+    <img src="https://img.shields.io/badge/Go-1.25+-00ADD8?style=flat-square&logo=go" alt="Go">
     <img src="https://img.shields.io/badge/React-18-61DAFB?style=flat-square&logo=react" alt="React">
-    <img src="https://img.shields.io/badge/TypeScript-5-3178C6?style=flat-square&logo=typescript" alt="TypeScript">
     <img src="https://img.shields.io/badge/SQLite-embedded-003B57?style=flat-square&logo=sqlite" alt="SQLite">
     <a href="LICENSE"><img src="https://img.shields.io/github/license/Awuqing/BackupX?style=flat-square" alt="License"></a>
-    <a href="https://github.com/Awuqing/BackupX/issues"><img src="https://img.shields.io/github/issues/Awuqing/BackupX?style=flat-square" alt="Issues"></a>
   </p>
 </p>
 
 ---
 
-BackupX 是一个面向 **Linux / macOS 服务器**的自托管备份管理平台。通过企业级 Web 控制台，轻松配置目录备份、数据库备份，并将备份文件安全存储到阿里云 OSS、腾讯云 COS、七牛云 Kodo、Google Drive、S3 兼容存储、WebDAV、FTP/FTPS 或本地磁盘。
+<table>
+<tr>
+<td width="50%"><img src="screenshots/dashboard.png" alt="仪表盘"></td>
+<td width="50%"><img src="screenshots/backup-tasks.png" alt="备份任务"></td>
+</tr>
+<tr>
+<td><img src="screenshots/storage-targets.png" alt="存储目标"></td>
+<td><img src="screenshots/backup-records.png" alt="备份记录"></td>
+</tr>
+</table>
 
-支持 **多节点集群管理**，可统一管控分布在不同服务器上的备份任务。
+## 功能亮点
 
-> **适用人群**：拥有 Linux 服务器的个人开发者 / 小团队 / 企业运维
+| 能力 | 说明 |
+|------|------|
+| **备份类型** | 文件/目录（多源路径）、MySQL、PostgreSQL、SQLite、SAP HANA |
+| **存储后端** | 阿里云 OSS、腾讯云 COS、七牛云、S3 兼容(AWS/MinIO/R2)、Google Drive、WebDAV、FTP/FTPS、本地磁盘 |
+| **自动调度** | Cron 定时 + 可视化编辑器 + 自动保留策略（按天数/份数清理） |
+| **多节点** | Master-Agent 集群，统一管理多台服务器的备份 |
+| **安全** | JWT + bcrypt + AES-256-GCM 加密配置 + 可选备份文件加密 + 审计日志 |
+| **通知** | 邮件 / Webhook / Telegram，备份成功或失败时自动推送 |
+| **部署** | 单二进制 + 内嵌 SQLite，Docker 一键启动，零外部依赖 |
 
-## Screenshots
+---
 
-### 登录页面
-![登录页面](screenshots/login.png)
+## 快速开始
 
-### 仪表盘
-![仪表盘](screenshots/dashboard.png)
+### 1. 安装
 
-### 备份任务
-![备份任务](screenshots/backup-tasks.png)
-
-### 备份记录
-![备份记录](screenshots/backup-records.png)
-
-### 存储目标
-![存储目标](screenshots/storage-targets.png)
-
-### 节点管理
-![节点管理](screenshots/nodes.png)
-
-### 通知配置
-![通知配置](screenshots/notifications.png)
-
-### 系统设置
-![系统设置](screenshots/settings.png)
-
-## Features
-
-### 📦 多种备份类型
-- **文件/目录** — 支持自定义排除规则（如 `node_modules`、`*.log`）
-- **MySQL** — 通过 `mysqldump` 原生工具
-- **SQLite** — 安全文件拷贝
-- **PostgreSQL** — 通过 `pg_dump` 原生工具
-- **SAP HANA** — 通过 `hdbsql` 原生工具（支持多租户数据库）
-
-### ☁️ 多云存储后端
-| 厂商 | 类型 | 说明 |
-|------|------|------|
-| 🇨🇳 **阿里云 OSS** | `aliyun_oss` | 自动组装 Endpoint，支持内网传输 |
-| 🇨🇳 **腾讯云 COS** | `tencent_cos` | 自动组装 Endpoint |
-| 🇨🇳 **七牛云 Kodo** | `qiniu_kodo` | 6 大区域精确映射 |
-| 🌍 **S3 Compatible** | `s3` | AWS S3 / MinIO / Cloudflare R2 等 |
-| 🌍 **Google Drive** | `google_drive` | 完整 OAuth 2.0 授权流程 |
-| 🌍 **WebDAV** | `webdav` | 坚果云 / Nextcloud 等 |
-| 🌍 **FTP / FTPS** | `ftp` | 标准 FTP 协议，支持 Explicit TLS 加密 |
-| 💾 **本地磁盘** | `local_disk` | 备份到服务器本地目录 |
-
-> 国内云厂商仅需填写 **Region** 和 **AccessKey**，系统自动完成 Endpoint 组装，底层复用 S3 引擎零额外依赖。
-
-### 🖥️ 集群管理 (Master-Agent)
-- **节点管理** — 注册远程服务器节点，Token 认证
-- **本机节点** — 自动创建，单机用户零感知升级
-- **目录浏览** — 可视化文件树选择备份源路径，告别手动输入
-- **Agent 心跳** — 节点在线状态实时监控
-- **任务标签** — 按标签/节点分类管理备份任务
-
-### ⏰ 自动化与调度
-- Cron 表达式定时调度
-- 可视化 Cron 编辑器
-- 自动保留策略（按天数 / 按份数过期清理）
-- 最大并发备份数限制
-
-### 🔐 安全
-- JWT 认证 + bcrypt 密码存储
-- AES-256-GCM 加密存储敏感配置（数据库密码、OAuth Token）
-- 可选备份文件加密
-- 登录限流防暴力破解
-- 节点 Token 认证（一次性显示，安全传输）
-
-### 📊 监控与通知
-- 仪表盘统计（成功率、存储用量、备份趋势图表）
-- 邮件 / Webhook / Telegram 通知
-- 实时备份执行日志 (SSE)
-
-### 🌐 其他
-- 中英文国际化 (i18n)
-- 零外部依赖（内嵌 SQLite，单二进制部署）
-- systemd 服务支持
-
-## Quick Start
-
-### 从源码构建
+**Docker（推荐，无需克隆仓库）：**
 
 ```bash
-# 克隆项目
-git clone https://github.com/Awuqing/BackupX.git
-cd BackupX
+# 创建 docker-compose.yml 后一键启动
+docker compose up -d
 
-# 一键构建前后端
-make build
-
-# 启动后端服务（默认监听 :8340）
-cd server && ./bin/backupx
+# 或直接运行
+docker run -d --name backupx -p 8340:8340 -v backupx-data:/app/data awuqing/backupx:latest
 ```
 
-### 访问 Web UI
+> Docker Hub 镜像：[`awuqing/backupx`](https://hub.docker.com/r/awuqing/backupx)，支持 linux/amd64 和 linux/arm64。
 
-打开浏览器访问 `http://your-server:8340`，首次使用会引导您创建管理员账户。
-
-## Configuration
-
-配置文件路径默认为 `./config.yaml`，也可通过环境变量 `BACKUPX_` 前缀覆盖。
+<details>
+<summary>docker-compose.yml 参考</summary>
 
 ```yaml
-# config.yaml
-server:
-  host: "0.0.0.0"
-  port: 8340
-  mode: "release"              # debug | release
+services:
+  backupx:
+    image: awuqing/backupx:latest
+    container_name: backupx
+    restart: unless-stopped
+    ports:
+      - "8340:8340"
+    volumes:
+      - backupx-data:/app/data
+      # 挂载需要备份的宿主机目录（按需添加）：
+      # - /var/www:/mnt/www:ro
+      # - /etc/nginx:/mnt/nginx-conf:ro
+    environment:
+      - TZ=Asia/Shanghai
 
-database:
-  path: "./data/backupx.db"    # SQLite 数据库路径
-
-security:
-  jwt_secret: ""               # 留空则自动生成
-  jwt_expire: "24h"
-  encryption_key: ""           # AES 加密密钥，留空自动生成
-
-backup:
-  temp_dir: "/tmp/backupx"     # 备份临时文件目录
-  max_concurrent: 2            # 最大并发备份数
-
-log:
-  level: "info"                # debug | info | warn | error
-  file: "./data/backupx.log"
-  max_size: 100                # 日志文件大小上限 (MB)
-  max_backups: 3               # 保留旧日志文件数
-  max_age: 30                  # 日志保留天数
+volumes:
+  backupx-data:
 ```
 
-> 💡 `jwt_secret` 和 `encryption_key` 首次启动时自动生成并持久化到数据库，无需手动配置。
+</details>
 
-## Architecture
+**预编译包（裸机部署）：**
 
-```
-                        ┌─────────────────────┐
-                        │   Nginx (反向代理)    │
-                        │  / → 前端静态文件    │
-                        │  /api → :8340       │
-                        └─────────┬───────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────┐
-│              BackupX Master (Go API Server)           │
-│                      :8340                            │
-│                                                      │
-│  ┌──────┐  ┌────────────┐  ┌───────────────────────┐│
-│  │ Auth │  │Backup Engine│  │  Storage Registry     ││
-│  └──────┘  └──────┬─────┘  │  ┌─────────────────┐  ││
-│                   │        │  │ Aliyun OSS       │  ││
-│  ┌──────────┐    │        │  │ Tencent COS      │  ││
-│  │ Cron     │◄───┘        │  │ Qiniu Kodo       │  ││
-│  │Scheduler │             │  │ S3 Compatible    │  ││
-│  └──────────┘             │  │ Google Drive     │  ││
-│                           │  │ WebDAV           │  ││
-│                           │  │ FTP / FTPS       │  ││
-│  ┌──────────┐             │  │ Local Disk       │  ││
-│  │ Notify   │             │  └─────────────────┘  ││
-│  │ Module   │             └───────────────────────┘│
-│  └──────────┘                                      │
-│                                                      │
-│  ┌──────────────┐   ┌────────────────────┐          │
-│  │ Node Manager │   │ SQLite (backupx.db)│          │
-│  └──────┬───────┘   └────────────────────┘          │
-└─────────┼────────────────────────────────────────────┘
-          │ Heartbeat / Task Dispatch
-          ▼
-┌──────────────────┐  ┌──────────────────┐
-│   Agent Node A   │  │   Agent Node B   │
-│   (远程服务器)    │  │   (远程服务器)    │
-└──────────────────┘  └──────────────────┘
-```
-
-### 技术栈
-
-| 组件 | 技术 |
-|------|------|
-| **后端** | Go · Gin · GORM · SQLite · robfig/cron |
-| **前端** | React 18 · TypeScript · ArcoDesign · Vite · Zustand · ECharts |
-| **存储** | AWS SDK v2 (S3/OSS/COS/Kodo) · Google Drive API v3 · gowebdav · jlaffaye/ftp |
-| **安全** | JWT · bcrypt · AES-256-GCM |
-| **日志** | zap + lumberjack (自动轮转) |
-
-## Cluster Mode
-
-BackupX 支持 **Master-Agent** 模式，可管理多台服务器的备份任务。
-
-### 工作原理
-
-1. **Master** 为运行 BackupX Web 控制台的主控服务器
-2. **Agent** 部署在需要备份的远程服务器上
-3. Agent 启动后通过 Token 向 Master 注册并定期发送心跳
-4. Master 将备份任务下发至对应 Agent 执行
-
-### 添加节点
+从 [Releases](https://github.com/Awuqing/BackupX/releases) 下载对应平台的压缩包：
 
 ```bash
-# 在 Web 控制台 → 节点管理 → 添加节点
-# 系统将生成一个唯一的 64 位十六进制 Token
-
-# 在远程服务器上配置 Agent 启动参数
-./backupx-agent --master http://master-server:8340 --token <your-token>
+tar xzf backupx-v*-linux-amd64.tar.gz && cd backupx-*
+sudo ./install.sh        # 自动配置 systemd + Nginx
 ```
 
-### 目录探针 API
-
-Master 提供 `GET /api/nodes/:id/fs/list?path=/` 接口，可远程浏览节点的文件系统目录。前端在创建备份任务的"源路径"输入时可使用树形选择器直接浏览目标机器的目录结构。
-
-## Project Structure
-
-```
-BackupX/
-├── server/                        # Go 后端
-│   ├── cmd/backupx/               #   程序入口
-│   ├── internal/
-│   │   ├── app/                   #   应用组装 (DI)
-│   │   ├── apperror/              #   统一错误类型
-│   │   ├── backup/                #   备份引擎 (file/mysql/sqlite/pgsql/saphana)
-│   │   │   └── retention/         #     保留策略
-│   │   ├── config/                #   配置加载 (viper)
-│   │   ├── database/              #   数据库初始化 + 迁移
-│   │   ├── http/                  #   HTTP 处理器 + 路由 + 中间件
-│   │   ├── httpapi/               #   HTTP API 辅助工具
-│   │   ├── logger/                #   日志初始化 (zap + lumberjack)
-│   │   ├── model/                 #   GORM 数据模型
-│   │   ├── notify/                #   通知 (email/webhook/telegram)
-│   │   ├── repository/            #   数据访问层
-│   │   ├── scheduler/             #   Cron 调度器
-│   │   ├── security/              #   JWT + 限流
-│   │   ├── service/               #   业务逻辑层
-│   │   └── storage/               #   存储后端 (插件化接口)
-│   │       ├── aliyun/            #     阿里云 OSS
-│   │       ├── tencent/           #     腾讯云 COS
-│   │       ├── qiniu/             #     七牛云 Kodo
-│   │       ├── s3/                #     S3 Compatible 核心
-│   │       ├── s3provider/        #     S3 Provider 辅助
-│   │       ├── googledrive/       #     Google Drive
-│   │       ├── webdav/            #     WebDAV 核心
-│   │       ├── webdavprovider/    #     WebDAV Provider 辅助
-│   │       ├── localdisk/         #     本地磁盘
-│   │       ├── ftp/               #     FTP / FTPS
-│   │       └── codec/             #     配置编解码
-│   └── pkg/                       #   工具包 (compress/crypto/response)
-├── web/                           # React 前端
-│   └── src/
-│       ├── components/            #   通用组件 (CronEditor/FormDrawer/...)
-│       ├── hooks/                 #   自定义 Hooks
-│       ├── layouts/               #   布局组件 (AppLayout)
-│       ├── pages/                 #   页面模块
-│       │   ├── dashboard/         #     仪表盘
-│       │   ├── backup-tasks/      #     备份任务
-│       │   ├── backup-records/    #     备份记录
-│       │   ├── storage-targets/   #     存储目标
-│       │   ├── nodes/             #     节点管理
-│       │   ├── notifications/     #     通知配置
-│       │   ├── settings/          #     系统设置
-│       │   └── login/             #     登录页
-│       ├── services/              #   API 请求封装
-│       ├── stores/                #   Zustand 状态管理
-│       ├── styles/                #   全局样式
-│       ├── types/                 #   TypeScript 类型定义
-│       ├── utils/                 #   工具函数
-│       ├── locales/               #   i18n 语言包 (zh-CN / en-US)
-│       └── router/                #   路由配置
-├── deploy/                        # 部署配置
-│   ├── nginx.conf                 #   Nginx 参考配置
-│   ├── backupx.service            #   systemd 服务单元
-│   └── install.sh                 #   一键安装脚本
-├── .github/                       # GitHub 配置
-│   ├── workflows/ci.yml           #   CI 工作流
-│   ├── workflows/release.yml      #   Release 工作流
-│   └── ISSUE_TEMPLATE/            #   Issue 模板
-└── Makefile                       # 构建命令
-```
-
-## Development
-
-### 前置条件
-
-- **Go** ≥ 1.21
-- **Node.js** ≥ 18
-- **npm**
-
-### 开发模式
+**从源码构建：**
 
 ```bash
-# 终端 1：启动后端 (热重载需配合 air)
-make dev-server
-
-# 终端 2：启动前端 (Vite HMR)
-make dev-web
+git clone https://github.com/Awuqing/BackupX.git && cd BackupX
+make build               # 构建前后端
+make docker-cn           # 或用国内镜像构建 Docker（goproxy.cn / npmmirror / 阿里云 apk）
 ```
 
-### 运行测试
+### 2. 打开控制台
+
+浏览器访问 `http://your-server:8340`，首次打开会引导创建管理员账户。
+
+### 3. 添加存储目标
+
+进入 **存储目标** 页面，点击 **添加**，选择存储类型并填写凭证：
+
+| 存储类型 | 需要填写 |
+|---------|---------|
+| 阿里云 OSS | Region + AccessKey ID/Secret + Bucket |
+| 腾讯云 COS | Region + SecretId/SecretKey + Bucket（格式 `name-appid`） |
+| 七牛云 Kodo | Region + AccessKey/SecretKey + Bucket |
+| S3 兼容 | Endpoint + AccessKey + Bucket |
+| Google Drive | Client ID/Secret → 点击授权完成 OAuth |
+| WebDAV | 服务器地址 + 用户名/密码 |
+| FTP | 主机 + 端口 + 用户名/密码 |
+| 本地磁盘 | 目标目录路径 |
+
+> 国内云厂商只需填 Region 和 AccessKey，系统自动组装 Endpoint。
+
+添加后点击 **测试连接** 确认配置正确。
+
+### 4. 创建备份任务
+
+进入 **备份任务** 页面，点击 **新建**，三步完成：
+
+1. **基础信息** — 任务名称、备份类型、Cron 表达式（留空则仅手动执行）
+2. **源配置** — 文件备份选择源路径（支持多个）、数据库备份填写连接信息
+3. **存储与策略** — 选择存储目标、压缩策略、保留天数、是否加密
+
+保存后可以点击 **立即执行** 测试，在 **备份记录** 页面实时查看执行日志。
+
+### 5. 配置通知（可选）
+
+进入 **通知配置** 页面，支持邮件、Webhook、Telegram 三种方式，可分别配置成功/失败时是否推送。
+
+---
+
+## 部署指南
+
+### Docker 部署
 
 ```bash
-# 运行全部测试
-make test
-
-# 仅后端
-make test-server    # go test ./...
-
-# 仅前端
-make test-web       # npm run test
+docker compose up -d     # 使用上方的 docker-compose.yml
 ```
 
-### 构建
+备份宿主机目录时需要挂载路径（在 docker-compose.yml 的 `volumes` 中添加）：
+
+```yaml
+volumes:
+  - backupx-data:/app/data
+  - /var/www:/mnt/www:ro              # 挂载需要备份的目录
+  - /etc/nginx:/mnt/nginx-conf:ro     # 可以挂载多个
+```
+
+通过环境变量调整配置：
+
+```yaml
+environment:
+  - TZ=Asia/Shanghai
+  - BACKUPX_LOG_LEVEL=debug
+  - BACKUPX_BACKUP_MAX_CONCURRENT=4
+```
+
+### 裸机部署
 
 ```bash
-# 构建前后端
+# 使用预编译包
+tar xzf backupx-v*-linux-amd64.tar.gz && cd backupx-*
+sudo ./install.sh
+
+# 或从源码
 make build
-
-# 清理构建产物
-make clean
-```
-
-## Deployment
-
-### 一键安装 (推荐)
-
-```bash
-# 先构建
-make build
-
-# 以 root 执行安装脚本
 sudo ./deploy/install.sh
 ```
 
-安装脚本将自动：
-1. 创建 `backupx` 系统用户
-2. 安装二进制到 `/opt/backupx/bin/`
-3. 部署前端到 `/opt/backupx/web/`
-4. 生成配置文件 `/etc/backupx/config.yaml`
-5. 注册并启动 systemd 服务
-6. 配置 Nginx 反向代理（如已安装）
+安装脚本自动完成：创建系统用户 → 安装二进制到 `/opt/backupx/` → 配置 systemd → 配置 Nginx 反向代理。
 
-### 手动部署
-
-```bash
-# 1. 构建
-cd server && go build -o backupx ./cmd/backupx
-cd ../web && npm run build
-
-# 2. 部署文件
-scp server/backupx your-server:/opt/backupx/bin/
-scp -r web/dist/ your-server:/opt/backupx/web/
-scp server/config.example.yaml your-server:/etc/backupx/config.yaml
-
-# 3. 启动
-ssh your-server '/opt/backupx/bin/backupx -config /etc/backupx/config.yaml'
-```
-
-### Nginx 配置示例
+### Nginx 反向代理（裸机部署时）
 
 ```nginx
 server {
     listen 80;
     server_name backup.example.com;
 
-    # 前端静态文件
     location / {
         root /opt/backupx/web;
         try_files $uri $uri/ /index.html;
     }
 
-    # API 反向代理
     location /api/ {
         proxy_pass http://127.0.0.1:8340;
         proxy_set_header Host $host;
@@ -409,89 +201,122 @@ server {
 }
 ```
 
-## API Reference
+### 配置文件
 
-所有 API 均以 `/api` 为前缀，使用 JWT Bearer Token 认证（除特殊标注外）。
+配置文件路径 `./config.yaml`，也可通过 `BACKUPX_` 前缀环境变量覆盖：
+
+```yaml
+server:
+  port: 8340
+database:
+  path: "./data/backupx.db"
+security:
+  jwt_secret: ""          # 留空自动生成并持久化到数据库
+  encryption_key: ""      # 留空自动生成
+backup:
+  temp_dir: "/tmp/backupx"
+  max_concurrent: 2
+log:
+  level: "info"           # debug | info | warn | error
+  file: "./data/backupx.log"
+```
+
+### 密码重置
+
+忘记管理员密码时通过 CLI 重置：
+
+```bash
+# 裸机
+./backupx reset-password --username admin --password newpass123
+
+# Docker
+docker exec -it backupx /app/bin/backupx reset-password --username admin --password newpass123
+```
+
+---
+
+## 多节点集群
+
+BackupX 支持 Master-Agent 模式管理多台服务器：
+
+1. Web 控制台 → **节点管理** → **添加节点**，系统生成 Token
+2. 在远程服务器部署 Agent 并使用 Token 连接 Master
+3. 创建备份任务时选择对应节点，Master 自动下发任务
+
+创建文件备份任务时，可通过可视化目录浏览器远程选择 Agent 节点上的目录，无需手动输入路径。
+
+---
+
+## 开发指南
+
+**环境要求：** Go >= 1.25 · Node.js >= 20 · npm
+
+```bash
+# 开发模式
+make dev-server          # 终端 1：后端（默认 :8340）
+make dev-web             # 终端 2：前端（Vite HMR）
+
+# 测试
+make test                # 运行全部测试
+
+# 构建
+make build               # 前后端一起构建
+make docker              # Docker 构建
+make docker-cn           # 国内 Docker 构建（镜像加速）
+```
+
+### 发版
+
+```bash
+git tag v1.2.3 && git push --tags
+# GitHub Actions 自动：编译双架构二进制 → 发布 GitHub Release → 推送 Docker Hub 镜像
+```
+
+也可在 GitHub Actions 页面手动触发 Release workflow。
+
+---
+
+## API 参考
+
+所有接口以 `/api` 为前缀，使用 JWT Bearer Token 认证。
 
 | 模块 | 端点 | 说明 |
 |------|------|------|
-| **认证** | `POST /api/auth/setup` | 首次初始化管理员 |
-| | `POST /api/auth/login` | 登录获取 Token |
-| | `POST /api/auth/logout` | 登出 |
-| | `GET /api/auth/profile` | 当前用户信息 |
-| | `PUT /api/auth/password` | 修改密码 |
-| **备份任务** | `GET/POST /api/backup/tasks` | 任务列表 / 创建 |
-| | `GET/PUT/DELETE /api/backup/tasks/:id` | 详情 / 更新 / 删除 |
-| | `PUT /api/backup/tasks/:id/toggle` | 启用/禁用 |
-| | `POST /api/backup/tasks/:id/run` | 手动触发执行 |
-| **备份记录** | `GET /api/backup/records` | 记录列表 (支持筛选) |
-| | `GET /api/backup/records/:id` | 记录详情 |
-| | `GET /api/backup/records/:id/logs/stream` | 实时执行日志 (SSE) |
-| | `GET /api/backup/records/:id/download` | 下载备份文件 |
-| | `POST /api/backup/records/:id/restore` | 恢复备份 |
-| **存储目标** | `GET/POST /api/storage-targets` | 存储列表 / 添加 |
-| | `GET/PUT/DELETE /api/storage-targets/:id` | 详情 / 更新 / 删除 |
-| | `POST /api/storage-targets/test` | 测试连接 |
-| | `POST /api/storage-targets/:id/test` | 测试已保存连接 |
-| | `GET /api/storage-targets/:id/usage` | 查询用量 |
-| **节点管理** | `GET/POST /api/nodes` | 节点列表 / 添加 |
-| | `GET/DELETE /api/nodes/:id` | 详情 / 删除 |
-| | `GET /api/nodes/:id/fs/list` | 目录浏览 |
-| | `POST /api/agent/heartbeat` | Agent 心跳 ⚡ |
-| **通知** | `GET/POST /api/notifications` | 通知列表 / 添加 |
-| | `POST /api/notifications/test` | 测试通知 |
-| | `POST /api/notifications/:id/test` | 测试已保存通知 |
-| **仪表盘** | `GET /api/dashboard/stats` | 概览统计 |
-| | `GET /api/dashboard/timeline` | 备份趋势时间线 |
-| **系统** | `GET /api/system/info` | 系统信息 (版本/磁盘) |
-| | `GET/PUT /api/settings` | 系统设置读写 |
+| **认证** | `POST /auth/setup` | 初始化管理员 |
+| | `POST /auth/login` | 登录 |
+| | `PUT /auth/password` | 修改密码 |
+| **备份任务** | `GET\|POST /backup/tasks` | 列表 / 创建 |
+| | `GET\|PUT\|DELETE /backup/tasks/:id` | 详情 / 更新 / 删除 |
+| | `PUT /backup/tasks/:id/toggle` | 启用/禁用 |
+| | `POST /backup/tasks/:id/run` | 手动执行 |
+| **备份记录** | `GET /backup/records` | 列表（支持筛选） |
+| | `GET /backup/records/:id/logs/stream` | 实时日志 (SSE) |
+| | `GET /backup/records/:id/download` | 下载 |
+| | `POST /backup/records/:id/restore` | 恢复 |
+| **存储目标** | `GET\|POST /storage-targets` | 列表 / 添加 |
+| | `POST /storage-targets/test` | 测试连接 |
+| **节点** | `GET\|POST /nodes` | 列表 / 添加 |
+| | `GET /nodes/:id/fs/list` | 目录浏览 |
+| **通知** | `GET\|POST /notifications` | 列表 / 添加 |
+| **仪表盘** | `GET /dashboard/stats` | 概览统计 |
+| **审计日志** | `GET /audit-logs` | 操作审计 |
+| **系统** | `GET /system/info` | 系统信息 |
 
-> ⚡ `POST /api/agent/heartbeat` 为公开端点，使用 Node Token 认证而非 JWT。
+---
 
-## 云存储配置指南
+## 技术栈
 
-### 阿里云 OSS
-
-1. 登录[阿里云控制台](https://oss.console.aliyun.com/)，创建 Bucket
-2. 前往 RAM 控制台创建 AccessKey
-3. 在 BackupX 添加存储目标时选择"阿里云 OSS"
-4. 填写 Region（如 `cn-hangzhou`）和 AccessKey，系统自动组装 Endpoint
-
-### 腾讯云 COS
-
-1. 登录[腾讯云控制台](https://console.cloud.tencent.com/cos)，创建存储桶
-2. 前往 API 密钥管理创建 SecretId/SecretKey
-3. Bucket 名称格式为 `BucketName-APPID`（如 `backup-1250000000`）
-
-### 七牛云 Kodo
-
-1. 登录[七牛云控制台](https://portal.qiniu.com/)，创建存储空间
-2. 支持区域：`z0`(华东) / `cn-east-2`(华东-浙江2) / `z1`(华北) / `z2`(华南) / `na0`(北美) / `as0`(东南亚)
-
-### Google Drive
-
-1. 前往 [Google Cloud Console](https://console.cloud.google.com/) 创建项目
-2. 启用 **Google Drive API**
-3. 创建 **OAuth 2.0 客户端 ID**（Web 应用类型）
-4. 添加重定向 URI：`http://your-server/api/storage-targets/google-drive/callback`
-5. 在 BackupX 存储管理页面填入 Client ID / Secret，点击授权
+| 组件 | 技术 |
+|------|------|
+| **后端** | Go · Gin · GORM · SQLite · robfig/cron |
+| **前端** | React 18 · TypeScript · ArcoDesign · Vite · Zustand · ECharts |
+| **存储** | AWS SDK v2 · Google Drive API v3 · gowebdav · jlaffaye/ftp |
+| **安全** | JWT · bcrypt · AES-256-GCM |
 
 ## Contributing
 
 欢迎提交 Issue 和 Pull Request！
 
-1. Fork 本项目
-2. 创建功能分支 (`git checkout -b feature/amazing-feature`)
-3. 提交更改 (`git commit -m 'Add amazing feature'`)
-4. 推送到分支 (`git push origin feature/amazing-feature`)
-5. 创建 Pull Request
-
 ## License
 
-本项目采用 [Apache License 2.0](LICENSE) 开源协议。
-
----
-
-<p align="center">
-  Made with ❤️ for self-hosters
-</p>
+[Apache License 2.0](LICENSE)

README_EN.md

@@ -2,406 +2,195 @@
   <strong>English</strong> | <a href="README.md">中文</a>
 </p>
 <p align="center">
-  <h1 align="center">🛡️ BackupX</h1>
+  <h1 align="center">BackupX</h1>
   <p align="center">
-    <strong>Self-hosted Server Backup Management Platform with Web UI</strong>
-  </p>
-  <p align="center">
-    <a href="#features">Features</a> •
-    <a href="#quick-start">Quick Start</a> •
-    <a href="#configuration">Configuration</a> •
-    <a href="#architecture">Architecture</a> •
-    <a href="#cluster-mode">Cluster</a> •
-    <a href="#development">Development</a> •
-    <a href="#api-reference">API</a>
+    <strong>Self-hosted Server Backup Management Platform</strong><br>
+    One binary, one command — manage all your server backups.
   </p>
   <p align="center">
     <a href="https://github.com/Awuqing/BackupX/stargazers"><img src="https://img.shields.io/github/stars/Awuqing/BackupX?style=flat-square&color=f5c542" alt="Stars"></a>
     <a href="https://github.com/Awuqing/BackupX/releases"><img src="https://img.shields.io/github/v/release/Awuqing/BackupX?style=flat-square&color=brightgreen" alt="Release"></a>
-    <img src="https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat-square&logo=go" alt="Go">
+    <img src="https://img.shields.io/badge/Go-1.25+-00ADD8?style=flat-square&logo=go" alt="Go">
     <img src="https://img.shields.io/badge/React-18-61DAFB?style=flat-square&logo=react" alt="React">
-    <img src="https://img.shields.io/badge/TypeScript-5-3178C6?style=flat-square&logo=typescript" alt="TypeScript">
     <img src="https://img.shields.io/badge/SQLite-embedded-003B57?style=flat-square&logo=sqlite" alt="SQLite">
     <a href="LICENSE"><img src="https://img.shields.io/github/license/Awuqing/BackupX?style=flat-square" alt="License"></a>
-    <a href="https://github.com/Awuqing/BackupX/issues"><img src="https://img.shields.io/github/issues/Awuqing/BackupX?style=flat-square" alt="Issues"></a>
   </p>
 </p>
 
 ---
 
-BackupX is a self-hosted backup management platform for **Linux / macOS servers**. Through an enterprise-grade Web console, you can easily configure directory backups, database backups, and securely store backup files to Alibaba Cloud OSS, Tencent Cloud COS, Qiniu Cloud Kodo, Google Drive, S3-compatible storage, WebDAV, FTP/FTPS, or local disk.
+<table>
+<tr>
+<td width="50%"><img src="screenshots/dashboard.png" alt="Dashboard"></td>
+<td width="50%"><img src="screenshots/backup-tasks.png" alt="Backup Tasks"></td>
+</tr>
+<tr>
+<td><img src="screenshots/storage-targets.png" alt="Storage Targets"></td>
+<td><img src="screenshots/backup-records.png" alt="Backup Records"></td>
+</tr>
+</table>
 
-Supports **multi-node cluster management** for unified control of backup tasks across different servers.
+## Highlights
 
-> **For**: Individual developers / small teams / DevOps with Linux servers
+| Capability | Details |
+|-----------|---------|
+| **Backup Types** | Files/Directories (multi-source), MySQL, PostgreSQL, SQLite, SAP HANA |
+| **Storage Backends** | Alibaba Cloud OSS, Tencent COS, Qiniu Kodo, S3-compatible (AWS/MinIO/R2), Google Drive, WebDAV, FTP/FTPS, Local Disk |
+| **Scheduling** | Cron-based scheduling + visual editor + auto-retention policy (by days/count) |
+| **Multi-Node** | Master-Agent cluster for managing backups across multiple servers |
+| **Security** | JWT + bcrypt + AES-256-GCM encrypted config + optional backup encryption + audit logs |
+| **Notifications** | Email / Webhook / Telegram — push on success or failure |
+| **Deployment** | Single binary + embedded SQLite, Docker one-click, zero external dependencies |
 
-## Screenshots
-
-### Login
-![Login](screenshots/login.png)
-
-### Dashboard
-![Dashboard](screenshots/dashboard.png)
-
-### Backup Tasks
-![Backup Tasks](screenshots/backup-tasks.png)
-
-### Backup Records
-![Backup Records](screenshots/backup-records.png)
-
-### Storage Targets
-![Storage Targets](screenshots/storage-targets.png)
-
-### Node Management
-![Node Management](screenshots/nodes.png)
-
-### Notification Settings
-![Notification Settings](screenshots/notifications.png)
-
-### System Settings
-![System Settings](screenshots/settings.png)
-
-## Features
-
-### 📦 Multiple Backup Types
-- **Files / Directories** — Custom exclude rules (e.g. `node_modules`, `*.log`)
-- **MySQL** — Via native `mysqldump` tool
-- **SQLite** — Safe file copy
-- **PostgreSQL** — Via native `pg_dump` tool
-- **SAP HANA** — Via native `hdbsql` tool (multi-tenant database support)
-
-### ☁️ Multi-Cloud Storage Backends
-| Provider | Type | Description |
-|----------|------|-------------|
-| 🇨🇳 **Alibaba Cloud OSS** | `aliyun_oss` | Auto endpoint assembly, internal network support |
-| 🇨🇳 **Tencent Cloud COS** | `tencent_cos` | Auto endpoint assembly |
-| 🇨🇳 **Qiniu Cloud Kodo** | `qiniu_kodo` | 6 region precise mapping |
-| 🌍 **S3 Compatible** | `s3` | AWS S3 / MinIO / Cloudflare R2, etc. |
-| 🌍 **Google Drive** | `google_drive` | Full OAuth 2.0 flow |
-| 🌍 **WebDAV** | `webdav` | Nextcloud / Nutstore, etc. |
-| 🌍 **FTP / FTPS** | `ftp` | Standard FTP protocol with Explicit TLS support |
-| 💾 **Local Disk** | `local_disk` | Backup to local server directory |
-
-> Chinese cloud providers only require **Region** and **AccessKey** — the system auto-assembles the endpoint. Powered by the S3 engine under the hood with zero extra dependencies.
-
-### 🖥️ Cluster Management (Master-Agent)
-- **Node Management** — Register remote server nodes with Token authentication
-- **Local Node** — Auto-created, zero-friction upgrade for single-machine users
-- **Directory Browser** — Visual file tree selector for backup source paths
-- **Agent Heartbeat** — Real-time node online status monitoring
-- **Task Tags** — Categorize and manage backup tasks by tags/nodes
-
-### ⏰ Automation & Scheduling
-- Cron expression scheduling
-- Visual Cron editor
-- Auto-retention policy (by days / by count)
-- Max concurrent backup limit
-
-### 🔐 Security
-- JWT authentication + bcrypt password hashing
-- AES-256-GCM encrypted sensitive config storage (DB passwords, OAuth tokens)
-- Optional backup file encryption
-- Login rate limiting (brute force protection)
-- Node Token authentication (one-time display, secure transport)
-
-### 📊 Monitoring & Notifications
-- Dashboard stats (success rate, storage usage, backup trend charts)
-- Email / Webhook / Telegram notifications
-- Real-time backup execution logs (SSE)
-
-### 🌐 Other
-- Chinese & English i18n
-- Zero external dependencies (embedded SQLite, single binary deployment)
-- systemd service support
+---
 
 ## Quick Start
 
-### Build from Source
+### 1. Install
+
+**Docker (recommended, no clone needed):**
 
 ```bash
-# Clone the project
-git clone https://github.com/Awuqing/BackupX.git
-cd BackupX
+# Create a docker-compose.yml then start
+docker compose up -d
 
-# Build frontend and backend
-make build
-
-# Start the backend service (default port :8340)
-cd server && ./bin/backupx
+# Or run directly
+docker run -d --name backupx -p 8340:8340 -v backupx-data:/app/data awuqing/backupx:latest
 ```
 
-### Access Web UI
+> Docker Hub: [`awuqing/backupx`](https://hub.docker.com/r/awuqing/backupx) — supports linux/amd64 and linux/arm64.
 
-Open `http://your-server:8340` in your browser. First-time use will guide you through creating an admin account.
-
-## Configuration
-
-The config file defaults to `./config.yaml`. Settings can also be overridden via `BACKUPX_` prefixed environment variables.
+<details>
+<summary>docker-compose.yml reference</summary>
 
 ```yaml
-# config.yaml
-server:
-  host: "0.0.0.0"
-  port: 8340
-  mode: "release"              # debug | release
+services:
+  backupx:
+    image: awuqing/backupx:latest
+    container_name: backupx
+    restart: unless-stopped
+    ports:
+      - "8340:8340"
+    volumes:
+      - backupx-data:/app/data
+      # Mount host directories to back up (add as needed):
+      # - /var/www:/mnt/www:ro
+      # - /etc/nginx:/mnt/nginx-conf:ro
+    environment:
+      - TZ=Asia/Shanghai
 
-database:
-  path: "./data/backupx.db"    # SQLite database path
-
-security:
-  jwt_secret: ""               # Leave empty to auto-generate
-  jwt_expire: "24h"
-  encryption_key: ""           # AES encryption key, auto-generated if empty
-
-backup:
-  temp_dir: "/tmp/backupx"     # Backup temp directory
-  max_concurrent: 2            # Max concurrent backups
-
-log:
-  level: "info"                # debug | info | warn | error
-  file: "./data/backupx.log"
-  max_size: 100                # Max log file size (MB)
-  max_backups: 3               # Number of old log files to retain
-  max_age: 30                  # Log retention days
+volumes:
+  backupx-data:
 ```
 
-> 💡 `jwt_secret` and `encryption_key` are auto-generated on first startup and persisted to the database.
+</details>
 
-## Architecture
+**Pre-built binaries (bare metal):**
 
-```
-                        ┌─────────────────────┐
-                        │   Nginx (Reverse     │
-                        │   Proxy)             │
-                        │  / → Static Files    │
-                        │  /api → :8340        │
-                        └─────────┬───────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────┐
-│              BackupX Master (Go API Server)           │
-│                      :8340                            │
-│                                                      │
-│  ┌──────┐  ┌────────────┐  ┌───────────────────────┐│
-│  │ Auth │  │Backup Engine│  │  Storage Registry     ││
-│  └──────┘  └──────┬─────┘  │  ┌─────────────────┐  ││
-│                   │        │  │ Alibaba Cloud    │  ││
-│  ┌──────────┐    │        │  │ Tencent Cloud    │  ││
-│  │ Cron     │◄───┘        │  │ Qiniu Cloud      │  ││
-│  │Scheduler │             │  │ S3 Compatible    │  ││
-│  └──────────┘             │  │ Google Drive     │  ││
-│                           │  │ WebDAV           │  ││
-│                           │  │ FTP / FTPS       │  ││
-│  ┌──────────┐             │  │ Local Disk       │  ││
-│  │ Notify   │             │  └─────────────────┘  ││
-│  │ Module   │             └───────────────────────┘│
-│  └──────────┘                                      │
-│                                                      │
-│  ┌──────────────┐   ┌────────────────────┐          │
-│  │ Node Manager │   │ SQLite (backupx.db)│          │
-│  └──────┬───────┘   └────────────────────┘          │
-└─────────┼────────────────────────────────────────────┘
-          │ Heartbeat / Task Dispatch
-          ▼
-┌──────────────────┐  ┌──────────────────┐
-│   Agent Node A   │  │   Agent Node B   │
-│   (Remote Server)│  │   (Remote Server)│
-└──────────────────┘  └──────────────────┘
-```
-
-### Tech Stack
-
-| Component | Technology |
-|-----------|-----------|
-| **Backend** | Go · Gin · GORM · SQLite · robfig/cron |
-| **Frontend** | React 18 · TypeScript · ArcoDesign · Vite · Zustand · ECharts |
-| **Storage** | AWS SDK v2 (S3/OSS/COS/Kodo) · Google Drive API v3 · gowebdav · jlaffaye/ftp |
-| **Security** | JWT · bcrypt · AES-256-GCM |
-| **Logging** | zap + lumberjack (auto-rotation) |
-
-## Cluster Mode
-
-BackupX supports **Master-Agent** mode for managing backup tasks across multiple servers.
-
-### How It Works
-
-1. **Master** is the server running the BackupX Web console
-2. **Agent** is deployed on remote servers that need to be backed up
-3. Agents register with the Master using a Token and send periodic heartbeats
-4. Master dispatches backup tasks to the corresponding Agent for execution
-
-### Adding Nodes
+Download from [Releases](https://github.com/Awuqing/BackupX/releases):
 
 ```bash
-# In Web Console → Node Management → Add Node
-# The system generates a unique 64-character hex Token
-
-# Configure the Agent on the remote server
-./backupx-agent --master http://master-server:8340 --token <your-token>
+tar xzf backupx-v*-linux-amd64.tar.gz && cd backupx-*
+sudo ./install.sh        # Auto-configures systemd + Nginx
 ```
 
-### Directory Probe API
-
-Master provides `GET /api/nodes/:id/fs/list?path=/` to remotely browse a node's file system. The frontend uses a tree selector to browse the target machine's directory structure when creating backup tasks.
-
-## Project Structure
-
-```
-BackupX/
-├── server/                        # Go backend
-│   ├── cmd/backupx/               #   Entry point
-│   ├── internal/
-│   │   ├── app/                   #   App assembly (DI)
-│   │   ├── apperror/              #   Unified error types
-│   │   ├── backup/                #   Backup engine (file/mysql/sqlite/pgsql/saphana)
-│   │   │   └── retention/         #     Retention policy
-│   │   ├── config/                #   Config loading (viper)
-│   │   ├── database/              #   Database init + migrations
-│   │   ├── http/                  #   HTTP handlers + routes + middleware
-│   │   ├── httpapi/               #   HTTP API helpers
-│   │   ├── logger/                #   Logger init (zap + lumberjack)
-│   │   ├── model/                 #   GORM data models
-│   │   ├── notify/                #   Notifications (email/webhook/telegram)
-│   │   ├── repository/            #   Data access layer
-│   │   ├── scheduler/             #   Cron scheduler
-│   │   ├── security/              #   JWT + rate limiting
-│   │   ├── service/               #   Business logic
-│   │   └── storage/               #   Storage backends (plugin interface)
-│   │       ├── aliyun/            #     Alibaba Cloud OSS
-│   │       ├── tencent/           #     Tencent Cloud COS
-│   │       ├── qiniu/             #     Qiniu Cloud Kodo
-│   │       ├── s3/                #     S3 Compatible core
-│   │       ├── s3provider/        #     S3 Provider helper
-│   │       ├── googledrive/       #     Google Drive
-│   │       ├── webdav/            #     WebDAV core
-│   │       ├── webdavprovider/    #     WebDAV Provider helper
-│   │       ├── localdisk/         #     Local disk
-│   │       ├── ftp/               #     FTP / FTPS
-│   │       └── codec/             #     Config codec
-│   └── pkg/                       #   Utilities (compress/crypto/response)
-├── web/                           # React frontend
-│   └── src/
-│       ├── components/            #   Shared components (CronEditor/FormDrawer/...)
-│       ├── hooks/                 #   Custom Hooks
-│       ├── layouts/               #   Layout components (AppLayout)
-│       ├── pages/                 #   Page modules
-│       │   ├── dashboard/         #     Dashboard
-│       │   ├── backup-tasks/      #     Backup tasks
-│       │   ├── backup-records/    #     Backup records
-│       │   ├── storage-targets/   #     Storage targets
-│       │   ├── nodes/             #     Node management
-│       │   ├── notifications/     #     Notification settings
-│       │   ├── settings/          #     System settings
-│       │   └── login/             #     Login page
-│       ├── services/              #   API request wrappers
-│       ├── stores/                #   Zustand state management
-│       ├── styles/                #   Global styles
-│       ├── types/                 #   TypeScript type definitions
-│       ├── utils/                 #   Utility functions
-│       ├── locales/               #   i18n language packs (zh-CN / en-US)
-│       └── router/                #   Route configuration
-├── deploy/                        # Deployment configs
-│   ├── nginx.conf                 #   Nginx reference config
-│   ├── backupx.service            #   systemd service unit
-│   └── install.sh                 #   One-click install script
-├── .github/                       # GitHub configuration
-│   ├── workflows/ci.yml           #   CI workflow
-│   ├── workflows/release.yml      #   Release workflow
-│   └── ISSUE_TEMPLATE/            #   Issue templates
-└── Makefile                       # Build commands
-```
-
-## Development
-
-### Prerequisites
-
-- **Go** ≥ 1.21
-- **Node.js** ≥ 18
-- **npm**
-
-### Dev Mode
+**Build from source:**
 
 ```bash
-# Terminal 1: Start backend (use air for hot-reload)
-make dev-server
-
-# Terminal 2: Start frontend (Vite HMR)
-make dev-web
+git clone https://github.com/Awuqing/BackupX.git && cd BackupX
+make build               # Build frontend + backend
+make docker-cn           # Or Docker build with China mirrors (goproxy.cn / npmmirror / Aliyun apk)
 ```
 
-### Run Tests
+### 2. Open the Console
+
+Visit `http://your-server:8340` in your browser. First-time access guides you through admin account creation.
+
+### 3. Add a Storage Target
+
+Go to **Storage Targets** → **Add**, choose a storage type and enter credentials:
+
+| Storage Type | Required Fields |
+|-------------|----------------|
+| Alibaba Cloud OSS | Region + AccessKey ID/Secret + Bucket |
+| Tencent Cloud COS | Region + SecretId/SecretKey + Bucket (`name-appid`) |
+| Qiniu Cloud Kodo | Region + AccessKey/SecretKey + Bucket |
+| S3 Compatible | Endpoint + AccessKey + Bucket |
+| Google Drive | Client ID/Secret → click Authorize for OAuth |
+| WebDAV | Server URL + Username/Password |
+| FTP | Host + Port + Username/Password |
+| Local Disk | Target directory path |
+
+Click **Test Connection** to verify.
+
+### 4. Create a Backup Task
+
+Go to **Backup Tasks** → **Create**, complete 3 steps:
+
+1. **Basic Info** — Task name, backup type, Cron expression (leave empty for manual-only)
+2. **Source Config** — File backup: select source paths (supports multiple); Database: enter connection info
+3. **Storage & Policy** — Select storage target(s), compression, retention days, encryption toggle
+
+Save, then click **Run Now** to test. View real-time logs in **Backup Records**.
+
+### 5. Set Up Notifications (Optional)
+
+Go to **Notifications** to configure Email, Webhook, or Telegram alerts for backup success/failure.
+
+---
+
+## Deployment Guide
+
+### Docker
 
 ```bash
-# Run all tests
-make test
-
-# Backend only
-make test-server    # go test ./...
-
-# Frontend only
-make test-web       # npm run test
+docker compose up -d     # Using the docker-compose.yml above
 ```
 
-### Build
+Mount host directories for file backup (add to `volumes` in docker-compose.yml):
+
+```yaml
+volumes:
+  - backupx-data:/app/data
+  - /var/www:/mnt/www:ro
+  - /etc/nginx:/mnt/nginx-conf:ro
+```
+
+Override config via environment variables:
+
+```yaml
+environment:
+  - TZ=Asia/Shanghai
+  - BACKUPX_LOG_LEVEL=debug
+  - BACKUPX_BACKUP_MAX_CONCURRENT=4
+```
+
+### Bare Metal
 
 ```bash
-# Build frontend and backend
+# From pre-built package
+tar xzf backupx-v*-linux-amd64.tar.gz && cd backupx-*
+sudo ./install.sh
+
+# Or from source
 make build
-
-# Clean build artifacts
-make clean
-```
-
-## Deployment
-
-### One-Click Install (Recommended)
-
-```bash
-# Build first
-make build
-
-# Run install script as root
 sudo ./deploy/install.sh
 ```
 
-The install script will automatically:
-1. Create a `backupx` system user
-2. Install the binary to `/opt/backupx/bin/`
-3. Deploy the frontend to `/opt/backupx/web/`
-4. Generate config at `/etc/backupx/config.yaml`
-5. Register and start the systemd service
-6. Configure Nginx reverse proxy (if installed)
+The install script creates a system user, installs to `/opt/backupx/`, configures systemd, and sets up Nginx reverse proxy.
 
-### Manual Deployment
-
-```bash
-# 1. Build
-cd server && go build -o backupx ./cmd/backupx
-cd ../web && npm run build
-
-# 2. Deploy files
-scp server/backupx your-server:/opt/backupx/bin/
-scp -r web/dist/ your-server:/opt/backupx/web/
-scp server/config.example.yaml your-server:/etc/backupx/config.yaml
-
-# 3. Start
-ssh your-server '/opt/backupx/bin/backupx -config /etc/backupx/config.yaml'
-```
-
-### Nginx Config Example
+### Nginx Reverse Proxy (bare metal)
 
 ```nginx
 server {
     listen 80;
     server_name backup.example.com;
 
-    # Frontend static files
     location / {
         root /opt/backupx/web;
         try_files $uri $uri/ /index.html;
     }
 
-    # API reverse proxy
     location /api/ {
         proxy_pass http://127.0.0.1:8340;
         proxy_set_header Host $host;
@@ -410,89 +199,120 @@ server {
 }
 ```
 
+### Configuration
+
+Config file: `./config.yaml` (or override with `BACKUPX_` prefixed env vars):
+
+```yaml
+server:
+  port: 8340
+database:
+  path: "./data/backupx.db"
+security:
+  jwt_secret: ""          # Auto-generated and persisted to DB
+  encryption_key: ""      # Auto-generated
+backup:
+  temp_dir: "/tmp/backupx"
+  max_concurrent: 2
+log:
+  level: "info"           # debug | info | warn | error
+  file: "./data/backupx.log"
+```
+
+### Password Reset
+
+```bash
+# Bare metal
+./backupx reset-password --username admin --password newpass123
+
+# Docker
+docker exec -it backupx /app/bin/backupx reset-password --username admin --password newpass123
+```
+
+---
+
+## Multi-Node Cluster
+
+BackupX supports Master-Agent mode for managing multiple servers:
+
+1. Web Console → **Node Management** → **Add Node** — system generates a Token
+2. Deploy Agent on remote server, connect using the Token
+3. Create backup tasks and assign to specific nodes — Master dispatches automatically
+
+The visual directory browser lets you pick directories on remote Agent nodes — no manual path typing.
+
+---
+
+## Development
+
+**Requirements:** Go >= 1.25 · Node.js >= 20 · npm
+
+```bash
+# Dev mode
+make dev-server          # Terminal 1: backend (:8340)
+make dev-web             # Terminal 2: frontend (Vite HMR)
+
+# Test
+make test                # Run all tests
+
+# Build
+make build               # Build frontend + backend
+make docker              # Docker build
+make docker-cn           # Docker build with China mirrors
+```
+
+### Release
+
+```bash
+git tag v1.2.3 && git push --tags
+# GitHub Actions: compile dual-arch binaries → publish GitHub Release → push Docker Hub image
+```
+
+Or manually trigger the Release workflow from GitHub Actions page.
+
+---
+
 ## API Reference
 
-All APIs are prefixed with `/api` and use JWT Bearer Token authentication (unless noted otherwise).
+All endpoints prefixed with `/api`, authenticated via JWT Bearer Token.
 
 | Module | Endpoint | Description |
 |--------|----------|-------------|
-| **Auth** | `POST /api/auth/setup` | Initialize admin (first time) |
-| | `POST /api/auth/login` | Login to get Token |
-| | `POST /api/auth/logout` | Logout |
-| | `GET /api/auth/profile` | Current user info |
-| | `PUT /api/auth/password` | Change password |
-| **Backup Tasks** | `GET/POST /api/backup/tasks` | List / Create tasks |
-| | `GET/PUT/DELETE /api/backup/tasks/:id` | Detail / Update / Delete |
-| | `PUT /api/backup/tasks/:id/toggle` | Enable / Disable |
-| | `POST /api/backup/tasks/:id/run` | Trigger manual execution |
-| **Backup Records** | `GET /api/backup/records` | List records (with filter) |
-| | `GET /api/backup/records/:id` | Record detail |
-| | `GET /api/backup/records/:id/logs/stream` | Real-time execution logs (SSE) |
-| | `GET /api/backup/records/:id/download` | Download backup file |
-| | `POST /api/backup/records/:id/restore` | Restore backup |
-| **Storage Targets** | `GET/POST /api/storage-targets` | List / Add targets |
-| | `GET/PUT/DELETE /api/storage-targets/:id` | Detail / Update / Delete |
-| | `POST /api/storage-targets/test` | Test connection |
-| | `POST /api/storage-targets/:id/test` | Test saved connection |
-| | `GET /api/storage-targets/:id/usage` | Query usage |
-| **Nodes** | `GET/POST /api/nodes` | List / Add nodes |
-| | `GET/DELETE /api/nodes/:id` | Detail / Delete |
-| | `GET /api/nodes/:id/fs/list` | Directory browser |
-| | `POST /api/agent/heartbeat` | Agent heartbeat ⚡ |
-| **Notifications** | `GET/POST /api/notifications` | List / Add |
-| | `POST /api/notifications/test` | Test notification |
-| | `POST /api/notifications/:id/test` | Test saved notification |
-| **Dashboard** | `GET /api/dashboard/stats` | Overview statistics |
-| | `GET /api/dashboard/timeline` | Backup trend timeline |
-| **System** | `GET /api/system/info` | System info (version/disk) |
-| | `GET/PUT /api/settings` | System settings |
+| **Auth** | `POST /auth/setup` | Initialize admin |
+| | `POST /auth/login` | Login |
+| | `PUT /auth/password` | Change password |
+| **Backup Tasks** | `GET\|POST /backup/tasks` | List / Create |
+| | `GET\|PUT\|DELETE /backup/tasks/:id` | Detail / Update / Delete |
+| | `PUT /backup/tasks/:id/toggle` | Enable / Disable |
+| | `POST /backup/tasks/:id/run` | Manual run |
+| **Backup Records** | `GET /backup/records` | List (with filter) |
+| | `GET /backup/records/:id/logs/stream` | Real-time logs (SSE) |
+| | `GET /backup/records/:id/download` | Download |
+| | `POST /backup/records/:id/restore` | Restore |
+| **Storage Targets** | `GET\|POST /storage-targets` | List / Add |
+| | `POST /storage-targets/test` | Test connection |
+| **Nodes** | `GET\|POST /nodes` | List / Add |
+| | `GET /nodes/:id/fs/list` | Directory browser |
+| **Notifications** | `GET\|POST /notifications` | List / Add |
+| **Dashboard** | `GET /dashboard/stats` | Overview stats |
+| **Audit Logs** | `GET /audit-logs` | Operation audit |
+| **System** | `GET /system/info` | System info |
 
-> ⚡ `POST /api/agent/heartbeat` is a public endpoint authenticated via Node Token instead of JWT.
+---
 
-## Cloud Storage Setup Guide
+## Tech Stack
 
-### Alibaba Cloud OSS
-
-1. Log in to [Alibaba Cloud Console](https://oss.console.aliyun.com/), create a Bucket
-2. Go to RAM Console to create an AccessKey
-3. Select "Alibaba Cloud OSS" when adding a storage target in BackupX
-4. Enter the Region (e.g. `cn-hangzhou`) and AccessKey — the system auto-assembles the endpoint
-
-### Tencent Cloud COS
-
-1. Log in to [Tencent Cloud Console](https://console.cloud.tencent.com/cos), create a bucket
-2. Go to API Key Management to create SecretId/SecretKey
-3. Bucket name format is `BucketName-APPID` (e.g. `backup-1250000000`)
-
-### Qiniu Cloud Kodo
-
-1. Log in to [Qiniu Cloud Console](https://portal.qiniu.com/), create a storage space
-2. Supported regions: `z0` (East China) / `cn-east-2` (East China-Zhejiang 2) / `z1` (North China) / `z2` (South China) / `na0` (North America) / `as0` (Southeast Asia)
-
-### Google Drive
-
-1. Go to [Google Cloud Console](https://console.cloud.google.com/) and create a project
-2. Enable the **Google Drive API**
-3. Create an **OAuth 2.0 Client ID** (Web application type)
-4. Add redirect URI: `http://your-server/api/storage-targets/google-drive/callback`
-5. Enter the Client ID / Secret in BackupX storage management and click Authorize
+| Component | Technology |
+|-----------|-----------|
+| **Backend** | Go · Gin · GORM · SQLite · robfig/cron |
+| **Frontend** | React 18 · TypeScript · ArcoDesign · Vite · Zustand · ECharts |
+| **Storage** | AWS SDK v2 · Google Drive API v3 · gowebdav · jlaffaye/ftp |
+| **Security** | JWT · bcrypt · AES-256-GCM |
 
 ## Contributing
 
 Issues and Pull Requests are welcome!
 
-1. Fork this repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
-
 ## License
 
-This project is licensed under the [Apache License 2.0](LICENSE).
-
----
-
-<p align="center">
-  Made with ❤️ for self-hosters
-</p>
+[Apache License 2.0](LICENSE)

deploy/docker/entrypoint.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+set -e
+
+# Backend listens on internal port 8341, Nginx exposes 8340
+export BACKUPX_SERVER_PORT="${BACKUPX_SERVER_PORT_INTERNAL:-8341}"
+
+# Start Nginx in background
+nginx -g "daemon off;" &
+NGINX_PID=$!
+
+# Start BackupX backend
+/app/bin/backupx &
+APP_PID=$!
+
+# Trap signals for graceful shutdown
+trap 'kill $APP_PID $NGINX_PID 2>/dev/null; wait $APP_PID $NGINX_PID 2>/dev/null' SIGTERM SIGINT
+
+echo "BackupX started — Nginx :8340 -> Backend :8341"
+
+# Wait for either process to exit
+wait -n $APP_PID $NGINX_PID 2>/dev/null || true
+kill $APP_PID $NGINX_PID 2>/dev/null || true
+wait $APP_PID $NGINX_PID 2>/dev/null || true

deploy/docker/nginx.conf

@@ -0,0 +1,32 @@
+server {
+    listen 8340;
+    server_name _;
+
+    root /app/web;
+    index index.html;
+
+    # API reverse proxy to backend
+    location /api/ {
+        proxy_pass http://127.0.0.1:8341/api/;
+        proxy_http_version 1.1;
+        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;
+        proxy_set_header Connection "";
+        proxy_buffering off;
+        proxy_cache off;
+        proxy_read_timeout 3600s;
+    }
+
+    # SPA fallback
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+
+    # Static assets cache
+    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff2?)$ {
+        expires 30d;
+        add_header Cache-Control "public, immutable";
+    }
+}

docker-compose.yml

@@ -0,0 +1,30 @@
+# BackupX Docker Compose
+#
+# 快速启动：docker compose up -d
+# 访问地址：http://localhost:8340
+#
+# 如需从源码构建镜像（而非拉取线上镜像），取消注释 build 行并注释 image 行。
+
+services:
+  backupx:
+    image: awuqing/backupx:latest
+    # build: .                              # 从源码构建时取消此行注释
+    container_name: backupx
+    restart: unless-stopped
+    ports:
+      - "8340:8340"
+    volumes:
+      - backupx-data:/app/data
+      - /var/run/docker.sock:/var/run/docker.sock  # 支持 Web 一键更新
+      # 挂载需要备份的宿主机目录（按需添加，:ro 表示只读）：
+      # - /var/www:/mnt/www:ro
+      # - /etc/nginx:/mnt/nginx-conf:ro
+      # - /home/user/data:/mnt/data:ro
+    environment:
+      - TZ=Asia/Shanghai
+      # 通过 BACKUPX_ 前缀环境变量覆盖配置：
+      # - BACKUPX_LOG_LEVEL=debug
+      # - BACKUPX_BACKUP_MAX_CONCURRENT=4
+
+volumes:
+  backupx-data:

server/Makefile

@@ -1,14 +1,15 @@
 APP_NAME=backupx
 BUILD_DIR=./bin
+VERSION=$(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
 
 .PHONY: build run test
 
 build:
 	mkdir -p $(BUILD_DIR)
-	go build -o $(BUILD_DIR)/$(APP_NAME) ./cmd/backupx
+	go build -trimpath -ldflags "-s -w -X main.version=$(VERSION)" -o $(BUILD_DIR)/$(APP_NAME) ./cmd/backupx
 
 run:
-	go run ./cmd/backupx
+	go run -ldflags "-X main.version=$(VERSION)" ./cmd/backupx
 
 test:
 	go test ./...

server/cmd/backupx/main.go

@@ -10,11 +10,21 @@ import (
 
 	"backupx/server/internal/app"
 	"backupx/server/internal/config"
+	"backupx/server/internal/security"
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+	gormlogger "gorm.io/gorm/logger"
 )
 
 var version = "dev"
 
 func main() {
+	// 子命令分发：reset-password
+	if len(os.Args) > 1 && os.Args[1] == "reset-password" {
+		runResetPassword(os.Args[2:])
+		return
+	}
+
 	var configPath string
 	var showVersion bool
 
@@ -48,3 +58,58 @@ func main() {
 		os.Exit(1)
 	}
 }
+
+// runResetPassword 通过 CLI 直接操作 SQLite 重置用户密码，无需完整 app 初始化。
+// 用法：backupx reset-password --username admin --password newpass123 [--config path]
+func runResetPassword(args []string) {
+	fs := flag.NewFlagSet("reset-password", flag.ExitOnError)
+	username := fs.String("username", "admin", "要重置密码的用户名")
+	password := fs.String("password", "", "新密码（至少 8 个字符）")
+	configPath := fs.String("config", "", "配置文件路径")
+	if err := fs.Parse(args); err != nil {
+		os.Exit(1)
+	}
+
+	if *password == "" {
+		fmt.Fprintln(os.Stderr, "错误：--password 参数为必填项")
+		fs.Usage()
+		os.Exit(1)
+	}
+	if len(*password) < 8 {
+		fmt.Fprintln(os.Stderr, "错误：密码长度至少 8 个字符")
+		os.Exit(1)
+	}
+
+	cfg, err := config.Load(*configPath)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "加载配置失败：%v\n", err)
+		os.Exit(1)
+	}
+
+	db, err := gorm.Open(sqlite.Open(cfg.Database.Path), &gorm.Config{Logger: gormlogger.Default.LogMode(gormlogger.Silent)})
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "打开数据库失败：%v\n", err)
+		os.Exit(1)
+	}
+
+	var count int64
+	db.Table("users").Where("username = ?", *username).Count(&count)
+	if count == 0 {
+		fmt.Fprintf(os.Stderr, "错误：用户 %q 不存在\n", *username)
+		os.Exit(1)
+	}
+
+	hash, err := security.HashPassword(*password)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "密码哈希失败：%v\n", err)
+		os.Exit(1)
+	}
+
+	result := db.Table("users").Where("username = ?", *username).Update("password_hash", hash)
+	if result.Error != nil {
+		fmt.Fprintf(os.Stderr, "密码更新失败：%v\n", result.Error)
+		os.Exit(1)
+	}
+
+	fmt.Printf("用户 %q 密码已重置成功\n", *username)
+}

server/go.mod

@@ -3,97 +3,258 @@ module backupx/server
 go 1.25.0
 
 require (
-	github.com/aws/aws-sdk-go-v2 v1.41.3
-	github.com/aws/aws-sdk-go-v2/credentials v1.19.11
-	github.com/aws/aws-sdk-go-v2/service/s3 v1.96.4
 	github.com/gin-gonic/gin v1.10.1
 	github.com/glebarez/sqlite v1.11.0
-	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/natefinch/lumberjack v2.0.0+incompatible
+	github.com/rclone/rclone v1.73.3
 	github.com/robfig/cron/v3 v3.0.1
 	github.com/spf13/viper v1.20.0
-	github.com/studio-b12/gowebdav v0.12.0
 	go.uber.org/zap v1.27.0
-	golang.org/x/crypto v0.45.0
-	golang.org/x/oauth2 v0.25.0
-	google.golang.org/api v0.215.0
+	golang.org/x/crypto v0.48.0
+	golang.org/x/oauth2 v0.34.0
+	google.golang.org/api v0.255.0
 	gorm.io/gorm v1.25.12
 )
 
 require (
-	cloud.google.com/go/auth v0.13.0 // indirect
-	cloud.google.com/go/auth/oauth2adapt v0.2.6 // indirect
-	cloud.google.com/go/compute/metadata v0.6.0 // indirect
+	cloud.google.com/go/auth v0.17.0 // indirect
+	cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect
+	cloud.google.com/go/compute/metadata v0.9.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.20.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.13.0 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.3 // indirect
+	github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.5.3 // indirect
+	github.com/Azure/go-ntlmssp v0.0.2-0.20251110135918-10b7b7e7cd26 // indirect
+	github.com/AzureAD/microsoft-authentication-library-for-go v1.6.0 // indirect
 	github.com/BurntSushi/toml v1.6.0 // indirect
+	github.com/FilenCloudDienste/filen-sdk-go v0.0.37 // indirect
+	github.com/Files-com/files-sdk-go/v3 v3.2.264 // indirect
+	github.com/IBM/go-sdk-core/v5 v5.18.5 // indirect
+	github.com/Max-Sum/base32768 v0.0.0-20230304063302-18e6ce5945fd // indirect
+	github.com/Microsoft/go-winio v0.6.1 // indirect
+	github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf // indirect
+	github.com/ProtonMail/gluon v0.17.1-0.20230724134000-308be39be96e // indirect
+	github.com/ProtonMail/go-crypto v1.3.0 // indirect
+	github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f // indirect
+	github.com/ProtonMail/go-srp v0.0.7 // indirect
+	github.com/ProtonMail/gopenpgp/v2 v2.9.0 // indirect
+	github.com/PuerkitoBio/goquery v1.10.3 // indirect
+	github.com/a1ex3/zstd-seekable-format-go/pkg v0.10.0 // indirect
+	github.com/abbot/go-http-auth v0.4.0 // indirect
+	github.com/anchore/go-lzo v0.1.0 // indirect
+	github.com/andybalholm/cascadia v1.3.3 // indirect
+	github.com/appscode/go-querystring v0.0.0-20170504095604-0126cfb3f1dc // indirect
+	github.com/aws/aws-sdk-go-v2 v1.41.3 // indirect
 	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.6 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.31.17 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.19.11 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.19 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.20.4 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.19 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.19 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.20 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.6 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.11 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.19 // indirect
 	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.19 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.96.4 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.30.12 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.16 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.41.8 // indirect
 	github.com/aws/smithy-go v1.24.2 // indirect
-	github.com/bytedance/sonic v1.11.6 // indirect
-	github.com/bytedance/sonic/loader v0.1.1 // indirect
-	github.com/cloudwego/base64x v0.1.4 // indirect
-	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/bahlo/generic-list-go v0.2.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/boombuler/barcode v1.1.0 // indirect
+	github.com/bradenaw/juniper v0.15.3 // indirect
+	github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 // indirect
+	github.com/buengese/sgzip v0.1.1 // indirect
+	github.com/buger/jsonparser v1.1.2 // indirect
+	github.com/bytedance/sonic v1.13.2 // indirect
+	github.com/bytedance/sonic/loader v0.2.4 // indirect
+	github.com/calebcase/tmpfile v1.0.3 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/chilts/sid v0.0.0-20190607042430-660e94789ec9 // indirect
+	github.com/clipperhouse/stringish v0.1.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
+	github.com/cloudflare/circl v1.6.3 // indirect
+	github.com/cloudinary/cloudinary-go/v2 v2.13.0 // indirect
+	github.com/cloudsoda/go-smb2 v0.0.0-20250228001242-d4c70e6251cc // indirect
+	github.com/cloudsoda/sddl v0.0.0-20250224235906-926454e91efc // indirect
+	github.com/cloudwego/base64x v0.1.5 // indirect
+	github.com/colinmarc/hdfs/v2 v2.4.0 // indirect
+	github.com/coreos/go-semver v0.3.1 // indirect
+	github.com/coreos/go-systemd/v22 v22.6.0 // indirect
+	github.com/creasty/defaults v1.8.0 // indirect
+	github.com/cronokirby/saferith v0.33.0 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/diskfs/go-diskfs v1.7.0 // indirect
+	github.com/dromara/dongle v1.0.1 // indirect
+	github.com/dropbox/dropbox-sdk-go-unofficial/v6 v6.0.5 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/ebitengine/purego v0.9.1 // indirect
+	github.com/emersion/go-message v0.18.2 // indirect
+	github.com/emersion/go-vcard v0.0.0-20241024213814-c9703dde27ff // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/flynn/noise v1.1.0 // indirect
 	github.com/fsnotify/fsnotify v1.8.0 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
-	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.11 // indirect
+	github.com/geoffgarside/ber v1.2.0 // indirect
+	github.com/gin-contrib/sse v1.0.0 // indirect
 	github.com/glebarez/go-sqlite v1.21.2 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/go-chi/chi/v5 v5.2.5 // indirect
+	github.com/go-darwin/apfs v0.0.0-20211011131704-f84b94dbf348 // indirect
+	github.com/go-git/go-billy/v5 v5.6.2 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-openapi/errors v0.22.4 // indirect
+	github.com/go-openapi/strfmt v0.25.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.20.0 // indirect
-	github.com/go-viper/mapstructure/v2 v2.2.1 // indirect
-	github.com/goccy/go-json v0.10.2 // indirect
-	github.com/google/go-cmp v0.7.0 // indirect
-	github.com/google/s2a-go v0.1.8 // indirect
+	github.com/go-playground/validator/v10 v10.28.0 // indirect
+	github.com/go-resty/resty/v2 v2.16.5 // indirect
+	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+	github.com/goccy/go-json v0.10.5 // indirect
+	github.com/gofrs/flock v0.13.0 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang-jwt/jwt/v4 v4.5.2 // indirect
+	github.com/google/btree v1.1.3 // indirect
+	github.com/google/s2a-go v0.1.9 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/googleapis/enterprise-certificate-proxy v0.3.4 // indirect
-	github.com/googleapis/gax-go/v2 v2.14.1 // indirect
-	github.com/hashicorp/errwrap v1.0.0 // indirect
+	github.com/googleapis/enterprise-certificate-proxy v0.3.7 // indirect
+	github.com/googleapis/gax-go/v2 v2.15.0 // indirect
+	github.com/gorilla/schema v1.4.1 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
 	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.8 // indirect
+	github.com/hashicorp/go-uuid v1.0.3 // indirect
+	github.com/internxt/rclone-adapter v0.0.0-20260220172730-613f4cc8b8fd // indirect
+	github.com/jcmturner/aescts/v2 v2.0.0 // indirect
+	github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect
+	github.com/jcmturner/gofork v1.7.6 // indirect
+	github.com/jcmturner/goidentity/v6 v6.0.1 // indirect
+	github.com/jcmturner/gokrb5/v8 v8.4.4 // indirect
+	github.com/jcmturner/rpc/v2 v2.0.3 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/jlaffaye/ftp v0.2.0 // indirect
+	github.com/jlaffaye/ftp v0.2.1-0.20240918233326-1b970516f5d3 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/jtolio/noiseconn v0.0.0-20231127013910-f6d9ecbf1de7 // indirect
+	github.com/jzelinskie/whirlpool v0.0.0-20201016144138-0675e54bb004 // indirect
+	github.com/klauspost/compress v1.18.1 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+	github.com/koofr/go-httpclient v0.0.0-20240520111329-e20f8f203988 // indirect
+	github.com/koofr/go-koofrclient v0.0.0-20221207135200-cbd7fc9ad6a6 // indirect
+	github.com/kr/fs v0.1.0 // indirect
+	github.com/kylelemons/godebug v1.1.0 // indirect
+	github.com/lanrat/extsort v1.4.2 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/lpar/date v1.0.0 // indirect
+	github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 // indirect
+	github.com/mailru/easyjson v0.9.1 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.19 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/ncw/swift/v2 v2.0.5 // indirect
+	github.com/oklog/ulid v1.3.1 // indirect
+	github.com/onsi/ginkgo/v2 v2.19.0 // indirect
+	github.com/oracle/oci-go-sdk/v65 v65.104.0 // indirect
+	github.com/panjf2000/ants/v2 v2.11.3 // indirect
+	github.com/patrickmn/go-cache v2.1.0+incompatible // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/pengsrc/go-shared v0.2.1-0.20190131101655-1999055a4a14 // indirect
+	github.com/peterh/liner v1.2.2 // indirect
+	github.com/pierrec/lz4/v4 v4.1.22 // indirect
+	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pkg/sftp v1.13.10 // indirect
+	github.com/pkg/xattr v0.4.12 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
+	github.com/pquerna/otp v1.5.0 // indirect
+	github.com/prometheus/client_golang v1.23.2 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/common v0.67.2 // indirect
+	github.com/prometheus/procfs v0.19.2 // indirect
+	github.com/putdotio/go-putio/putio v0.0.0-20200123120452-16d982cac2b8 // indirect
+	github.com/rclone/Proton-API-Bridge v1.0.1-0.20260127174007-77f974840d11 // indirect
+	github.com/rclone/go-proton-api v1.0.1-0.20260127173028-eb465cac3b18 // indirect
+	github.com/relvacode/iso8601 v1.7.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/rfjakob/eme v1.1.2 // indirect
+	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect
 	github.com/sagikazarmark/locafero v0.7.0 // indirect
+	github.com/samber/lo v1.52.0 // indirect
+	github.com/shirou/gopsutil/v4 v4.25.10 // indirect
+	github.com/sirupsen/logrus v1.9.4-0.20230606125235-dd1b4c2e81af // indirect
+	github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966 // indirect
+	github.com/sony/gobreaker v1.0.0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
-	github.com/spf13/afero v1.12.0 // indirect
+	github.com/spacemonkeygo/monkit/v3 v3.0.25-0.20251022131615-eb24eb109368 // indirect
+	github.com/spf13/afero v1.15.0 // indirect
 	github.com/spf13/cast v1.7.1 // indirect
-	github.com/spf13/pflag v1.0.6 // indirect
+	github.com/spf13/pflag v1.0.10 // indirect
+	github.com/stretchr/testify v1.11.1 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/t3rm1n4l/go-mega v0.0.0-20251031123324-a804aaa87491 // indirect
+	github.com/tklauser/go-sysconf v0.3.15 // indirect
+	github.com/tklauser/numcpus v0.10.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.54.0 // indirect
-	go.opentelemetry.io/otel v1.29.0 // indirect
-	go.opentelemetry.io/otel/metric v1.29.0 // indirect
-	go.opentelemetry.io/otel/trace v1.29.0 // indirect
+	github.com/ulikunitz/xz v0.5.15 // indirect
+	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
+	github.com/xanzy/ssh-agent v0.3.3 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 // indirect
+	github.com/yunify/qingstor-sdk-go/v3 v3.2.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	github.com/zeebo/blake3 v0.2.4 // indirect
+	github.com/zeebo/errs v1.4.0 // indirect
+	github.com/zeebo/xxh3 v1.0.2 // indirect
+	go.etcd.io/bbolt v1.4.3 // indirect
+	go.mongodb.org/mongo-driver v1.17.6 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 // indirect
+	go.opentelemetry.io/otel v1.39.0 // indirect
+	go.opentelemetry.io/otel/metric v1.39.0 // indirect
+	go.opentelemetry.io/otel/trace v1.39.0 // indirect
 	go.uber.org/multierr v1.10.0 // indirect
-	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/net v0.47.0 // indirect
-	golang.org/x/sys v0.38.0 // indirect
-	golang.org/x/text v0.31.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20241223144023-3abc09e42ca8 // indirect
-	google.golang.org/grpc v1.67.3 // indirect
-	google.golang.org/protobuf v1.36.5 // indirect
+	go.yaml.in/yaml/v2 v2.4.3 // indirect
+	golang.org/x/arch v0.14.0 // indirect
+	golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 // indirect
+	golang.org/x/image v0.32.0 // indirect
+	golang.org/x/mod v0.32.0 // indirect
+	golang.org/x/net v0.51.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sys v0.41.0 // indirect
+	golang.org/x/term v0.40.0 // indirect
+	golang.org/x/text v0.34.0 // indirect
+	golang.org/x/time v0.14.0 // indirect
+	golang.org/x/tools v0.41.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect
+	google.golang.org/grpc v1.79.3 // indirect
+	google.golang.org/protobuf v1.36.10 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect
+	gopkg.in/validator.v2 v2.0.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.22.5 // indirect
 	modernc.org/mathutil v1.5.0 // indirect
 	modernc.org/memory v1.5.0 // indirect
 	modernc.org/sqlite v1.23.1 // indirect
+	moul.io/http2curl/v2 v2.3.0 // indirect
+	storj.io/common v0.0.0-20251107171817-6221ae45072c // indirect
+	storj.io/drpc v0.0.35-0.20250513201419-f7819ea69b55 // indirect
+	storj.io/eventkit v0.0.0-20250410172343-61f26d3de156 // indirect
+	storj.io/infectious v0.0.2 // indirect
+	storj.io/picobuf v0.0.4 // indirect
+	storj.io/uplink v1.13.1 // indirect
 )

server/internal/app/app.go

@@ -20,14 +20,7 @@ import (
 	"backupx/server/internal/service"
 	"backupx/server/internal/storage"
 	"backupx/server/internal/storage/codec"
-	"backupx/server/internal/storage/googledrive"
-	"backupx/server/internal/storage/localdisk"
-	storageAliyun "backupx/server/internal/storage/aliyun"
-	storageFTP "backupx/server/internal/storage/ftp"
-	storageTencent "backupx/server/internal/storage/tencent"
-	storageQiniu "backupx/server/internal/storage/qiniu"
-	storageS3 "backupx/server/internal/storage/s3"
-	storageWebDAV "backupx/server/internal/storage/webdav"
+	storageRclone "backupx/server/internal/storage/rclone"
 	"go.uber.org/zap"
 	"gorm.io/gorm"
 )
@@ -70,15 +63,18 @@ func New(ctx context.Context, cfg config.Config, version string) (*Application,
 	systemService := service.NewSystemService(cfg, version, time.Now().UTC())
 	configCipher := codec.NewConfigCipher(resolvedSecurity.EncryptionKey)
 	storageRegistry := storage.NewRegistry(
-		localdisk.NewFactory(),
-		storageS3.NewFactory(),
-		storageWebDAV.NewFactory(),
-		googledrive.NewFactory(),
-		storageAliyun.NewFactory(),
-		storageTencent.NewFactory(),
-		storageQiniu.NewFactory(),
-		storageFTP.NewFactory(),
+		storageRclone.NewLocalDiskFactory(),
+		storageRclone.NewS3Factory(),
+		storageRclone.NewWebDAVFactory(),
+		storageRclone.NewGoogleDriveFactory(),
+		storageRclone.NewAliyunOSSFactory(),
+		storageRclone.NewTencentCOSFactory(),
+		storageRclone.NewQiniuKodoFactory(),
+		storageRclone.NewFTPFactory(),
+		storageRclone.NewRcloneFactory(),
 	)
+	// 将全部 rclone 后端注册为独立存储类型（sftp、azureblob、dropbox 等与 s3、ftp 完全平级）
+	storageRclone.RegisterAllBackends(storageRegistry)
 	storageTargetService := service.NewStorageTargetService(storageTargetRepo, oauthSessionRepo, storageRegistry, configCipher)
 	storageTargetService.SetBackupTaskRepository(backupTaskRepo)
 	storageTargetService.SetBackupRecordRepository(backupRecordRepo)
@@ -88,13 +84,30 @@ func New(ctx context.Context, cfg config.Config, version string) (*Application,
 	retentionService := backupretention.NewService(backupRecordRepo)
 	notifyRegistry := notify.NewRegistry(notify.NewEmailNotifier(), notify.NewWebhookNotifier(), notify.NewTelegramNotifier())
 	notificationService := service.NewNotificationService(notificationRepo, notifyRegistry, configCipher)
-	backupExecutionService := service.NewBackupExecutionService(backupTaskRepo, backupRecordRepo, storageTargetRepo, storageRegistry, backupRunnerRegistry, logHub, retentionService, configCipher, notificationService, cfg.Backup.TempDir, cfg.Backup.MaxConcurrent)
+	// 初始化 rclone 传输配置（重试 + 带宽限制）
+	rcloneCtx := storageRclone.ConfiguredContext(ctx, storageRclone.TransferConfig{
+		LowLevelRetries: cfg.Backup.Retries,
+		BandwidthLimit:  cfg.Backup.BandwidthLimit,
+	})
+	storageRclone.StartAccounting(rcloneCtx)
+
+	backupExecutionService := service.NewBackupExecutionService(backupTaskRepo, backupRecordRepo, storageTargetRepo, storageRegistry, backupRunnerRegistry, logHub, retentionService, configCipher, notificationService, cfg.Backup.TempDir, cfg.Backup.MaxConcurrent, cfg.Backup.Retries, cfg.Backup.BandwidthLimit)
 	schedulerService := scheduler.NewService(backupTaskRepo, backupExecutionService, appLogger)
 	backupTaskService.SetScheduler(schedulerService)
+	// 审计日志注入延迟到 auditService 创建后（见下方）
 	backupRecordService := service.NewBackupRecordService(backupRecordRepo, backupExecutionService, logHub)
 	dashboardService := service.NewDashboardService(backupTaskRepo, backupRecordRepo, storageTargetRepo)
 	settingsService := service.NewSettingsService(systemConfigRepo)
 
+	// Audit
+	auditLogRepo := repository.NewAuditLogRepository(db)
+	auditService := service.NewAuditService(auditLogRepo)
+	authService.SetAuditService(auditService)
+	schedulerService.SetAuditRecorder(auditService)
+
+	// Database discovery
+	databaseDiscoveryService := service.NewDatabaseDiscoveryService(backup.NewOSCommandExecutor())
+
 	// Cluster: Node management
 	nodeRepo := repository.NewNodeRepository(db)
 	nodeService := service.NewNodeService(nodeRepo)
@@ -115,8 +128,10 @@ func New(ctx context.Context, cfg config.Config, version string) (*Application,
 		NotificationService:    notificationService,
 		DashboardService:       dashboardService,
 		SettingsService:        settingsService,
-		NodeService:            nodeService,
-		JWTManager:             jwtManager,
+		NodeService:              nodeService,
+		DatabaseDiscoveryService: databaseDiscoveryService,
+		AuditService:            auditService,
+		JWTManager:               jwtManager,
 		UserRepository:         userRepo,
 		SystemConfigRepo:       systemConfigRepo,
 	})

server/internal/backup/file_runner.go

@@ -22,14 +22,23 @@ func (r *FileRunner) Type() string {
 }
 
 func (r *FileRunner) Run(_ context.Context, task TaskSpec, writer LogWriter) (*RunResult, error) {
-	sourcePath := filepath.Clean(strings.TrimSpace(task.SourcePath))
-	if sourcePath == "" {
+	// 解析源路径列表：优先 SourcePaths，回退 SourcePath
+	sourcePaths := task.SourcePaths
+	if len(sourcePaths) == 0 && strings.TrimSpace(task.SourcePath) != "" {
+		sourcePaths = []string{task.SourcePath}
+	}
+	if len(sourcePaths) == 0 {
 		return nil, fmt.Errorf("source path is required")
 	}
-	info, err := os.Stat(sourcePath)
-	if err != nil {
-		return nil, fmt.Errorf("stat source path: %w", err)
+
+	// 验证所有路径存在
+	for _, sp := range sourcePaths {
+		cleaned := filepath.Clean(strings.TrimSpace(sp))
+		if _, err := os.Stat(cleaned); err != nil {
+			return nil, fmt.Errorf("stat source path %s: %w", cleaned, err)
+		}
 	}
+
 	tempDir, artifactPath, err := createTempArtifact(task.TempDir, task.Name, "tar")
 	if err != nil {
 		return nil, err
@@ -41,69 +50,88 @@ func (r *FileRunner) Run(_ context.Context, task TaskSpec, writer LogWriter) (*R
 	defer artifactFile.Close()
 	tw := tar.NewWriter(artifactFile)
 	defer tw.Close()
-	baseParent := filepath.Dir(sourcePath)
+
 	excludes := normalizeExcludePatterns(task.ExcludePatterns)
-	writer.WriteLine(fmt.Sprintf("开始打包文件备份：%s", sourcePath))
-	fileCount := 0
-	dirCount := 0
-	walkErr := filepath.Walk(sourcePath, func(currentPath string, currentInfo os.FileInfo, walkErr error) error {
-		if walkErr != nil {
-			writer.WriteLine(fmt.Sprintf("⚠ 无法访问 %s: %v", currentPath, walkErr))
-			return nil
-		}
-		relPath, err := filepath.Rel(baseParent, currentPath)
+	totalFileCount := 0
+	totalDirCount := 0
+
+	for i, sp := range sourcePaths {
+		sourcePath := filepath.Clean(strings.TrimSpace(sp))
+		info, err := os.Stat(sourcePath)
 		if err != nil {
-			return err
+			return nil, fmt.Errorf("stat source path: %w", err)
 		}
-		archiveName := filepath.ToSlash(relPath)
-		if shouldExcludeEntry(archiveName, currentInfo.IsDir(), excludes) {
-			if currentInfo.IsDir() {
-				writer.WriteLine(fmt.Sprintf("跳过排除目录 %s", archiveName))
-				return filepath.SkipDir
+
+		baseParent := filepath.Dir(sourcePath)
+		writer.WriteLine(fmt.Sprintf("开始打包源路径 [%d/%d]: %s", i+1, len(sourcePaths), sourcePath))
+		fileCount := 0
+		dirCount := 0
+
+		walkErr := filepath.Walk(sourcePath, func(currentPath string, currentInfo os.FileInfo, walkErr error) error {
+			if walkErr != nil {
+				writer.WriteLine(fmt.Sprintf("⚠ 无法访问 %s: %v", currentPath, walkErr))
+				return nil
 			}
-			return nil
-		}
-		if currentPath == sourcePath && currentInfo.IsDir() {
-			return nil
-		}
-
-		if currentInfo.IsDir() {
-			dirCount++
-			writer.WriteLine(fmt.Sprintf("📁 进入目录 %s", archiveName))
-		}
-
-		header, err := tar.FileInfoHeader(currentInfo, "")
-		if err != nil {
-			return err
-		}
-		header.Name = archiveName
-		if err := tw.WriteHeader(header); err != nil {
-			return err
-		}
-
-		if currentInfo.Mode().IsRegular() {
-			file, err := os.Open(currentPath)
+			relPath, err := filepath.Rel(baseParent, currentPath)
 			if err != nil {
 				return err
 			}
-			defer file.Close()
-			if _, err := io.CopyN(tw, file, currentInfo.Size()); err != nil && err != io.EOF {
+			archiveName := filepath.ToSlash(relPath)
+			if shouldExcludeEntry(archiveName, currentInfo.IsDir(), excludes) {
+				if currentInfo.IsDir() {
+					writer.WriteLine(fmt.Sprintf("跳过排除目录 %s", archiveName))
+					return filepath.SkipDir
+				}
+				return nil
+			}
+			if currentPath == sourcePath && currentInfo.IsDir() {
+				return nil
+			}
+
+			if currentInfo.IsDir() {
+				dirCount++
+				writer.WriteLine(fmt.Sprintf("📁 进入目录 %s", archiveName))
+			}
+
+			header, err := tar.FileInfoHeader(currentInfo, "")
+			if err != nil {
 				return err
 			}
-			fileCount++
-			if fileCount%100 == 0 {
-				writer.WriteLine(fmt.Sprintf("已打包 %d 个文件...", fileCount))
+			header.Name = archiveName
+			if err := tw.WriteHeader(header); err != nil {
+				return err
 			}
+
+			if currentInfo.Mode().IsRegular() {
+				file, err := os.Open(currentPath)
+				if err != nil {
+					return err
+				}
+				defer file.Close()
+				if _, err := io.CopyN(tw, file, currentInfo.Size()); err != nil && err != io.EOF {
+					return err
+				}
+				fileCount++
+				if fileCount%100 == 0 {
+					writer.WriteLine(fmt.Sprintf("已打包 %d 个文件...", fileCount))
+				}
+			}
+			return nil
+		})
+		if walkErr != nil {
+			return nil, fmt.Errorf("walk source path %s: %w", sourcePath, walkErr)
 		}
-		return nil
-	})
-	if walkErr != nil {
-		return nil, fmt.Errorf("walk source path: %w", walkErr)
+		if info.IsDir() {
+			writer.WriteLine(fmt.Sprintf("源路径 [%d/%d] 打包完成（%d 个目录，%d 个文件）", i+1, len(sourcePaths), dirCount, fileCount))
+		} else {
+			writer.WriteLine(fmt.Sprintf("源路径 [%d/%d] 文件打包完成", i+1, len(sourcePaths)))
+		}
+		totalFileCount += fileCount
+		totalDirCount += dirCount
 	}
-	if info.IsDir() {
-		writer.WriteLine(fmt.Sprintf("目录打包完成（%d 个目录，%d 个文件）", dirCount, fileCount))
-	} else {
-		writer.WriteLine("文件打包完成")
+
+	if len(sourcePaths) > 1 {
+		writer.WriteLine(fmt.Sprintf("全部源路径打包完成（共 %d 个目录，%d 个文件）", totalDirCount, totalFileCount))
 	}
 	return &RunResult{ArtifactPath: artifactPath, FileName: filepath.Base(artifactPath), TempDir: tempDir}, nil
 }
@@ -114,7 +142,12 @@ func (r *FileRunner) Restore(_ context.Context, task TaskSpec, artifactPath stri
 		return fmt.Errorf("open tar artifact: %w", err)
 	}
 	defer artifactFile.Close()
-	targetParent := filepath.Dir(filepath.Clean(strings.TrimSpace(task.SourcePath)))
+	// 恢复目标：优先取 SourcePaths 的第一个路径的父目录，回退 SourcePath
+	restoreSource := task.SourcePath
+	if len(task.SourcePaths) > 0 {
+		restoreSource = task.SourcePaths[0]
+	}
+	targetParent := filepath.Dir(filepath.Clean(strings.TrimSpace(restoreSource)))
 	if err := os.MkdirAll(targetParent, 0o755); err != nil {
 		return fmt.Errorf("create restore parent: %w", err)
 	}

server/internal/backup/log_hub.go

@@ -1,6 +1,7 @@
 package backup
 
 import (
+	"fmt"
 	"sync"
 	"time"
 )
@@ -99,6 +100,41 @@ func (h *LogHub) Complete(recordID uint, status string) {
 	}
 }
 
+// AppendProgress 推送上传进度事件（节流：每个 recordID 每 500ms 最多一次，最终值始终推送）。
+func (h *LogHub) AppendProgress(recordID uint, progress ProgressInfo) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	state := h.ensureState(recordID)
+
+	// 节流：距上次 progress 事件不足 500ms 且未完成则跳过（100% 始终推送）
+	now := time.Now().UTC()
+	isFinal := progress.Percent >= 100
+	if !isFinal && len(state.events) > 0 {
+		last := state.events[len(state.events)-1]
+		if last.Progress != nil && now.Sub(last.Timestamp) < 500*time.Millisecond {
+			return
+		}
+	}
+
+	state.nextSequence++
+	event := LogEvent{
+		RecordID:  recordID,
+		Sequence:  state.nextSequence,
+		Level:     "progress",
+		Message:   fmt.Sprintf("上传进度: %.1f%%", progress.Percent),
+		Timestamp: now,
+		Status:    state.status,
+		Progress:  &progress,
+	}
+	state.events = append(state.events, event)
+	for _, subscriber := range state.subscribers {
+		select {
+		case subscriber <- event:
+		default:
+		}
+	}
+}
+
 func (h *LogHub) ensureState(recordID uint) *logStreamState {
 	state, ok := h.streams[recordID]
 	if ok {

server/internal/backup/types.go

@@ -19,6 +19,7 @@ type TaskSpec struct {
 	Name              string
 	Type              string
 	SourcePath        string
+	SourcePaths       []string
 	ExcludePatterns   []string
 	Database          DatabaseSpec
 	StorageTargetID   uint
@@ -40,13 +41,23 @@ type RunResult struct {
 }
 
 type LogEvent struct {
-	RecordID  uint      `json:"recordId"`
-	Sequence  int64     `json:"sequence"`
-	Level     string    `json:"level"`
-	Message   string    `json:"message"`
-	Timestamp time.Time `json:"timestamp"`
-	Completed bool      `json:"completed"`
-	Status    string    `json:"status"`
+	RecordID  uint          `json:"recordId"`
+	Sequence  int64         `json:"sequence"`
+	Level     string        `json:"level"`
+	Message   string        `json:"message"`
+	Timestamp time.Time     `json:"timestamp"`
+	Completed bool          `json:"completed"`
+	Status    string        `json:"status"`
+	Progress  *ProgressInfo `json:"progress,omitempty"`
+}
+
+// ProgressInfo 描述上传进度，通过 SSE 实时推送给前端。
+type ProgressInfo struct {
+	BytesSent  int64   `json:"bytesSent"`
+	TotalBytes int64   `json:"totalBytes"`
+	Percent    float64 `json:"percent"`
+	SpeedBps   float64 `json:"speedBps"`   // bytes/sec
+	TargetName string  `json:"targetName"`
 }
 
 type LogWriter interface {

server/internal/config/config.go

@@ -33,8 +33,10 @@ type SecurityConfig struct {
 }
 
 type BackupConfig struct {
-	TempDir       string `mapstructure:"temp_dir"`
-	MaxConcurrent int    `mapstructure:"max_concurrent"`
+	TempDir        string `mapstructure:"temp_dir"`
+	MaxConcurrent  int    `mapstructure:"max_concurrent"`
+	Retries        int    `mapstructure:"retries"`         // 底层 HTTP 请求重试次数，默认 10
+	BandwidthLimit string `mapstructure:"bandwidth_limit"` // 带宽限制，如 "10M"，空不限
 }
 
 type LogConfig struct {
@@ -96,6 +98,9 @@ func Load(configPath string) (Config, error) {
 	if cfg.Backup.MaxConcurrent <= 0 {
 		cfg.Backup.MaxConcurrent = 2
 	}
+	if cfg.Backup.Retries <= 0 {
+		cfg.Backup.Retries = 10
+	}
 	if cfg.Log.Level == "" {
 		cfg.Log.Level = "info"
 	}
@@ -135,6 +140,8 @@ func applyDefaults(v *viper.Viper) {
 	v.SetDefault("security.jwt_expire", "24h")
 	v.SetDefault("backup.temp_dir", "/tmp/backupx")
 	v.SetDefault("backup.max_concurrent", 2)
+	v.SetDefault("backup.retries", 10)
+	v.SetDefault("backup.bandwidth_limit", "")
 	v.SetDefault("log.level", "info")
 	v.SetDefault("log.file", "./data/backupx.log")
 	v.SetDefault("log.max_size", 100)

server/internal/database/database.go

@@ -23,10 +23,17 @@ func Open(cfg config.DatabaseConfig, logger *zap.Logger) (*gorm.DB, error) {
 		return nil, fmt.Errorf("open sqlite: %w", err)
 	}
 
-	if err := db.AutoMigrate(&model.User{}, &model.SystemConfig{}, &model.StorageTarget{}, &model.OAuthSession{}, &model.BackupTask{}, &model.BackupRecord{}, &model.Notification{}, &model.Node{}); err != nil {
+	if err := db.AutoMigrate(&model.User{}, &model.SystemConfig{}, &model.StorageTarget{}, &model.OAuthSession{}, &model.BackupTask{}, &model.BackupRecord{}, &model.Notification{}, &model.Node{}, &model.BackupTaskStorageTarget{}, &model.AuditLog{}); err != nil {
 		return nil, fmt.Errorf("migrate schema: %w", err)
 	}
 
+	// 一次性数据迁移：从 backup_tasks.storage_target_id 回填到多对多中间表
+	var count int64
+	db.Model(&model.BackupTaskStorageTarget{}).Count(&count)
+	if count == 0 {
+		db.Exec("INSERT INTO backup_task_storage_targets (backup_task_id, storage_target_id) SELECT id, storage_target_id FROM backup_tasks WHERE storage_target_id > 0")
+	}
+
 	logger.Info("database initialized", zap.String("path", cfg.Path))
 	return db, nil
 }

server/internal/http/audit_handler.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"strconv"
+	"strings"
+
+	"backupx/server/internal/service"
+	"backupx/server/pkg/response"
+	"github.com/gin-gonic/gin"
+)
+
+type AuditHandler struct {
+	auditService *service.AuditService
+}
+
+func NewAuditHandler(auditService *service.AuditService) *AuditHandler {
+	return &AuditHandler{auditService: auditService}
+}
+
+func (h *AuditHandler) List(c *gin.Context) {
+	category := strings.TrimSpace(c.Query("category"))
+	limit := 50
+	offset := 0
+	if v := strings.TrimSpace(c.Query("limit")); v != "" {
+		if parsed, err := strconv.Atoi(v); err == nil && parsed > 0 {
+			limit = parsed
+		}
+	}
+	if v := strings.TrimSpace(c.Query("offset")); v != "" {
+		if parsed, err := strconv.Atoi(v); err == nil && parsed >= 0 {
+			offset = parsed
+		}
+	}
+	result, err := h.auditService.List(c.Request.Context(), category, limit, offset)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, result)
+}

server/internal/http/audit_helpers.go

@@ -0,0 +1,29 @@
+package http
+
+import (
+	"fmt"
+
+	"backupx/server/internal/service"
+	"github.com/gin-gonic/gin"
+)
+
+// recordAudit 从 gin context 中提取用户信息并记录审计日志（nil 安全）
+func recordAudit(c *gin.Context, auditService *service.AuditService, category, action, targetType, targetID, targetName, detail string) {
+	if auditService == nil {
+		return
+	}
+	username := ""
+	if subject, exists := c.Get(contextUserSubjectKey); exists {
+		username = fmt.Sprintf("%v", subject)
+	}
+	auditService.Record(service.AuditEntry{
+		Username:   username,
+		Category:   category,
+		Action:     action,
+		TargetType: targetType,
+		TargetID:   targetID,
+		TargetName: targetName,
+		Detail:     detail,
+		ClientIP:   c.ClientIP(),
+	})
+}

server/internal/http/backup_record_handler.go

@@ -16,11 +16,12 @@ import (
 )
 
 type BackupRecordHandler struct {
-	service *service.BackupRecordService
+	service      *service.BackupRecordService
+	auditService *service.AuditService
 }
 
-func NewBackupRecordHandler(recordService *service.BackupRecordService) *BackupRecordHandler {
-	return &BackupRecordHandler{service: recordService}
+func NewBackupRecordHandler(recordService *service.BackupRecordService, auditService *service.AuditService) *BackupRecordHandler {
+	return &BackupRecordHandler{service: recordService, auditService: auditService}
 }
 
 func (h *BackupRecordHandler) List(c *gin.Context) {
@@ -129,6 +130,7 @@ func (h *BackupRecordHandler) Restore(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "backup_record", "restore", "backup_record", fmt.Sprintf("%d", id), "", fmt.Sprintf("恢复备份记录 #%d", id))
 	response.Success(c, gin.H{"restored": true})
 }
 
@@ -141,9 +143,28 @@ func (h *BackupRecordHandler) Delete(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "backup_record", "delete", "backup_record", fmt.Sprintf("%d", id), "", fmt.Sprintf("删除备份记录 #%d", id))
 	response.Success(c, gin.H{"deleted": true})
 }
 
+func (h *BackupRecordHandler) BatchDelete(c *gin.Context) {
+	var input struct {
+		IDs []uint `json:"ids" binding:"required,min=1"`
+	}
+	if err := c.ShouldBindJSON(&input); err != nil {
+		response.Error(c, apperror.BadRequest("BACKUP_RECORD_BATCH_INVALID", "批量删除参数不合法", err))
+		return
+	}
+	deleted := 0
+	for _, id := range input.IDs {
+		if err := h.service.Delete(c.Request.Context(), id); err == nil {
+			deleted++
+		}
+	}
+	recordAudit(c, h.auditService, "backup_record", "batch_delete", "backup_record", "", "", fmt.Sprintf("批量删除 %d 条备份记录", deleted))
+	response.Success(c, gin.H{"deleted": deleted})
+}
+
 func buildRecordFilter(c *gin.Context) (service.BackupRecordListInput, error) {
 	var filter service.BackupRecordListInput
 	if taskIDValue := strings.TrimSpace(c.Query("taskId")); taskIDValue != "" {

server/internal/http/backup_run_handler.go

@@ -1,17 +1,20 @@
 package http
 
 import (
+	"fmt"
+
 	"backupx/server/internal/service"
 	"backupx/server/pkg/response"
 	"github.com/gin-gonic/gin"
 )
 
 type BackupRunHandler struct {
-	service *service.BackupExecutionService
+	service      *service.BackupExecutionService
+	auditService *service.AuditService
 }
 
-func NewBackupRunHandler(executionService *service.BackupExecutionService) *BackupRunHandler {
-	return &BackupRunHandler{service: executionService}
+func NewBackupRunHandler(executionService *service.BackupExecutionService, auditService *service.AuditService) *BackupRunHandler {
+	return &BackupRunHandler{service: executionService, auditService: auditService}
 }
 
 func (h *BackupRunHandler) Run(c *gin.Context) {
@@ -24,5 +27,6 @@ func (h *BackupRunHandler) Run(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "backup_task", "run", "backup_task", fmt.Sprintf("%d", id), "", "手动触发备份")
 	response.Success(c, record)
 }

server/internal/http/backup_task_handler.go

@@ -1,6 +1,8 @@
 package http
 
 import (
+	"fmt"
+
 	"backupx/server/internal/apperror"
 	"backupx/server/internal/service"
 	"backupx/server/pkg/response"
@@ -8,11 +10,12 @@ import (
 )
 
 type BackupTaskHandler struct {
-	service *service.BackupTaskService
+	service      *service.BackupTaskService
+	auditService *service.AuditService
 }
 
-func NewBackupTaskHandler(taskService *service.BackupTaskService) *BackupTaskHandler {
-	return &BackupTaskHandler{service: taskService}
+func NewBackupTaskHandler(taskService *service.BackupTaskService, auditService *service.AuditService) *BackupTaskHandler {
+	return &BackupTaskHandler{service: taskService, auditService: auditService}
 }
 
 func (h *BackupTaskHandler) List(c *gin.Context) {
@@ -48,6 +51,7 @@ func (h *BackupTaskHandler) Create(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "backup_task", "create", "backup_task", fmt.Sprintf("%d", item.ID), item.Name, fmt.Sprintf("类型: %s", input.Type))
 	response.Success(c, item)
 }
 
@@ -66,6 +70,7 @@ func (h *BackupTaskHandler) Update(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "backup_task", "update", "backup_task", fmt.Sprintf("%d", item.ID), item.Name, fmt.Sprintf("类型: %s, Cron: %s", input.Type, input.CronExpr))
 	response.Success(c, item)
 }
 
@@ -78,6 +83,7 @@ func (h *BackupTaskHandler) Delete(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "backup_task", "delete", "backup_task", fmt.Sprintf("%d", id), "", fmt.Sprintf("删除备份任务 #%d", id))
 	response.Success(c, gin.H{"deleted": true})
 }
 
@@ -105,5 +111,10 @@ func (h *BackupTaskHandler) Toggle(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	action := "enable"
+	if !enabled {
+		action = "disable"
+	}
+	recordAudit(c, h.auditService, "backup_task", action, "backup_task", fmt.Sprintf("%d", id), item.Name, fmt.Sprintf("%s 备份任务", action))
 	response.Success(c, item)
 }

server/internal/http/database_handler.go

@@ -0,0 +1,30 @@
+package http
+
+import (
+	"backupx/server/internal/apperror"
+	"backupx/server/internal/service"
+	"backupx/server/pkg/response"
+	"github.com/gin-gonic/gin"
+)
+
+type DatabaseHandler struct {
+	service *service.DatabaseDiscoveryService
+}
+
+func NewDatabaseHandler(service *service.DatabaseDiscoveryService) *DatabaseHandler {
+	return &DatabaseHandler{service: service}
+}
+
+func (h *DatabaseHandler) Discover(c *gin.Context) {
+	var input service.DatabaseDiscoverInput
+	if err := c.ShouldBindJSON(&input); err != nil {
+		response.Error(c, apperror.BadRequest("DATABASE_DISCOVER_INVALID", "数据库发现参数不合法", err))
+		return
+	}
+	result, err := h.service.Discover(c.Request.Context(), input)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, result)
+}

server/internal/http/rclone_handler.go

@@ -0,0 +1,21 @@
+package http
+
+import (
+	storageRclone "backupx/server/internal/storage/rclone"
+	"backupx/server/pkg/response"
+
+	"github.com/gin-gonic/gin"
+)
+
+// RcloneHandler 处理 rclone 后端元数据查询。
+type RcloneHandler struct{}
+
+func NewRcloneHandler() *RcloneHandler {
+	return &RcloneHandler{}
+}
+
+// ListBackends 返回所有可用的 rclone 后端及其配置选项。
+func (h *RcloneHandler) ListBackends(c *gin.Context) {
+	backends := storageRclone.ListBackends()
+	response.Success(c, backends)
+}

server/internal/http/router.go

@@ -15,22 +15,24 @@ import (
 )
 
 type RouterDependencies struct {
-	Config                 config.Config
-	Version                string
-	Logger                 *zap.Logger
-	AuthService            *service.AuthService
-	SystemService          *service.SystemService
-	StorageTargetService   *service.StorageTargetService
-	BackupTaskService      *service.BackupTaskService
-	BackupExecutionService *service.BackupExecutionService
-	BackupRecordService    *service.BackupRecordService
-	NotificationService    *service.NotificationService
-	DashboardService       *service.DashboardService
-	SettingsService        *service.SettingsService
-	NodeService            *service.NodeService
-	JWTManager             *security.JWTManager
-	UserRepository         repository.UserRepository
-	SystemConfigRepo       repository.SystemConfigRepository
+	Config                   config.Config
+	Version                  string
+	Logger                   *zap.Logger
+	AuthService              *service.AuthService
+	SystemService            *service.SystemService
+	StorageTargetService     *service.StorageTargetService
+	BackupTaskService        *service.BackupTaskService
+	BackupExecutionService   *service.BackupExecutionService
+	BackupRecordService      *service.BackupRecordService
+	NotificationService      *service.NotificationService
+	DashboardService         *service.DashboardService
+	SettingsService          *service.SettingsService
+	NodeService              *service.NodeService
+	DatabaseDiscoveryService *service.DatabaseDiscoveryService
+	AuditService             *service.AuditService
+	JWTManager               *security.JWTManager
+	UserRepository           repository.UserRepository
+	SystemConfigRepo         repository.SystemConfigRepository
 }
 
 func NewRouter(deps RouterDependencies) *gin.Engine {
@@ -42,13 +44,14 @@ func NewRouter(deps RouterDependencies) *gin.Engine {
 
 	authHandler := NewAuthHandler(deps.AuthService)
 	systemHandler := NewSystemHandler(deps.SystemService)
-	storageTargetHandler := NewStorageTargetHandler(deps.StorageTargetService)
-	backupTaskHandler := NewBackupTaskHandler(deps.BackupTaskService)
-	backupRunHandler := NewBackupRunHandler(deps.BackupExecutionService)
-	backupRecordHandler := NewBackupRecordHandler(deps.BackupRecordService)
+	storageTargetHandler := NewStorageTargetHandler(deps.StorageTargetService, deps.AuditService)
+	backupTaskHandler := NewBackupTaskHandler(deps.BackupTaskService, deps.AuditService)
+	backupRunHandler := NewBackupRunHandler(deps.BackupExecutionService, deps.AuditService)
+	backupRecordHandler := NewBackupRecordHandler(deps.BackupRecordService, deps.AuditService)
 	notificationHandler := NewNotificationHandler(deps.NotificationService)
 	dashboardHandler := NewDashboardHandler(deps.DashboardService)
-	settingsHandler := NewSettingsHandler(deps.SettingsService)
+	settingsHandler := NewSettingsHandler(deps.SettingsService, deps.AuditService)
+	auditHandler := NewAuditHandler(deps.AuditService)
 
 	api := engine.Group("/api")
 	{
@@ -65,20 +68,27 @@ func NewRouter(deps RouterDependencies) *gin.Engine {
 		system := api.Group("/system")
 		system.Use(AuthMiddleware(deps.JWTManager))
 		system.GET("/info", systemHandler.Info)
+		system.GET("/update-check", systemHandler.CheckUpdate)
+		system.POST("/update-apply", systemHandler.ApplyUpdate)
 
 		storageTargets := api.Group("/storage-targets")
 		storageTargets.Use(AuthMiddleware(deps.JWTManager))
+		// 静态路由必须在参数路由 /:id 之前注册，避免 Gin 路由冲突
 		storageTargets.GET("", storageTargetHandler.List)
-		storageTargets.GET("/:id", storageTargetHandler.Get)
 		storageTargets.POST("", storageTargetHandler.Create)
-		storageTargets.PUT("/:id", storageTargetHandler.Update)
-		storageTargets.DELETE("/:id", storageTargetHandler.Delete)
 		storageTargets.POST("/test", storageTargetHandler.TestConnection)
-		storageTargets.POST("/:id/test", storageTargetHandler.TestSavedConnection)
-		storageTargets.GET("/:id/usage", storageTargetHandler.GetUsage)
 		storageTargets.POST("/google-drive/auth-url", storageTargetHandler.StartGoogleDriveOAuth)
 		storageTargets.POST("/google-drive/complete", storageTargetHandler.CompleteGoogleDriveOAuth)
 		storageTargets.GET("/google-drive/callback", storageTargetHandler.HandleGoogleDriveCallback)
+		rcloneHandler := NewRcloneHandler()
+		storageTargets.GET("/rclone/backends", rcloneHandler.ListBackends)
+		// 参数路由
+		storageTargets.GET("/:id", storageTargetHandler.Get)
+		storageTargets.PUT("/:id", storageTargetHandler.Update)
+		storageTargets.DELETE("/:id", storageTargetHandler.Delete)
+		storageTargets.PUT("/:id/star", storageTargetHandler.ToggleStar)
+		storageTargets.POST("/:id/test", storageTargetHandler.TestSavedConnection)
+		storageTargets.GET("/:id/usage", storageTargetHandler.GetUsage)
 		storageTargets.GET("/:id/google-drive/profile", storageTargetHandler.GoogleDriveProfile)
 
 		backupTasks := api.Group("/backup/tasks")
@@ -98,6 +108,7 @@ func NewRouter(deps RouterDependencies) *gin.Engine {
 		backupRecords.GET("/:id/logs/stream", backupRecordHandler.StreamLogs)
 		backupRecords.GET("/:id/download", backupRecordHandler.Download)
 		backupRecords.POST("/:id/restore", backupRecordHandler.Restore)
+		backupRecords.POST("/batch-delete", backupRecordHandler.BatchDelete)
 		backupRecords.DELETE("/:id", backupRecordHandler.Delete)
 		dashboard := api.Group("/dashboard")
 		dashboard.Use(AuthMiddleware(deps.JWTManager))
@@ -119,6 +130,17 @@ func NewRouter(deps RouterDependencies) *gin.Engine {
 		settings.GET("", settingsHandler.Get)
 		settings.PUT("", settingsHandler.Update)
 
+		auditLogs := api.Group("/audit-logs")
+		auditLogs.Use(AuthMiddleware(deps.JWTManager))
+		auditLogs.GET("", auditHandler.List)
+
+		if deps.DatabaseDiscoveryService != nil {
+			databaseHandler := NewDatabaseHandler(deps.DatabaseDiscoveryService)
+			database := api.Group("/database")
+			database.Use(AuthMiddleware(deps.JWTManager))
+			database.POST("/discover", databaseHandler.Discover)
+		}
+
 		nodeHandler := NewNodeHandler(deps.NodeService)
 		nodes := api.Group("/nodes")
 		nodes.Use(AuthMiddleware(deps.JWTManager))

server/internal/http/settings_handler.go

@@ -1,6 +1,9 @@
 package http
 
 import (
+	"fmt"
+	"strings"
+
 	"backupx/server/internal/apperror"
 	"backupx/server/internal/service"
 	"backupx/server/pkg/response"
@@ -9,10 +12,11 @@ import (
 
 type SettingsHandler struct {
 	settingsService *service.SettingsService
+	auditService    *service.AuditService
 }
 
-func NewSettingsHandler(settingsService *service.SettingsService) *SettingsHandler {
-	return &SettingsHandler{settingsService: settingsService}
+func NewSettingsHandler(settingsService *service.SettingsService, auditService *service.AuditService) *SettingsHandler {
+	return &SettingsHandler{settingsService: settingsService, auditService: auditService}
 }
 
 func (h *SettingsHandler) Get(c *gin.Context) {
@@ -35,5 +39,10 @@ func (h *SettingsHandler) Update(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	keys := make([]string, 0, len(input))
+	for k := range input {
+		keys = append(keys, k)
+	}
+	recordAudit(c, h.auditService, "settings", "update", "settings", "", "", fmt.Sprintf("修改设置: %s", strings.Join(keys, ", ")))
 	response.Success(c, settings)
 }

server/internal/http/storage_target_handler.go

@@ -12,7 +12,8 @@ import (
 )
 
 type StorageTargetHandler struct {
-	service *service.StorageTargetService
+	service      *service.StorageTargetService
+	auditService *service.AuditService
 }
 
 type storageTargetGoogleDriveAuthRequest struct {
@@ -27,8 +28,8 @@ type storageTargetGoogleDriveAuthRequest struct {
 	FolderID     string         `json:"folderId"`
 }
 
-func NewStorageTargetHandler(service *service.StorageTargetService) *StorageTargetHandler {
-	return &StorageTargetHandler{service: service}
+func NewStorageTargetHandler(service *service.StorageTargetService, auditService *service.AuditService) *StorageTargetHandler {
+	return &StorageTargetHandler{service: service, auditService: auditService}
 }
 
 func (h *StorageTargetHandler) List(c *gin.Context) {
@@ -64,6 +65,7 @@ func (h *StorageTargetHandler) Create(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "storage_target", "create", "storage_target", fmt.Sprintf("%d", item.ID), item.Name, fmt.Sprintf("类型: %s", input.Type))
 	response.Success(c, item)
 }
 
@@ -82,6 +84,7 @@ func (h *StorageTargetHandler) Update(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "storage_target", "update", "storage_target", fmt.Sprintf("%d", item.ID), item.Name, fmt.Sprintf("类型: %s", input.Type))
 	response.Success(c, item)
 }
 
@@ -94,6 +97,7 @@ func (h *StorageTargetHandler) Delete(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "storage_target", "delete", "storage_target", fmt.Sprintf("%d", id), "", fmt.Sprintf("删除存储目标 #%d", id))
 	response.Success(c, gin.H{"deleted": true})
 }
 
@@ -230,6 +234,19 @@ func firstNonEmpty(values ...string) string {
 	return ""
 }
 
+func (h *StorageTargetHandler) ToggleStar(c *gin.Context) {
+	id, ok := parseUintParam(c, "id")
+	if !ok {
+		return
+	}
+	item, err := h.service.ToggleStar(c.Request.Context(), id)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, item)
+}
+
 func (h *StorageTargetHandler) GetUsage(c *gin.Context) {
 	id, ok := parseUintParam(c, "id")
 	if !ok {

server/internal/http/system_handler.go

@@ -17,3 +17,26 @@ func NewSystemHandler(systemService *service.SystemService) *SystemHandler {
 func (h *SystemHandler) Info(c *gin.Context) {
 	response.Success(c, h.systemService.GetInfo(c.Request.Context()))
 }
+
+func (h *SystemHandler) ApplyUpdate(c *gin.Context) {
+	var input struct {
+		Version string `json:"version"`
+	}
+	_ = c.ShouldBindJSON(&input)
+	result := h.systemService.ApplyDockerUpdate(c.Request.Context(), input.Version)
+	response.Success(c, result)
+}
+
+func (h *SystemHandler) CheckUpdate(c *gin.Context) {
+	result, err := h.systemService.CheckUpdate(c.Request.Context())
+	if err != nil {
+		// 即使检查失败也返回当前版本信息
+		response.Success(c, gin.H{
+			"currentVersion": result.CurrentVersion,
+			"hasUpdate":      false,
+			"error":          err.Error(),
+		})
+		return
+	}
+	response.Success(c, result)
+}

server/internal/model/audit_log.go

@@ -0,0 +1,21 @@
+package model
+
+import "time"
+
+type AuditLog struct {
+	ID         uint      `gorm:"primaryKey" json:"id"`
+	UserID     uint      `gorm:"column:user_id;index" json:"userId"`
+	Username   string    `gorm:"column:username;size:64;not null" json:"username"`
+	Category   string    `gorm:"column:category;size:32;index;not null" json:"category"`
+	Action     string    `gorm:"column:action;size:64;not null" json:"action"`
+	TargetType string    `gorm:"column:target_type;size:32" json:"targetType"`
+	TargetID   string    `gorm:"column:target_id;size:64" json:"targetId"`
+	TargetName string    `gorm:"column:target_name;size:128" json:"targetName"`
+	Detail     string    `gorm:"column:detail;type:text" json:"detail"`
+	ClientIP   string    `gorm:"column:client_ip;size:45" json:"clientIp"`
+	CreatedAt  time.Time `gorm:"index" json:"createdAt"`
+}
+
+func (AuditLog) TableName() string {
+	return "audit_logs"
+}

server/internal/model/backup_record.go

@@ -9,22 +9,24 @@ const (
 )
 
 type BackupRecord struct {
-	ID              uint          `gorm:"primaryKey" json:"id"`
-	TaskID          uint          `gorm:"column:task_id;index;not null" json:"taskId"`
-	Task            BackupTask    `json:"task,omitempty"`
-	StorageTargetID uint          `gorm:"column:storage_target_id;index;not null" json:"storageTargetId"`
-	StorageTarget   StorageTarget `json:"storageTarget,omitempty"`
-	Status          string        `gorm:"size:20;index;not null" json:"status"`
-	FileName        string        `gorm:"column:file_name;size:255" json:"fileName"`
-	FileSize        int64         `gorm:"column:file_size;not null;default:0" json:"fileSize"`
-	StoragePath     string        `gorm:"column:storage_path;size:500" json:"storagePath"`
-	DurationSeconds int           `gorm:"column:duration_seconds;not null;default:0" json:"durationSeconds"`
-	ErrorMessage    string        `gorm:"column:error_message;size:2000" json:"errorMessage"`
-	LogContent      string        `gorm:"column:log_content;type:text" json:"logContent"`
-	StartedAt       time.Time     `gorm:"column:started_at;index;not null" json:"startedAt"`
-	CompletedAt     *time.Time    `gorm:"column:completed_at;index" json:"completedAt,omitempty"`
-	CreatedAt       time.Time     `json:"createdAt"`
-	UpdatedAt       time.Time     `json:"updatedAt"`
+	ID                   uint          `gorm:"primaryKey" json:"id"`
+	TaskID               uint          `gorm:"column:task_id;index;not null" json:"taskId"`
+	Task                 BackupTask    `json:"task,omitempty"`
+	StorageTargetID      uint          `gorm:"column:storage_target_id;index;not null" json:"storageTargetId"`
+	StorageTarget        StorageTarget `json:"storageTarget,omitempty"`
+	Status               string        `gorm:"size:20;index;not null" json:"status"`
+	FileName             string        `gorm:"column:file_name;size:255" json:"fileName"`
+	FileSize             int64         `gorm:"column:file_size;not null;default:0" json:"fileSize"`
+	Checksum             string        `gorm:"column:checksum;size:64" json:"checksum"`
+	StoragePath          string        `gorm:"column:storage_path;size:500" json:"storagePath"`
+	StorageUploadResults string        `gorm:"column:storage_upload_results;type:text" json:"-"`
+	DurationSeconds      int           `gorm:"column:duration_seconds;not null;default:0" json:"durationSeconds"`
+	ErrorMessage         string        `gorm:"column:error_message;size:2000" json:"errorMessage"`
+	LogContent           string        `gorm:"column:log_content;type:text" json:"logContent"`
+	StartedAt            time.Time     `gorm:"column:started_at;index;not null" json:"startedAt"`
+	CompletedAt          *time.Time    `gorm:"column:completed_at;index" json:"completedAt,omitempty"`
+	CreatedAt            time.Time     `json:"createdAt"`
+	UpdatedAt            time.Time     `json:"updatedAt"`
 }
 
 func (BackupRecord) TableName() string {

server/internal/model/backup_task.go

@@ -17,34 +17,46 @@ const (
 )
 
 type BackupTask struct {
-	ID                   uint          `gorm:"primaryKey" json:"id"`
-	Name                 string        `gorm:"size:100;uniqueIndex;not null" json:"name"`
-	Type                 string        `gorm:"size:20;index;not null" json:"type"`
-	Enabled              bool          `gorm:"not null;default:true" json:"enabled"`
-	CronExpr             string        `gorm:"column:cron_expr;size:64" json:"cronExpr"`
-	SourcePath           string        `gorm:"column:source_path;size:500" json:"sourcePath"`
-	ExcludePatterns      string        `gorm:"column:exclude_patterns;type:text" json:"excludePatterns"`
-	DBHost               string        `gorm:"column:db_host;size:255" json:"dbHost"`
-	DBPort               int           `gorm:"column:db_port" json:"dbPort"`
-	DBUser               string        `gorm:"column:db_user;size:100" json:"dbUser"`
-	DBPasswordCiphertext string        `gorm:"column:db_password_ciphertext;type:text" json:"-"`
-	DBName               string        `gorm:"column:db_name;size:255" json:"dbName"`
-	DBPath               string        `gorm:"column:db_path;size:500" json:"dbPath"`
-	StorageTargetID      uint          `gorm:"column:storage_target_id;index;not null" json:"storageTargetId"`
-	StorageTarget        StorageTarget `json:"storageTarget,omitempty"`
-	NodeID               uint          `gorm:"column:node_id;index;default:0" json:"nodeId"`
-	Node                 Node          `json:"node,omitempty"`
-	Tags                 string        `gorm:"column:tags;size:500" json:"tags"`
-	RetentionDays        int           `gorm:"column:retention_days;not null;default:30" json:"retentionDays"`
-	Compression          string        `gorm:"size:10;not null;default:'gzip'" json:"compression"`
-	Encrypt              bool          `gorm:"not null;default:false" json:"encrypt"`
-	MaxBackups           int           `gorm:"column:max_backups;not null;default:10" json:"maxBackups"`
-	LastRunAt            *time.Time    `gorm:"column:last_run_at" json:"lastRunAt,omitempty"`
-	LastStatus           string        `gorm:"column:last_status;size:20;not null;default:'idle'" json:"lastStatus"`
-	CreatedAt            time.Time     `json:"createdAt"`
-	UpdatedAt            time.Time     `json:"updatedAt"`
+	ID                   uint            `gorm:"primaryKey" json:"id"`
+	Name                 string          `gorm:"size:100;uniqueIndex;not null" json:"name"`
+	Type                 string          `gorm:"size:20;index;not null" json:"type"`
+	Enabled              bool            `gorm:"not null;default:true" json:"enabled"`
+	CronExpr             string          `gorm:"column:cron_expr;size:64" json:"cronExpr"`
+	SourcePath           string          `gorm:"column:source_path;size:500" json:"sourcePath"`
+	SourcePaths          string          `gorm:"column:source_paths;type:text" json:"sourcePaths"`
+	ExcludePatterns      string          `gorm:"column:exclude_patterns;type:text" json:"excludePatterns"`
+	DBHost               string          `gorm:"column:db_host;size:255" json:"dbHost"`
+	DBPort               int             `gorm:"column:db_port" json:"dbPort"`
+	DBUser               string          `gorm:"column:db_user;size:100" json:"dbUser"`
+	DBPasswordCiphertext string          `gorm:"column:db_password_ciphertext;type:text" json:"-"`
+	DBName               string          `gorm:"column:db_name;size:255" json:"dbName"`
+	DBPath               string          `gorm:"column:db_path;size:500" json:"dbPath"`
+	StorageTargetID      uint            `gorm:"column:storage_target_id;index;not null" json:"storageTargetId"`           // deprecated: 保留兼容
+	StorageTarget        StorageTarget   `json:"storageTarget,omitempty"`                                                  // deprecated: 保留兼容
+	StorageTargets       []StorageTarget `gorm:"many2many:backup_task_storage_targets" json:"storageTargets,omitempty"`
+	NodeID               uint            `gorm:"column:node_id;index;default:0" json:"nodeId"`
+	Node                 Node            `json:"node,omitempty"`
+	Tags                 string          `gorm:"column:tags;size:500" json:"tags"`
+	RetentionDays        int             `gorm:"column:retention_days;not null;default:30" json:"retentionDays"`
+	Compression          string          `gorm:"size:10;not null;default:'gzip'" json:"compression"`
+	Encrypt              bool            `gorm:"not null;default:false" json:"encrypt"`
+	MaxBackups           int             `gorm:"column:max_backups;not null;default:10" json:"maxBackups"`
+	LastRunAt            *time.Time      `gorm:"column:last_run_at" json:"lastRunAt,omitempty"`
+	LastStatus           string          `gorm:"column:last_status;size:20;not null;default:'idle'" json:"lastStatus"`
+	CreatedAt            time.Time       `json:"createdAt"`
+	UpdatedAt            time.Time       `json:"updatedAt"`
 }
 
 func (BackupTask) TableName() string {
 	return "backup_tasks"
 }
+
+// BackupTaskStorageTarget 多对多中间表
+type BackupTaskStorageTarget struct {
+	BackupTaskID    uint `gorm:"primaryKey;column:backup_task_id"`
+	StorageTargetID uint `gorm:"primaryKey;column:storage_target_id"`
+}
+
+func (BackupTaskStorageTarget) TableName() string {
+	return "backup_task_storage_targets"
+}

server/internal/model/storage_target.go

@@ -8,6 +8,7 @@ type StorageTarget struct {
 	Type             string     `gorm:"size:32;index;not null" json:"type"`
 	Description      string     `gorm:"size:255" json:"description"`
 	Enabled          bool       `gorm:"not null;default:true" json:"enabled"`
+	Starred          bool       `gorm:"not null;default:false" json:"starred"`
 	ConfigCiphertext string     `gorm:"column:config_ciphertext;type:text;not null" json:"-"`
 	ConfigVersion    int        `gorm:"not null;default:1" json:"configVersion"`
 	LastTestedAt     *time.Time `gorm:"column:last_tested_at" json:"lastTestedAt,omitempty"`

server/internal/repository/audit_log_repository.go

@@ -0,0 +1,56 @@
+package repository
+
+import (
+	"context"
+
+	"backupx/server/internal/model"
+	"gorm.io/gorm"
+)
+
+type AuditLogListOptions struct {
+	Category string
+	Limit    int
+	Offset   int
+}
+
+type AuditLogListResult struct {
+	Items []model.AuditLog `json:"items"`
+	Total int64            `json:"total"`
+}
+
+type AuditLogRepository interface {
+	Create(ctx context.Context, log *model.AuditLog) error
+	List(ctx context.Context, opts AuditLogListOptions) (*AuditLogListResult, error)
+}
+
+type gormAuditLogRepository struct {
+	db *gorm.DB
+}
+
+func NewAuditLogRepository(db *gorm.DB) AuditLogRepository {
+	return &gormAuditLogRepository{db: db}
+}
+
+func (r *gormAuditLogRepository) Create(_ context.Context, log *model.AuditLog) error {
+	return r.db.Create(log).Error
+}
+
+func (r *gormAuditLogRepository) List(_ context.Context, opts AuditLogListOptions) (*AuditLogListResult, error) {
+	query := r.db.Model(&model.AuditLog{})
+	if opts.Category != "" {
+		query = query.Where("category = ?", opts.Category)
+	}
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, err
+	}
+	limit := opts.Limit
+	if limit <= 0 {
+		limit = 50
+	}
+	var items []model.AuditLog
+	if err := query.Order("created_at DESC").Offset(opts.Offset).Limit(limit).Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return &AuditLogListResult{Items: items, Total: total}, nil
+}

server/internal/repository/backup_task_repository.go

@@ -35,7 +35,7 @@ func NewBackupTaskRepository(db *gorm.DB) *GormBackupTaskRepository {
 }
 
 func (r *GormBackupTaskRepository) List(ctx context.Context, options BackupTaskListOptions) ([]model.BackupTask, error) {
-	query := r.db.WithContext(ctx).Model(&model.BackupTask{}).Preload("StorageTarget").Order("updated_at desc")
+	query := r.db.WithContext(ctx).Model(&model.BackupTask{}).Preload("StorageTarget").Preload("StorageTargets").Order("updated_at desc")
 	if options.Type != "" {
 		query = query.Where("type = ?", options.Type)
 	}
@@ -51,7 +51,7 @@ func (r *GormBackupTaskRepository) List(ctx context.Context, options BackupTaskL
 
 func (r *GormBackupTaskRepository) FindByID(ctx context.Context, id uint) (*model.BackupTask, error) {
 	var item model.BackupTask
-	if err := r.db.WithContext(ctx).Preload("StorageTarget").First(&item, id).Error; err != nil {
+	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").First(&item, id).Error; err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, nil
 		}
@@ -73,7 +73,7 @@ func (r *GormBackupTaskRepository) FindByName(ctx context.Context, name string)
 
 func (r *GormBackupTaskRepository) ListSchedulable(ctx context.Context) ([]model.BackupTask, error) {
 	var items []model.BackupTask
-	if err := r.db.WithContext(ctx).Preload("StorageTarget").Where("enabled = ? AND cron_expr <> ''", true).Order("id asc").Find(&items).Error; err != nil {
+	if err := r.db.WithContext(ctx).Preload("StorageTarget").Preload("StorageTargets").Where("enabled = ? AND cron_expr <> ''", true).Order("id asc").Find(&items).Error; err != nil {
 		return nil, err
 	}
 	return items, nil
@@ -97,18 +97,39 @@ func (r *GormBackupTaskRepository) CountEnabled(ctx context.Context) (int64, err
 
 func (r *GormBackupTaskRepository) CountByStorageTargetID(ctx context.Context, storageTargetID uint) (int64, error) {
 	var count int64
-	if err := r.db.WithContext(ctx).Model(&model.BackupTask{}).Where("storage_target_id = ?", storageTargetID).Count(&count).Error; err != nil {
+	if err := r.db.WithContext(ctx).Model(&model.BackupTaskStorageTarget{}).Where("storage_target_id = ?", storageTargetID).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
 }
 
 func (r *GormBackupTaskRepository) Create(ctx context.Context, item *model.BackupTask) error {
-	return r.db.WithContext(ctx).Create(item).Error
+	if err := r.db.WithContext(ctx).Create(item).Error; err != nil {
+		return err
+	}
+	return r.syncStorageTargets(ctx, item)
 }
 
 func (r *GormBackupTaskRepository) Update(ctx context.Context, item *model.BackupTask) error {
-	return r.db.WithContext(ctx).Save(item).Error
+	if err := r.db.WithContext(ctx).Save(item).Error; err != nil {
+		return err
+	}
+	if len(item.StorageTargets) > 0 {
+		return r.db.WithContext(ctx).Model(item).Association("StorageTargets").Replace(item.StorageTargets)
+	}
+	return nil
+}
+
+// syncStorageTargets 确保中间表数据一致：优先使用 StorageTargets，回退到 StorageTargetID
+func (r *GormBackupTaskRepository) syncStorageTargets(ctx context.Context, item *model.BackupTask) error {
+	targets := item.StorageTargets
+	if len(targets) == 0 && item.StorageTargetID > 0 {
+		targets = []model.StorageTarget{{ID: item.StorageTargetID}}
+	}
+	if len(targets) > 0 {
+		return r.db.WithContext(ctx).Model(item).Association("StorageTargets").Replace(targets)
+	}
+	return nil
 }
 
 func (r *GormBackupTaskRepository) Delete(ctx context.Context, id uint) error {

server/internal/repository/storage_target_repository.go

@@ -27,7 +27,7 @@ func NewStorageTargetRepository(db *gorm.DB) *GormStorageTargetRepository {
 
 func (r *GormStorageTargetRepository) List(ctx context.Context) ([]model.StorageTarget, error) {
 	var items []model.StorageTarget
-	if err := r.db.WithContext(ctx).Order("updated_at desc").Find(&items).Error; err != nil {
+	if err := r.db.WithContext(ctx).Order("starred desc, updated_at desc").Find(&items).Error; err != nil {
 		return nil, err
 	}
 	return items, nil

server/internal/scheduler/service.go

@@ -17,12 +17,18 @@ type TaskRunner interface {
 	RunTaskByID(context.Context, uint) (*servicepkg.BackupRecordDetail, error)
 }
 
+// AuditRecorder 记录审计日志（可选依赖）
+type AuditRecorder interface {
+	Record(servicepkg.AuditEntry)
+}
+
 type Service struct {
 	mu      sync.Mutex
 	cron    *cron.Cron
 	tasks   repository.BackupTaskRepository
 	runner  TaskRunner
 	logger  *zap.Logger
+	audit   AuditRecorder
 	entries map[uint]cron.EntryID
 }
 
@@ -31,6 +37,8 @@ func NewService(tasks repository.BackupTaskRepository, runner TaskRunner, logger
 	return &Service{cron: cron.New(cron.WithParser(parser), cron.WithLocation(time.UTC)), tasks: tasks, runner: runner, logger: logger, entries: make(map[uint]cron.EntryID)}
 }
 
+func (s *Service) SetAuditRecorder(audit AuditRecorder) { s.audit = audit }
+
 func (s *Service) Start(ctx context.Context) error {
 	if err := s.Reload(ctx); err != nil {
 		return err
@@ -96,9 +104,19 @@ func (s *Service) syncTaskLocked(task *model.BackupTask) error {
 	if !task.Enabled || task.CronExpr == "" {
 		return nil
 	}
+	taskID := task.ID
+	taskName := task.Name
 	entryID, err := s.cron.AddFunc(task.CronExpr, func() {
-		if _, runErr := s.runner.RunTaskByID(context.Background(), task.ID); runErr != nil && s.logger != nil {
-			s.logger.Warn("scheduled backup run failed", zap.Uint("task_id", task.ID), zap.Error(runErr))
+		// 自动调度任务记录审计日志
+		if s.audit != nil {
+			s.audit.Record(servicepkg.AuditEntry{
+				Username: "system", Category: "backup_task", Action: "scheduled_run",
+				TargetType: "backup_task", TargetID: fmt.Sprintf("%d", taskID),
+				TargetName: taskName, Detail: fmt.Sprintf("定时调度触发备份任务: %s (cron: %s)", taskName, task.CronExpr),
+			})
+		}
+		if _, runErr := s.runner.RunTaskByID(context.Background(), taskID); runErr != nil && s.logger != nil {
+			s.logger.Warn("scheduled backup run failed", zap.Uint("task_id", taskID), zap.Error(runErr))
 		}
 	})
 	if err != nil {

server/internal/service/audit_service.go

@@ -0,0 +1,68 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"backupx/server/internal/apperror"
+	"backupx/server/internal/model"
+	"backupx/server/internal/repository"
+)
+
+// AuditEntry 是记录审计日志的输入结构
+type AuditEntry struct {
+	UserID     uint
+	Username   string
+	Category   string // auth / storage_target / backup_task / backup_record / settings
+	Action     string // create / update / delete / login_success / login_failed / ...
+	TargetType string
+	TargetID   string
+	TargetName string
+	Detail     string
+	ClientIP   string
+}
+
+type AuditService struct {
+	repo repository.AuditLogRepository
+}
+
+func NewAuditService(repo repository.AuditLogRepository) *AuditService {
+	return &AuditService{repo: repo}
+}
+
+// Record 异步 fire-and-forget 写入审计日志，不阻塞业务逻辑
+func (s *AuditService) Record(entry AuditEntry) {
+	if s == nil || s.repo == nil {
+		return
+	}
+	go func() {
+		record := &model.AuditLog{
+			UserID:     entry.UserID,
+			Username:   entry.Username,
+			Category:   entry.Category,
+			Action:     entry.Action,
+			TargetType: entry.TargetType,
+			TargetID:   entry.TargetID,
+			TargetName: entry.TargetName,
+			Detail:     entry.Detail,
+			ClientIP:   entry.ClientIP,
+		}
+		if err := s.repo.Create(context.Background(), record); err != nil {
+			log.Printf("[audit] failed to write audit log: %v", err)
+		}
+	}()
+}
+
+// List 分页查询审计日志
+func (s *AuditService) List(ctx context.Context, category string, limit, offset int) (*repository.AuditLogListResult, error) {
+	result, err := s.repo.List(ctx, repository.AuditLogListOptions{
+		Category: category,
+		Limit:    limit,
+		Offset:   offset,
+	})
+	if err != nil {
+		return nil, apperror.Internal("AUDIT_LOG_LIST_FAILED", fmt.Sprintf("无法获取审计日志列表: %v", err), err)
+	}
+	return result, nil
+}

server/internal/service/auth_service.go

@@ -37,10 +37,11 @@ type UserOutput struct {
 }
 
 type AuthService struct {
-	users       repository.UserRepository
-	configs     repository.SystemConfigRepository
-	jwtManager  *security.JWTManager
-	rateLimiter *security.LoginRateLimiter
+	users        repository.UserRepository
+	configs      repository.SystemConfigRepository
+	jwtManager   *security.JWTManager
+	rateLimiter  *security.LoginRateLimiter
+	auditService *AuditService
 }
 
 func NewAuthService(
@@ -52,6 +53,10 @@ func NewAuthService(
 	return &AuthService{users: users, configs: configs, jwtManager: jwtManager, rateLimiter: rateLimiter}
 }
 
+func (s *AuthService) SetAuditService(auditService *AuditService) {
+	s.auditService = auditService
+}
+
 func (s *AuthService) SetupStatus(ctx context.Context) (bool, error) {
 	count, err := s.users.Count(ctx)
 	if err != nil {
@@ -97,6 +102,15 @@ func (s *AuthService) Setup(ctx context.Context, input SetupInput) (*AuthPayload
 		return nil, apperror.Internal("AUTH_TOKEN_FAILED", "无法生成访问令牌", err)
 	}
 
+	if s.auditService != nil {
+		s.auditService.Record(AuditEntry{
+			UserID: user.ID, Username: user.Username,
+			Category: "auth", Action: "setup",
+			TargetType: "user", TargetID: fmt.Sprintf("%d", user.ID), TargetName: user.Username,
+			Detail: "系统初始化，创建管理员账户",
+		})
+	}
+
 	return &AuthPayload{Token: token, User: ToUserOutput(user)}, nil
 }
 
@@ -113,9 +127,23 @@ func (s *AuthService) Login(ctx context.Context, input LoginInput, clientKey str
 		return nil, apperror.Internal("AUTH_LOOKUP_FAILED", "无法执行登录校验", err)
 	}
 	if user == nil {
+		if s.auditService != nil {
+			s.auditService.Record(AuditEntry{
+				Category: "auth", Action: "login_failed",
+				Detail: fmt.Sprintf("用户名不存在: %s", strings.TrimSpace(input.Username)),
+				ClientIP: clientKey,
+			})
+		}
 		return nil, apperror.Unauthorized("AUTH_INVALID_CREDENTIALS", "用户名或密码错误", nil)
 	}
 	if err := security.ComparePassword(user.PasswordHash, input.Password); err != nil {
+		if s.auditService != nil {
+			s.auditService.Record(AuditEntry{
+				UserID: user.ID, Username: user.Username,
+				Category: "auth", Action: "login_failed",
+				Detail: "密码错误", ClientIP: clientKey,
+			})
+		}
 		return nil, apperror.Unauthorized("AUTH_INVALID_CREDENTIALS", "用户名或密码错误", err)
 	}
 
@@ -124,6 +152,15 @@ func (s *AuthService) Login(ctx context.Context, input LoginInput, clientKey str
 	if err != nil {
 		return nil, apperror.Internal("AUTH_TOKEN_FAILED", "无法生成访问令牌", err)
 	}
+
+	if s.auditService != nil {
+		s.auditService.Record(AuditEntry{
+			UserID: user.ID, Username: user.Username,
+			Category: "auth", Action: "login_success",
+			Detail: "登录成功", ClientIP: clientKey,
+		})
+	}
+
 	return &AuthPayload{Token: token, User: ToUserOutput(user)}, nil
 }
 
@@ -170,6 +207,15 @@ func (s *AuthService) ChangePassword(ctx context.Context, subject string, input
 	if err := s.users.Update(ctx, user); err != nil {
 		return apperror.Internal("AUTH_UPDATE_FAILED", "密码修改失败", err)
 	}
+
+	if s.auditService != nil {
+		s.auditService.Record(AuditEntry{
+			UserID: user.ID, Username: user.Username,
+			Category: "auth", Action: "change_password",
+			Detail: "密码修改成功",
+		})
+	}
+
 	return nil
 }
 

server/internal/service/backup_execution_service.go

@@ -2,12 +2,16 @@ package service
 
 import (
 	"context"
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"hash"
 	"io"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 
 	"backupx/server/internal/apperror"
@@ -17,6 +21,7 @@ import (
 	"backupx/server/internal/repository"
 	"backupx/server/internal/storage"
 	"backupx/server/internal/storage/codec"
+	"backupx/server/internal/storage/rclone"
 	"backupx/server/pkg/compress"
 	backupcrypto "backupx/server/pkg/crypto"
 )
@@ -37,11 +42,35 @@ func (noopBackupNotifier) NotifyBackupResult(context.Context, BackupExecutionNot
 	return nil
 }
 
+type StorageUploadResultItem struct {
+	StorageTargetID   uint   `json:"storageTargetId"`
+	StorageTargetName string `json:"storageTargetName"`
+	Status            string `json:"status"`
+	StoragePath       string `json:"storagePath,omitempty"`
+	FileSize          int64  `json:"fileSize,omitempty"`
+	Error             string `json:"error,omitempty"`
+}
+
 type DownloadedArtifact struct {
 	FileName string
 	Reader   io.ReadCloser
 }
 
+// collectTargetIDs 获取任务关联的所有存储目标 ID
+func collectTargetIDs(task *model.BackupTask) []uint {
+	if len(task.StorageTargets) > 0 {
+		ids := make([]uint, len(task.StorageTargets))
+		for i, t := range task.StorageTargets {
+			ids[i] = t.ID
+		}
+		return ids
+	}
+	if task.StorageTargetID > 0 {
+		return []uint{task.StorageTargetID}
+	}
+	return nil
+}
+
 type BackupExecutionService struct {
 	tasks           repository.BackupTaskRepository
 	records         repository.BackupRecordRepository
@@ -56,6 +85,8 @@ type BackupExecutionService struct {
 	now             func() time.Time
 	tempDir         string
 	semaphore       chan struct{}
+	retries         int    // rclone 底层重试次数
+	bandwidthLimit  string // rclone 带宽限制
 }
 
 func NewBackupExecutionService(
@@ -70,6 +101,8 @@ func NewBackupExecutionService(
 	notifier BackupResultNotifier,
 	tempDir string,
 	maxConcurrent int,
+	retries int,
+	bandwidthLimit string,
 ) *BackupExecutionService {
 	if notifier == nil {
 		notifier = noopBackupNotifier{}
@@ -93,9 +126,11 @@ func NewBackupExecutionService(
 		async: func(job func()) {
 			go job()
 		},
-		now:       func() time.Time { return time.Now().UTC() },
-		tempDir:   tempDir,
-		semaphore: make(chan struct{}, maxConcurrent),
+		now:            func() time.Time { return time.Now().UTC() },
+		tempDir:        tempDir,
+		semaphore:      make(chan struct{}, maxConcurrent),
+		retries:        retries,
+		bandwidthLimit: bandwidthLimit,
 	}
 }
 
@@ -194,7 +229,12 @@ func (s *BackupExecutionService) startTask(ctx context.Context, id uint, async b
 		return nil, apperror.New(404, "BACKUP_TASK_NOT_FOUND", "备份任务不存在", fmt.Errorf("backup task %d not found", id))
 	}
 	startedAt := s.now()
-	record := &model.BackupRecord{TaskID: task.ID, StorageTargetID: task.StorageTargetID, Status: "running", StartedAt: startedAt}
+	// 取第一个存储目标 ID 做兼容
+	primaryTargetID := task.StorageTargetID
+	if tids := collectTargetIDs(task); len(tids) > 0 {
+		primaryTargetID = tids[0]
+	}
+	record := &model.BackupRecord{TaskID: task.ID, StorageTargetID: primaryTargetID, Status: "running", StartedAt: startedAt}
 	if err := s.records.Create(ctx, record); err != nil {
 		return nil, apperror.Internal("BACKUP_RECORD_CREATE_FAILED", "无法创建备份记录", err)
 	}
@@ -223,11 +263,22 @@ func (s *BackupExecutionService) executeTask(ctx context.Context, task *model.Ba
 	errMessage := ""
 	var fileName string
 	var fileSize int64
+	var checksum string
 	var storagePath string
+	var uploadResults []StorageUploadResultItem
 	completeRecord := func() {
-		if finalizeErr := s.finalizeRecord(ctx, task, recordID, startedAt, status, errMessage, logger.String(), fileName, fileSize, storagePath); finalizeErr != nil {
+		if finalizeErr := s.finalizeRecord(ctx, task, recordID, startedAt, status, errMessage, logger.String(), fileName, fileSize, checksum, storagePath); finalizeErr != nil {
 			logger.Errorf("写回备份记录失败：%v", finalizeErr)
 		}
+		// 写入多目标上传结果
+		if len(uploadResults) > 0 {
+			if resultsJSON, marshalErr := json.Marshal(uploadResults); marshalErr == nil {
+				if record, findErr := s.records.FindByID(ctx, recordID); findErr == nil && record != nil {
+					record.StorageUploadResults = string(resultsJSON)
+					_ = s.records.Update(ctx, record)
+				}
+			}
+		}
 		if err := s.notifier.NotifyBackupResult(ctx, BackupExecutionNotification{Task: task, Record: &model.BackupRecord{ID: recordID, TaskID: task.ID, Status: status, FileName: fileName, FileSize: fileSize, StoragePath: storagePath, ErrorMessage: errMessage, StartedAt: startedAt}, Error: buildOptionalError(errMessage)}); err != nil {
 			logger.Warnf("发送备份通知失败：%v", err)
 		}
@@ -241,12 +292,6 @@ func (s *BackupExecutionService) executeTask(ctx context.Context, task *model.Ba
 		logger.Errorf("构建任务运行时配置失败：%v", err)
 		return
 	}
-	provider, err := s.resolveProvider(ctx, task.StorageTargetID)
-	if err != nil {
-		errMessage = err.Error()
-		logger.Errorf("创建存储客户端失败：%v", err)
-		return
-	}
 	runner, err := s.runnerRegistry.Runner(spec.Type)
 	if err != nil {
 		errMessage = err.Error()
@@ -290,34 +335,126 @@ func (s *BackupExecutionService) executeTask(ctx context.Context, task *model.Ba
 	fileSize = info.Size()
 	fileName = filepath.Base(finalPath)
 	storagePath = backup.BuildStorageKey(task.Type, startedAt, fileName)
-	artifact, err := os.Open(finalPath)
-	if err != nil {
-		errMessage = err.Error()
-		logger.Errorf("打开备份文件失败：%v", err)
+
+	// 收集所有存储目标
+	targetIDs := collectTargetIDs(task)
+	if len(targetIDs) == 0 {
+		errMessage = "没有关联的存储目标"
+		logger.Errorf("没有关联的存储目标")
 		return
 	}
-	defer artifact.Close()
-	logger.Infof("开始上传备份到存储目标")
-	if err := provider.Upload(ctx, storagePath, artifact, fileSize, map[string]string{"taskId": fmt.Sprintf("%d", task.ID), "recordId": fmt.Sprintf("%d", recordID)}); err != nil {
-		errMessage = err.Error()
-		logger.Errorf("上传备份文件失败：%v", err)
-		return
-	}
-	if s.retention != nil {
-		cleanupResult, cleanupErr := s.retention.Cleanup(ctx, task, provider)
-		if cleanupErr != nil {
-			logger.Warnf("执行保留策略失败：%v", cleanupErr)
-		} else {
-			for _, warning := range cleanupResult.Warnings {
-				logger.Warnf("保留策略警告：%s", warning)
+
+	// 并行上传到所有目标
+	uploadResults = make([]StorageUploadResultItem, len(targetIDs))
+	var checksumOnce sync.Once
+	var wg sync.WaitGroup
+	for i, tid := range targetIDs {
+		wg.Add(1)
+		go func(index int, targetID uint) {
+			defer wg.Done()
+			target, findErr := s.targets.FindByID(ctx, targetID)
+			targetName := fmt.Sprintf("target-%d", targetID)
+			if findErr == nil && target != nil {
+				targetName = target.Name
 			}
+			provider, resolveErr := s.resolveProvider(ctx, targetID)
+			if resolveErr != nil {
+				uploadResults[index] = StorageUploadResultItem{StorageTargetID: targetID, StorageTargetName: targetName, Status: "failed", Error: resolveErr.Error()}
+				logger.Warnf("存储目标 %s 创建客户端失败：%v", targetName, resolveErr)
+				return
+			}
+			logger.Infof("开始上传备份到存储目标：%s", targetName)
+			// 上传级重试：最多 3 次，指数退避（10s, 30s, 90s）
+			maxAttempts := 3
+			var lastUploadErr error
+			var hr *hashingReader
+			for attempt := 1; attempt <= maxAttempts; attempt++ {
+				if attempt > 1 {
+					backoff := time.Duration(attempt*attempt) * 10 * time.Second
+					logger.Warnf("存储目标 %s 第 %d 次重试（等待 %v）：%v", targetName, attempt, backoff, lastUploadErr)
+					time.Sleep(backoff)
+				}
+				artifact, openErr := os.Open(finalPath)
+				if openErr != nil {
+					uploadResults[index] = StorageUploadResultItem{StorageTargetID: targetID, StorageTargetName: targetName, Status: "failed", Error: openErr.Error()}
+					logger.Warnf("存储目标 %s 打开备份文件失败：%v", targetName, openErr)
+					return
+				}
+				hr = newHashingReader(artifact)
+				pr := newProgressReader(hr, fileSize, func(bytesRead int64, speedBps float64) {
+					percent := float64(0)
+					if fileSize > 0 {
+						percent = float64(bytesRead) / float64(fileSize) * 100
+					}
+					s.logHub.AppendProgress(recordID, backup.ProgressInfo{
+						BytesSent:  bytesRead,
+						TotalBytes: fileSize,
+						Percent:    percent,
+						SpeedBps:   speedBps,
+						TargetName: targetName,
+					})
+				})
+				lastUploadErr = provider.Upload(ctx, storagePath, pr, fileSize, map[string]string{"taskId": fmt.Sprintf("%d", task.ID), "recordId": fmt.Sprintf("%d", recordID)})
+				artifact.Close()
+				if lastUploadErr == nil {
+					break
+				}
+			}
+			if lastUploadErr != nil {
+				uploadResults[index] = StorageUploadResultItem{StorageTargetID: targetID, StorageTargetName: targetName, Status: "failed", Error: lastUploadErr.Error()}
+				logger.Warnf("存储目标 %s 上传失败（已重试 %d 次）：%v", targetName, maxAttempts, lastUploadErr)
+				return
+			}
+			// 完整性校验：对比实际传输字节数
+			if hr.n != fileSize {
+				uploadResults[index] = StorageUploadResultItem{StorageTargetID: targetID, StorageTargetName: targetName, Status: "failed", Error: fmt.Sprintf("完整性校验失败: 预期 %d bytes, 实际传输 %d bytes", fileSize, hr.n)}
+				logger.Errorf("存储目标 %s 完整性校验失败：预期 %d bytes, 实际传输 %d bytes", targetName, fileSize, hr.n)
+				_ = provider.Delete(ctx, storagePath)
+				return
+			}
+			// 取第一个成功目标的哈希写入 record（所有目标读同一文件，哈希一定相同）
+			targetChecksum := hr.Sum()
+			checksumOnce.Do(func() { checksum = targetChecksum })
+			uploadResults[index] = StorageUploadResultItem{StorageTargetID: targetID, StorageTargetName: targetName, Status: "success", StoragePath: storagePath, FileSize: fileSize}
+			logger.Infof("存储目标 %s 上传成功 (%d bytes, SHA-256=%s)", targetName, fileSize, targetChecksum)
+			// 每个成功目标独立执行保留策略
+			if s.retention != nil {
+				cleanupResult, cleanupErr := s.retention.Cleanup(ctx, task, provider)
+				if cleanupErr != nil {
+					logger.Warnf("存储目标 %s 执行保留策略失败：%v", targetName, cleanupErr)
+				} else {
+					for _, warning := range cleanupResult.Warnings {
+						logger.Warnf("存储目标 %s 保留策略警告：%s", targetName, warning)
+					}
+				}
+			}
+		}(i, tid)
+	}
+	wg.Wait()
+
+	// 汇总结果：任意一个 success → 整体 success
+	anySuccess := false
+	var failedMessages []string
+	for _, r := range uploadResults {
+		if r.Status == "success" {
+			anySuccess = true
+		} else if r.Error != "" {
+			failedMessages = append(failedMessages, fmt.Sprintf("%s: %s", r.StorageTargetName, r.Error))
 		}
 	}
-	status = "success"
-	logger.Infof("备份执行完成")
+	if anySuccess {
+		status = "success"
+		if len(failedMessages) > 0 {
+			logger.Warnf("部分存储目标上传失败：%s", strings.Join(failedMessages, "; "))
+		}
+		logger.Infof("备份执行完成")
+	} else {
+		errMessage = strings.Join(failedMessages, "; ")
+		logger.Errorf("所有存储目标上传均失败")
+	}
 }
 
-func (s *BackupExecutionService) finalizeRecord(ctx context.Context, task *model.BackupTask, recordID uint, startedAt time.Time, status string, errorMessage string, logContent string, fileName string, fileSize int64, storagePath string) error {
+func (s *BackupExecutionService) finalizeRecord(ctx context.Context, task *model.BackupTask, recordID uint, startedAt time.Time, status string, errorMessage string, logContent string, fileName string, fileSize int64, checksum string, storagePath string) error {
 	record, err := s.records.FindByID(ctx, recordID)
 	if err != nil {
 		return err
@@ -329,6 +466,7 @@ func (s *BackupExecutionService) finalizeRecord(ctx context.Context, task *model
 	record.Status = status
 	record.FileName = fileName
 	record.FileSize = fileSize
+	record.Checksum = checksum
 	record.StoragePath = storagePath
 	record.DurationSeconds = int(completedAt.Sub(startedAt).Seconds())
 	record.ErrorMessage = strings.TrimSpace(errorMessage)
@@ -343,6 +481,11 @@ func (s *BackupExecutionService) finalizeRecord(ctx context.Context, task *model
 }
 
 func (s *BackupExecutionService) resolveProvider(ctx context.Context, targetID uint) (storage.StorageProvider, error) {
+	// 注入 rclone 传输配置（重试、带宽限制）
+	ctx = rclone.ConfiguredContext(ctx, rclone.TransferConfig{
+		LowLevelRetries: s.retries,
+		BandwidthLimit:  s.bandwidthLimit,
+	})
 	target, err := s.targets.FindByID(ctx, targetID)
 	if err != nil {
 		return nil, apperror.Internal("BACKUP_STORAGE_TARGET_GET_FAILED", "无法获取存储目标详情", err)
@@ -376,11 +519,18 @@ func (s *BackupExecutionService) buildTaskSpec(task *model.BackupTask, startedAt
 		}
 		password = string(plain)
 	}
+	sourcePaths := []string{}
+	if strings.TrimSpace(task.SourcePaths) != "" {
+		if err := json.Unmarshal([]byte(task.SourcePaths), &sourcePaths); err != nil {
+			return backup.TaskSpec{}, apperror.Internal("BACKUP_TASK_DECODE_FAILED", "无法解析源路径配置", err)
+		}
+	}
 	return backup.TaskSpec{
 		ID:                task.ID,
 		Name:              task.Name,
 		Type:              task.Type,
 		SourcePath:        task.SourcePath,
+		SourcePaths:       sourcePaths,
 		ExcludePatterns:   excludePatterns,
 		StorageTargetID:   task.StorageTargetID,
 		StorageTargetType: "",
@@ -485,3 +635,28 @@ func buildStorageProviderFromRepos(ctx context.Context, storageTargetID uint, st
 	}
 	return provider, target, nil
 }
+
+// hashingReader 在上传过程中同步计算字节数和 SHA-256，零额外 I/O
+type hashingReader struct {
+	reader io.Reader
+	hash   hash.Hash
+	n      int64
+}
+
+func newHashingReader(reader io.Reader) *hashingReader {
+	h := sha256.New()
+	return &hashingReader{
+		reader: io.TeeReader(reader, h),
+		hash:   h,
+	}
+}
+
+func (r *hashingReader) Read(p []byte) (int, error) {
+	n, err := r.reader.Read(p)
+	r.n += int64(n)
+	return n, err
+}
+
+func (r *hashingReader) Sum() string {
+	return hex.EncodeToString(r.hash.Sum(nil))
+}

server/internal/service/backup_execution_service_test.go

@@ -15,7 +15,7 @@ import (
 	"backupx/server/internal/repository"
 	"backupx/server/internal/storage"
 	"backupx/server/internal/storage/codec"
-	"backupx/server/internal/storage/localdisk"
+	storageRclone "backupx/server/internal/storage/rclone"
 )
 
 func newExecutionTestServices(t *testing.T) (*BackupExecutionService, *BackupRecordService, repository.BackupTaskRepository, repository.StorageTargetRepository, repository.BackupRecordRepository, string, string) {
@@ -53,9 +53,13 @@ func newExecutionTestServices(t *testing.T) (*BackupExecutionService, *BackupRec
 	}
 	logHub := backup.NewLogHub()
 	runnerRegistry := backup.NewRegistry(backup.NewFileRunner(), backup.NewMySQLRunner(nil), backup.NewSQLiteRunner(), backup.NewPostgreSQLRunner(nil))
-	storageRegistry := storage.NewRegistry(localdisk.NewFactory())
+	storageRegistry := storage.NewRegistry(storageRclone.NewLocalDiskFactory())
 	retentionService := backupretention.NewService(records)
-	executionService := NewBackupExecutionService(tasks, records, targets, storageRegistry, runnerRegistry, logHub, retentionService, cipher, nil, "", 2)
+	tempDir := filepath.Join(baseDir, "tmp")
+	if err := os.MkdirAll(tempDir, 0o755); err != nil {
+		t.Fatalf("MkdirAll tempDir returned error: %v", err)
+	}
+	executionService := NewBackupExecutionService(tasks, records, targets, storageRegistry, runnerRegistry, logHub, retentionService, cipher, nil, tempDir, 2, 10, "")
 	recordService := NewBackupRecordService(records, executionService, logHub)
 	return executionService, recordService, tasks, targets, records, sourceDir, storageDir
 }

server/internal/service/backup_record_service.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"encoding/json"
 	"strings"
 	"time"
 
@@ -29,6 +30,7 @@ type BackupRecordSummary struct {
 	Status            string     `json:"status"`
 	FileName          string     `json:"fileName"`
 	FileSize          int64      `json:"fileSize"`
+	Checksum          string     `json:"checksum"`
 	StoragePath       string     `json:"storagePath"`
 	DurationSeconds   int        `json:"durationSeconds"`
 	ErrorMessage      string     `json:"errorMessage"`
@@ -38,8 +40,9 @@ type BackupRecordSummary struct {
 
 type BackupRecordDetail struct {
 	BackupRecordSummary
-	LogContent string            `json:"logContent"`
-	LogEvents  []backup.LogEvent `json:"logEvents,omitempty"`
+	LogContent           string                    `json:"logContent"`
+	LogEvents            []backup.LogEvent         `json:"logEvents,omitempty"`
+	StorageUploadResults []StorageUploadResultItem  `json:"storageUploadResults,omitempty"`
 }
 
 type BackupRecordService struct {
@@ -109,6 +112,7 @@ func toBackupRecordSummary(item *model.BackupRecord) BackupRecordSummary {
 		Status:            item.Status,
 		FileName:          item.FileName,
 		FileSize:          item.FileSize,
+		Checksum:          item.Checksum,
 		StoragePath:       item.StoragePath,
 		DurationSeconds:   item.DurationSeconds,
 		ErrorMessage:      item.ErrorMessage,
@@ -130,5 +134,12 @@ func toBackupRecordDetail(item *model.BackupRecord, logHub *backup.LogHub) *Back
 			detail.LogContent = strings.Join(lines, "\n")
 		}
 	}
+	// 解析多目标上传结果
+	if strings.TrimSpace(item.StorageUploadResults) != "" {
+		var uploadResults []StorageUploadResultItem
+		if err := json.Unmarshal([]byte(item.StorageUploadResults), &uploadResults); err == nil {
+			detail.StorageUploadResults = uploadResults
+		}
+	}
 	return detail
 }

server/internal/service/backup_task_service.go

@@ -17,23 +17,25 @@ import (
 const backupTaskMaskedValue = "********"
 
 type BackupTaskUpsertInput struct {
-	Name            string   `json:"name" binding:"required,min=1,max=100"`
-	Type            string   `json:"type" binding:"required,oneof=file mysql sqlite postgresql pgsql"`
-	Enabled         bool     `json:"enabled"`
-	CronExpr        string   `json:"cronExpr" binding:"max=64"`
-	SourcePath      string   `json:"sourcePath" binding:"max=500"`
-	ExcludePatterns []string `json:"excludePatterns"`
-	DBHost          string   `json:"dbHost" binding:"max=255"`
-	DBPort          int      `json:"dbPort"`
-	DBUser          string   `json:"dbUser" binding:"max=100"`
-	DBPassword      string   `json:"dbPassword" binding:"max=255"`
-	DBName          string   `json:"dbName" binding:"max=255"`
-	DBPath          string   `json:"dbPath" binding:"max=500"`
-	StorageTargetID uint     `json:"storageTargetId" binding:"required"`
-	RetentionDays   int      `json:"retentionDays"`
-	Compression     string   `json:"compression" binding:"omitempty,oneof=gzip none"`
-	Encrypt         bool     `json:"encrypt"`
-	MaxBackups      int      `json:"maxBackups"`
+	Name             string   `json:"name" binding:"required,min=1,max=100"`
+	Type             string   `json:"type" binding:"required,oneof=file mysql sqlite postgresql pgsql"`
+	Enabled          bool     `json:"enabled"`
+	CronExpr         string   `json:"cronExpr" binding:"max=64"`
+	SourcePath       string   `json:"sourcePath" binding:"max=500"`
+	SourcePaths      []string `json:"sourcePaths"`
+	ExcludePatterns  []string `json:"excludePatterns"`
+	DBHost           string   `json:"dbHost" binding:"max=255"`
+	DBPort           int      `json:"dbPort"`
+	DBUser           string   `json:"dbUser" binding:"max=100"`
+	DBPassword       string   `json:"dbPassword" binding:"max=255"`
+	DBName           string   `json:"dbName" binding:"max=255"`
+	DBPath           string   `json:"dbPath" binding:"max=500"`
+	StorageTargetID  uint     `json:"storageTargetId"`                       // deprecated: 向后兼容
+	StorageTargetIDs []uint   `json:"storageTargetIds"`                      // 新增：多存储目标
+	RetentionDays    int      `json:"retentionDays"`
+	Compression      string   `json:"compression" binding:"omitempty,oneof=gzip none"`
+	Encrypt          bool     `json:"encrypt"`
+	MaxBackups       int      `json:"maxBackups"`
 }
 
 type BackupTaskToggleInput struct {
@@ -41,25 +43,28 @@ type BackupTaskToggleInput struct {
 }
 
 type BackupTaskSummary struct {
-	ID                uint       `json:"id"`
-	Name              string     `json:"name"`
-	Type              string     `json:"type"`
-	Enabled           bool       `json:"enabled"`
-	CronExpr          string     `json:"cronExpr"`
-	StorageTargetID   uint       `json:"storageTargetId"`
-	StorageTargetName string     `json:"storageTargetName"`
-	RetentionDays     int        `json:"retentionDays"`
-	Compression       string     `json:"compression"`
-	Encrypt           bool       `json:"encrypt"`
-	MaxBackups        int        `json:"maxBackups"`
-	LastRunAt         *time.Time `json:"lastRunAt,omitempty"`
-	LastStatus        string     `json:"lastStatus"`
-	UpdatedAt         time.Time  `json:"updatedAt"`
+	ID                 uint       `json:"id"`
+	Name               string     `json:"name"`
+	Type               string     `json:"type"`
+	Enabled            bool       `json:"enabled"`
+	CronExpr           string     `json:"cronExpr"`
+	StorageTargetID    uint       `json:"storageTargetId"`              // deprecated: 取第一个
+	StorageTargetName  string     `json:"storageTargetName"`            // deprecated: 取第一个
+	StorageTargetIDs   []uint     `json:"storageTargetIds"`
+	StorageTargetNames []string   `json:"storageTargetNames"`
+	RetentionDays      int        `json:"retentionDays"`
+	Compression        string     `json:"compression"`
+	Encrypt            bool       `json:"encrypt"`
+	MaxBackups         int        `json:"maxBackups"`
+	LastRunAt          *time.Time `json:"lastRunAt,omitempty"`
+	LastStatus         string     `json:"lastStatus"`
+	UpdatedAt          time.Time  `json:"updatedAt"`
 }
 
 type BackupTaskDetail struct {
 	BackupTaskSummary
 	SourcePath      string    `json:"sourcePath"`
+	SourcePaths     []string  `json:"sourcePaths"`
 	ExcludePatterns []string  `json:"excludePatterns"`
 	DBHost          string    `json:"dbHost"`
 	DBPort          int       `json:"dbPort"`
@@ -227,19 +232,33 @@ func (s *BackupTaskService) Toggle(ctx context.Context, id uint, enabled bool) (
 	return &returnValue, nil
 }
 
+// resolveStorageTargetIDs 统一处理新旧字段，返回有效的存储目标 ID 列表
+func resolveStorageTargetIDs(input BackupTaskUpsertInput) []uint {
+	if len(input.StorageTargetIDs) > 0 {
+		return input.StorageTargetIDs
+	}
+	if input.StorageTargetID > 0 {
+		return []uint{input.StorageTargetID}
+	}
+	return nil
+}
+
 func (s *BackupTaskService) validateInput(ctx context.Context, existing *model.BackupTask, input BackupTaskUpsertInput) error {
 	if strings.TrimSpace(input.Name) == "" {
 		return apperror.BadRequest("BACKUP_TASK_INVALID", "任务名称不能为空", nil)
 	}
-	if input.StorageTargetID == 0 {
-		return apperror.BadRequest("BACKUP_TASK_INVALID", "请选择存储目标", nil)
+	targetIDs := resolveStorageTargetIDs(input)
+	if len(targetIDs) == 0 {
+		return apperror.BadRequest("BACKUP_TASK_INVALID", "请选择至少一个存储目标", nil)
 	}
-	target, err := s.targets.FindByID(ctx, input.StorageTargetID)
-	if err != nil {
-		return apperror.Internal("BACKUP_TASK_STORAGE_LOOKUP_FAILED", "无法检查存储目标", err)
-	}
-	if target == nil {
-		return apperror.BadRequest("BACKUP_STORAGE_TARGET_INVALID", "关联的存储目标不存在", nil)
+	for _, tid := range targetIDs {
+		target, err := s.targets.FindByID(ctx, tid)
+		if err != nil {
+			return apperror.Internal("BACKUP_TASK_STORAGE_LOOKUP_FAILED", "无法检查存储目标", err)
+		}
+		if target == nil {
+			return apperror.BadRequest("BACKUP_STORAGE_TARGET_INVALID", fmt.Sprintf("关联的存储目标 %d 不存在", tid), nil)
+		}
 	}
 	if input.RetentionDays < 0 {
 		return apperror.BadRequest("BACKUP_TASK_INVALID", "保留天数不能小于 0", nil)
@@ -260,7 +279,8 @@ func (s *BackupTaskService) validateInput(ctx context.Context, existing *model.B
 func validateTaskTypeSpecificFields(input BackupTaskUpsertInput, passwordRequired bool) error {
 	switch normalizeBackupTaskType(input.Type) {
 	case "file":
-		if strings.TrimSpace(input.SourcePath) == "" {
+		hasSourcePaths := len(resolveSourcePaths(input)) > 0
+		if !hasSourcePaths {
 			return apperror.BadRequest("BACKUP_TASK_INVALID", "文件备份必须填写源路径", nil)
 		}
 	case "mysql", "postgresql":
@@ -294,6 +314,10 @@ func (s *BackupTaskService) buildTask(existing *model.BackupTask, input BackupTa
 	if err != nil {
 		return nil, apperror.BadRequest("BACKUP_TASK_INVALID", "排除规则格式不合法", err)
 	}
+	sourcePathsJSON, err := encodeSourcePaths(resolveSourcePaths(input))
+	if err != nil {
+		return nil, apperror.BadRequest("BACKUP_TASK_INVALID", "源路径格式不合法", err)
+	}
 	passwordCiphertext := ""
 	if existing != nil {
 		passwordCiphertext = existing.DBPasswordCiphertext
@@ -313,12 +337,30 @@ func (s *BackupTaskService) buildTask(existing *model.BackupTask, input BackupTa
 	if maxBackups == 0 {
 		maxBackups = 10
 	}
+	targetIDs := resolveStorageTargetIDs(input)
+	// 保持旧字段兼容：取第一个
+	primaryTargetID := uint(0)
+	if len(targetIDs) > 0 {
+		primaryTargetID = targetIDs[0]
+	}
+	// 构建多对多关联
+	storageTargets := make([]model.StorageTarget, len(targetIDs))
+	for i, tid := range targetIDs {
+		storageTargets[i] = model.StorageTarget{ID: tid}
+	}
+	// 向后兼容：SourcePath 取第一个
+	resolvedPaths := resolveSourcePaths(input)
+	primarySourcePath := strings.TrimSpace(input.SourcePath)
+	if len(resolvedPaths) > 0 {
+		primarySourcePath = resolvedPaths[0]
+	}
 	item := &model.BackupTask{
 		Name:                 strings.TrimSpace(input.Name),
 		Type:                 normalizeBackupTaskType(input.Type),
 		Enabled:              input.Enabled,
 		CronExpr:             strings.TrimSpace(input.CronExpr),
-		SourcePath:           strings.TrimSpace(input.SourcePath),
+		SourcePath:           primarySourcePath,
+		SourcePaths:          sourcePathsJSON,
 		ExcludePatterns:      excludePatterns,
 		DBHost:               strings.TrimSpace(input.DBHost),
 		DBPort:               input.DBPort,
@@ -326,7 +368,8 @@ func (s *BackupTaskService) buildTask(existing *model.BackupTask, input BackupTa
 		DBPasswordCiphertext: passwordCiphertext,
 		DBName:               strings.TrimSpace(input.DBName),
 		DBPath:               strings.TrimSpace(input.DBPath),
-		StorageTargetID:      input.StorageTargetID,
+		StorageTargetID:      primaryTargetID,
+		StorageTargets:       storageTargets,
 		RetentionDays:        input.RetentionDays,
 		Compression:          compression,
 		Encrypt:              input.Encrypt,
@@ -346,9 +389,14 @@ func (s *BackupTaskService) toDetail(item *model.BackupTask) (*BackupTaskDetail,
 	if err != nil {
 		return nil, apperror.Internal("BACKUP_TASK_DECODE_FAILED", "无法解析备份任务配置", err)
 	}
+	sourcePaths, err := decodeSourcePaths(item.SourcePaths)
+	if err != nil {
+		return nil, apperror.Internal("BACKUP_TASK_DECODE_FAILED", "无法解析源路径配置", err)
+	}
 	detail := &BackupTaskDetail{
 		BackupTaskSummary: toBackupTaskSummary(item),
 		SourcePath:        item.SourcePath,
+		SourcePaths:       sourcePaths,
 		ExcludePatterns:   excludePatterns,
 		DBHost:            item.DBHost,
 		DBPort:            item.DBPort,
@@ -364,25 +412,45 @@ func (s *BackupTaskService) toDetail(item *model.BackupTask) (*BackupTaskDetail,
 }
 
 func toBackupTaskSummary(item *model.BackupTask) BackupTaskSummary {
-	storageTargetName := ""
-	if item != nil {
-		storageTargetName = item.StorageTarget.Name
+	// 从多对多关联提取 IDs 和 Names
+	var targetIDs []uint
+	var targetNames []string
+	if len(item.StorageTargets) > 0 {
+		for _, t := range item.StorageTargets {
+			targetIDs = append(targetIDs, t.ID)
+			targetNames = append(targetNames, t.Name)
+		}
+	} else if item.StorageTargetID > 0 {
+		// 回退到旧字段
+		targetIDs = []uint{item.StorageTargetID}
+		targetNames = []string{item.StorageTarget.Name}
+	}
+	// 向后兼容：取第一个
+	primaryID := uint(0)
+	primaryName := ""
+	if len(targetIDs) > 0 {
+		primaryID = targetIDs[0]
+	}
+	if len(targetNames) > 0 {
+		primaryName = targetNames[0]
 	}
 	return BackupTaskSummary{
-		ID:                item.ID,
-		Name:              item.Name,
-		Type:              normalizeBackupTaskType(item.Type),
-		Enabled:           item.Enabled,
-		CronExpr:          item.CronExpr,
-		StorageTargetID:   item.StorageTargetID,
-		StorageTargetName: storageTargetName,
-		RetentionDays:     item.RetentionDays,
-		Compression:       item.Compression,
-		Encrypt:           item.Encrypt,
-		MaxBackups:        item.MaxBackups,
-		LastRunAt:         item.LastRunAt,
-		LastStatus:        item.LastStatus,
-		UpdatedAt:         item.UpdatedAt,
+		ID:                 item.ID,
+		Name:               item.Name,
+		Type:               normalizeBackupTaskType(item.Type),
+		Enabled:            item.Enabled,
+		CronExpr:           item.CronExpr,
+		StorageTargetID:    primaryID,
+		StorageTargetName:  primaryName,
+		StorageTargetIDs:   targetIDs,
+		StorageTargetNames: targetNames,
+		RetentionDays:      item.RetentionDays,
+		Compression:        item.Compression,
+		Encrypt:            item.Encrypt,
+		MaxBackups:         item.MaxBackups,
+		LastRunAt:          item.LastRunAt,
+		LastStatus:         item.LastStatus,
+		UpdatedAt:          item.UpdatedAt,
 	}
 }
 
@@ -408,6 +476,47 @@ func decodeExcludePatterns(value string) ([]string, error) {
 	return items, nil
 }
 
+// resolveSourcePaths 统一处理 sourcePaths / sourcePath，返回有效路径列表
+func resolveSourcePaths(input BackupTaskUpsertInput) []string {
+	if len(input.SourcePaths) > 0 {
+		var cleaned []string
+		for _, p := range input.SourcePaths {
+			if trimmed := strings.TrimSpace(p); trimmed != "" {
+				cleaned = append(cleaned, trimmed)
+			}
+		}
+		if len(cleaned) > 0 {
+			return cleaned
+		}
+	}
+	if sp := strings.TrimSpace(input.SourcePath); sp != "" {
+		return []string{sp}
+	}
+	return nil
+}
+
+func encodeSourcePaths(paths []string) (string, error) {
+	if len(paths) == 0 {
+		return "[]", nil
+	}
+	encoded, err := json.Marshal(paths)
+	if err != nil {
+		return "", err
+	}
+	return string(encoded), nil
+}
+
+func decodeSourcePaths(value string) ([]string, error) {
+	if strings.TrimSpace(value) == "" || strings.TrimSpace(value) == "[]" {
+		return []string{}, nil
+	}
+	var items []string
+	if err := json.Unmarshal([]byte(value), &items); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 func normalizeBackupTaskType(value string) string {
 	normalized := strings.TrimSpace(strings.ToLower(value))
 	if normalized == "pgsql" {

server/internal/service/database_discovery_service.go

@@ -0,0 +1,141 @@
+package service
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"backupx/server/internal/apperror"
+	"backupx/server/internal/backup"
+)
+
+type DatabaseDiscoverInput struct {
+	Type     string `json:"type" binding:"required,oneof=mysql postgresql"`
+	Host     string `json:"host" binding:"required"`
+	Port     int    `json:"port" binding:"required,min=1"`
+	User     string `json:"user" binding:"required"`
+	Password string `json:"password" binding:"required"`
+}
+
+type DatabaseDiscoverResult struct {
+	Databases []string `json:"databases"`
+}
+
+type DatabaseDiscoveryService struct {
+	executor backup.CommandExecutor
+}
+
+func NewDatabaseDiscoveryService(executor backup.CommandExecutor) *DatabaseDiscoveryService {
+	return &DatabaseDiscoveryService{executor: executor}
+}
+
+func (s *DatabaseDiscoveryService) Discover(ctx context.Context, input DatabaseDiscoverInput) (*DatabaseDiscoverResult, error) {
+	switch strings.TrimSpace(strings.ToLower(input.Type)) {
+	case "mysql":
+		return s.discoverMySQL(ctx, input)
+	case "postgresql":
+		return s.discoverPostgreSQL(ctx, input)
+	default:
+		return nil, apperror.BadRequest("DATABASE_DISCOVER_INVALID_TYPE", "不支持的数据库类型", nil)
+	}
+}
+
+func (s *DatabaseDiscoveryService) discoverMySQL(ctx context.Context, input DatabaseDiscoverInput) (*DatabaseDiscoverResult, error) {
+	mysqlPath, err := s.executor.LookPath("mysql")
+	if err != nil {
+		return nil, apperror.BadRequest("DATABASE_DISCOVER_MYSQL_NOT_FOUND", "系统未安装 mysql 客户端", err)
+	}
+
+	timeout, cancel := context.WithTimeout(ctx, 5*time.Second)
+	defer cancel()
+
+	var stdout, stderr bytes.Buffer
+	args := []string{
+		fmt.Sprintf("--host=%s", input.Host),
+		fmt.Sprintf("--port=%d", input.Port),
+		fmt.Sprintf("--user=%s", input.User),
+		"-e", "SHOW DATABASES",
+		"--skip-column-names",
+	}
+	env := []string{fmt.Sprintf("MYSQL_PWD=%s", input.Password)}
+
+	if err := s.executor.Run(timeout, mysqlPath, args, backup.CommandOptions{
+		Stdout: &stdout,
+		Stderr: &stderr,
+		Env:    env,
+	}); err != nil {
+		errMsg := strings.TrimSpace(stderr.String())
+		if errMsg == "" {
+			errMsg = err.Error()
+		}
+		return nil, apperror.BadRequest("DATABASE_DISCOVER_MYSQL_FAILED", fmt.Sprintf("连接 MySQL 失败：%s", sanitizeMessage(errMsg)), err)
+	}
+
+	systemDBs := map[string]bool{
+		"information_schema": true,
+		"performance_schema": true,
+		"mysql":              true,
+		"sys":                true,
+	}
+
+	var databases []string
+	for _, line := range strings.Split(stdout.String(), "\n") {
+		db := strings.TrimSpace(line)
+		if db == "" || systemDBs[db] {
+			continue
+		}
+		databases = append(databases, db)
+	}
+
+	return &DatabaseDiscoverResult{Databases: databases}, nil
+}
+
+func (s *DatabaseDiscoveryService) discoverPostgreSQL(ctx context.Context, input DatabaseDiscoverInput) (*DatabaseDiscoverResult, error) {
+	psqlPath, err := s.executor.LookPath("psql")
+	if err != nil {
+		return nil, apperror.BadRequest("DATABASE_DISCOVER_PSQL_NOT_FOUND", "系统未安装 psql 客户端", err)
+	}
+
+	timeout, cancel := context.WithTimeout(ctx, 5*time.Second)
+	defer cancel()
+
+	var stdout, stderr bytes.Buffer
+	args := []string{
+		"-h", input.Host,
+		"-p", fmt.Sprintf("%d", input.Port),
+		"-U", input.User,
+		"-d", "postgres",
+		"-t", "-A",
+		"-c", "SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY datname",
+	}
+	env := []string{fmt.Sprintf("PGPASSWORD=%s", input.Password)}
+
+	if err := s.executor.Run(timeout, psqlPath, args, backup.CommandOptions{
+		Stdout: &stdout,
+		Stderr: &stderr,
+		Env:    env,
+	}); err != nil {
+		errMsg := strings.TrimSpace(stderr.String())
+		if errMsg == "" {
+			errMsg = err.Error()
+		}
+		return nil, apperror.BadRequest("DATABASE_DISCOVER_PSQL_FAILED", fmt.Sprintf("连接 PostgreSQL 失败：%s", sanitizeMessage(errMsg)), err)
+	}
+
+	skipDBs := map[string]bool{
+		"postgres": true,
+	}
+
+	var databases []string
+	for _, line := range strings.Split(stdout.String(), "\n") {
+		db := strings.TrimSpace(line)
+		if db == "" || skipDBs[db] || strings.HasPrefix(db, "template") {
+			continue
+		}
+		databases = append(databases, db)
+	}
+
+	return &DatabaseDiscoverResult{Databases: databases}, nil
+}

server/internal/service/progress_reader.go

@@ -0,0 +1,52 @@
+package service
+
+import (
+	"io"
+	"sync/atomic"
+	"time"
+)
+
+// progressCallback 在每次读取时被调用，报告已读字节数和估算速率。
+type progressCallback func(bytesRead int64, speedBps float64)
+
+// progressReader 包装 io.Reader，定期通过回调报告传输进度。
+type progressReader struct {
+	reader    io.Reader
+	total     int64
+	read      atomic.Int64
+	callback  progressCallback
+	startTime time.Time
+	lastCall  time.Time
+	interval  time.Duration
+}
+
+func newProgressReader(reader io.Reader, total int64, callback progressCallback) *progressReader {
+	now := time.Now()
+	return &progressReader{
+		reader:    reader,
+		total:     total,
+		callback:  callback,
+		startTime: now,
+		lastCall:  now,
+		interval:  500 * time.Millisecond,
+	}
+}
+
+func (r *progressReader) Read(p []byte) (int, error) {
+	n, err := r.reader.Read(p)
+	if n > 0 {
+		current := r.read.Add(int64(n))
+		now := time.Now()
+		isFinal := err == io.EOF || (r.total > 0 && current >= r.total)
+		if isFinal || now.Sub(r.lastCall) >= r.interval {
+			r.lastCall = now
+			elapsed := now.Sub(r.startTime).Seconds()
+			speed := float64(0)
+			if elapsed > 0 {
+				speed = float64(current) / elapsed
+			}
+			r.callback(current, speed)
+		}
+	}
+	return n, err
+}

server/internal/service/settings_service.go

@@ -22,6 +22,7 @@ var settingsKeys = []string{
 	"language",
 	"timezone",
 	"backup_notification_enabled",
+	"bandwidth_limit",
 }
 
 func (s *SettingsService) GetAll(ctx context.Context) (map[string]string, error) {

server/internal/service/storage_target_service.go

@@ -21,7 +21,7 @@ import (
 
 type StorageTargetUpsertInput struct {
 	Name        string         `json:"name" binding:"required,min=1,max=128"`
-	Type        string         `json:"type" binding:"required,oneof=local_disk google_drive s3 webdav"`
+	Type        string         `json:"type" binding:"required,min=1"`
 	Description string         `json:"description" binding:"max=255"`
 	Enabled     bool           `json:"enabled"`
 	Config      map[string]any `json:"config" binding:"required"`
@@ -53,6 +53,7 @@ type StorageTargetSummary struct {
 	Type            string     `json:"type"`
 	Description     string     `json:"description"`
 	Enabled         bool       `json:"enabled"`
+	Starred         bool       `json:"starred"`
 	ConfigVersion   int        `json:"configVersion"`
 	LastTestedAt    *time.Time `json:"lastTestedAt"`
 	LastTestStatus  string     `json:"lastTestStatus"`
@@ -209,6 +210,22 @@ func (s *StorageTargetService) Delete(ctx context.Context, id uint) error {
 	return nil
 }
 
+func (s *StorageTargetService) ToggleStar(ctx context.Context, id uint) (*StorageTargetSummary, error) {
+	item, err := s.targets.FindByID(ctx, id)
+	if err != nil {
+		return nil, apperror.Internal("STORAGE_TARGET_GET_FAILED", "无法获取存储目标详情", err)
+	}
+	if item == nil {
+		return nil, apperror.New(http.StatusNotFound, "STORAGE_TARGET_NOT_FOUND", "存储目标不存在", fmt.Errorf("storage target %d not found", id))
+	}
+	item.Starred = !item.Starred
+	if err := s.targets.Update(ctx, item); err != nil {
+		return nil, apperror.Internal("STORAGE_TARGET_UPDATE_FAILED", "无法更新存储目标收藏状态", err)
+	}
+	summary := toStorageTargetSummary(item)
+	return &summary, nil
+}
+
 func (s *StorageTargetService) TestConnection(ctx context.Context, input StorageTargetTestInput) error {
 	item, err := s.buildStorageTargetForTest(ctx, input)
 	if err != nil {
@@ -493,6 +510,7 @@ func toStorageTargetSummary(item *model.StorageTarget) StorageTargetSummary {
 		Type:            item.Type,
 		Description:     item.Description,
 		Enabled:         item.Enabled,
+		Starred:         item.Starred,
 		ConfigVersion:   item.ConfigVersion,
 		LastTestedAt:    item.LastTestedAt,
 		LastTestStatus:  item.LastTestStatus,
@@ -526,10 +544,11 @@ func cloneMap(source map[string]any) map[string]any {
 }
 
 type StorageTargetUsage struct {
-	TargetID    uint   `json:"targetId"`
-	TargetName  string `json:"targetName"`
-	RecordCount int64  `json:"recordCount"`
-	TotalSize   int64  `json:"totalSize"`
+	TargetID    uint                      `json:"targetId"`
+	TargetName  string                    `json:"targetName"`
+	RecordCount int64                     `json:"recordCount"`
+	TotalSize   int64                     `json:"totalSize"`
+	DiskUsage   *storage.StorageUsageInfo `json:"diskUsage,omitempty"`
 }
 
 func (s *StorageTargetService) GetUsage(ctx context.Context, id uint) (*StorageTargetUsage, error) {
@@ -552,5 +571,16 @@ func (s *StorageTargetService) GetUsage(ctx context.Context, id uint) (*StorageT
 			}
 		}
 	}
+	// 尝试查询远端真实存储空间（部分后端如 local/Google Drive/WebDAV 支持）
+	configMap := map[string]any{}
+	if decryptErr := s.cipher.DecryptJSON(target.ConfigCiphertext, &configMap); decryptErr == nil {
+		if provider, createErr := s.registry.Create(ctx, target.Type, configMap); createErr == nil {
+			if abouter, ok := provider.(storage.StorageAbout); ok {
+				if diskUsage, aboutErr := abouter.About(ctx); aboutErr == nil {
+					result.DiskUsage = diskUsage
+				}
+			}
+		}
+	}
 	return result, nil
 }

server/internal/service/system_service.go

@@ -2,7 +2,14 @@ package service
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
 	"path/filepath"
+	"runtime"
+	"strings"
 	"syscall"
 	"time"
 
@@ -30,6 +37,82 @@ func NewSystemService(cfg config.Config, version string, startedAt time.Time) *S
 	return &SystemService{cfg: cfg, version: version, startedAt: startedAt}
 }
 
+// UpdateCheckResult 描述版本更新检查结果。
+type UpdateCheckResult struct {
+	CurrentVersion string `json:"currentVersion"`
+	LatestVersion  string `json:"latestVersion"`
+	HasUpdate      bool   `json:"hasUpdate"`
+	ReleaseURL     string `json:"releaseUrl,omitempty"`
+	ReleaseNotes   string `json:"releaseNotes,omitempty"`
+	PublishedAt    string `json:"publishedAt,omitempty"`
+	DownloadURL    string `json:"downloadUrl,omitempty"`
+	DockerImage    string `json:"dockerImage,omitempty"`
+}
+
+const githubRepoAPI = "https://api.github.com/repos/Awuqing/BackupX/releases/latest"
+
+// CheckUpdate 从 GitHub Releases 检查是否有新版本。
+func (s *SystemService) CheckUpdate(ctx context.Context) (*UpdateCheckResult, error) {
+	result := &UpdateCheckResult{
+		CurrentVersion: s.version,
+		DockerImage:    "awuqing/backupx",
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, githubRepoAPI, nil)
+	if err != nil {
+		return result, fmt.Errorf("create request: %w", err)
+	}
+	req.Header.Set("Accept", "application/vnd.github.v3+json")
+	req.Header.Set("User-Agent", "BackupX/"+s.version)
+
+	client := &http.Client{Timeout: 15 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return result, fmt.Errorf("fetch latest release: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return result, fmt.Errorf("github api returned %d", resp.StatusCode)
+	}
+
+	var release struct {
+		TagName    string `json:"tag_name"`
+		HTMLURL    string `json:"html_url"`
+		Body       string `json:"body"`
+		Published  string `json:"published_at"`
+		Assets     []struct {
+			Name               string `json:"name"`
+			BrowserDownloadURL string `json:"browser_download_url"`
+		} `json:"assets"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+		return result, fmt.Errorf("decode release: %w", err)
+	}
+
+	result.LatestVersion = release.TagName
+	result.ReleaseURL = release.HTMLURL
+	result.ReleaseNotes = release.Body
+	result.PublishedAt = release.Published
+
+	// 比较版本号（去 v 前缀后字符串比较）
+	current := strings.TrimPrefix(s.version, "v")
+	latest := strings.TrimPrefix(release.TagName, "v")
+	result.HasUpdate = latest > current && current != "dev"
+
+	// 匹配当前平台的下载链接
+	goos := runtime.GOOS
+	goarch := runtime.GOARCH
+	suffix := fmt.Sprintf("%s-%s.tar.gz", goos, goarch)
+	for _, asset := range release.Assets {
+		if strings.HasSuffix(asset.Name, suffix) {
+			result.DownloadURL = asset.BrowserDownloadURL
+			break
+		}
+	}
+
+	return result, nil
+}
+
 func (s *SystemService) GetInfo(_ context.Context) *SystemInfo {
 	now := time.Now().UTC()
 	info := &SystemInfo{
@@ -51,3 +134,63 @@ func (s *SystemService) GetInfo(_ context.Context) *SystemInfo {
 	}
 	return info
 }
+
+// UpdateApplyResult 描述自动更新执行结果。
+type UpdateApplyResult struct {
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+	Output  string `json:"output,omitempty"`
+}
+
+// IsDockerEnvironment 检测当前是否运行在 Docker 容器中。
+func (s *SystemService) IsDockerEnvironment() bool {
+	if _, err := os.Stat("/.dockerenv"); err == nil {
+		return true
+	}
+	return false
+}
+
+// ApplyDockerUpdate 执行 Docker 自动更新：pull 新镜像 + recreate 容器。
+// 容器会在 docker compose up -d 后自动重启为新版本。
+func (s *SystemService) ApplyDockerUpdate(_ context.Context, targetVersion string) *UpdateApplyResult {
+	if !s.IsDockerEnvironment() {
+		return &UpdateApplyResult{Success: false, Message: "当前非 Docker 环境，请手动下载二进制更新"}
+	}
+
+	image := "awuqing/backupx"
+	tag := strings.TrimSpace(targetVersion)
+	if tag == "" {
+		tag = "latest"
+	}
+	pullTarget := image + ":" + tag
+
+	// Step 1: docker pull
+	pullCmd := exec.Command("docker", "pull", pullTarget)
+	pullOut, pullErr := pullCmd.CombinedOutput()
+	if pullErr != nil {
+		return &UpdateApplyResult{Success: false, Message: fmt.Sprintf("docker pull 失败: %v", pullErr), Output: string(pullOut)}
+	}
+
+	// Step 2: docker compose up -d（后台执行，容器会自重启）
+	// 检测 compose 命令
+	composeBin := "docker"
+	composeArgs := []string{"compose", "up", "-d"}
+	if _, err := exec.LookPath("docker-compose"); err == nil {
+		composeBin = "docker-compose"
+		composeArgs = []string{"up", "-d"}
+	}
+
+	// 异步执行，给 API 响应留时间
+	go func() {
+		time.Sleep(1 * time.Second)
+		cmd := exec.Command(composeBin, composeArgs...)
+		cmd.Dir = "/app" // Docker 容器中的工作目录
+		_ = cmd.Run()
+	}()
+
+	return &UpdateApplyResult{
+		Success: true,
+		Message: fmt.Sprintf("已拉取 %s，容器即将自动重启到新版本", pullTarget),
+		Output:  string(pullOut),
+	}
+}

server/internal/storage/aliyun/factory.go

@@ -1,66 +0,0 @@
-// Package aliyun provides an Aliyun OSS storage factory that delegates to the S3-compatible engine.
-// Aliyun OSS is fully S3-compatible; we auto-assemble the endpoint from the user-provided region.
-package aliyun
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"backupx/server/internal/storage"
-	"backupx/server/internal/storage/s3"
-)
-
-// Config is the user-facing configuration for Aliyun OSS.
-type Config struct {
-	Region          string `json:"region"`
-	Bucket          string `json:"bucket"`
-	AccessKeyID     string `json:"accessKeyId"`
-	SecretAccessKey  string `json:"secretAccessKey"`
-	Endpoint        string `json:"endpoint"`        // optional override
-	InternalNetwork bool   `json:"internalNetwork"` // use -internal endpoint
-}
-
-// Factory creates Aliyun OSS providers by composing the S3 engine.
-type Factory struct {
-	s3Factory s3.Factory
-}
-
-func NewFactory() Factory {
-	return Factory{s3Factory: s3.NewFactory()}
-}
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeAliyunOSS }
-func (Factory) SensitiveFields() []string  { return []string{"accessKeyId", "secretAccessKey"} }
-
-func (f Factory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[Config](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := strings.TrimSpace(cfg.Endpoint)
-	if endpoint == "" {
-		region := strings.TrimSpace(cfg.Region)
-		if region == "" {
-			return nil, fmt.Errorf("aliyun oss region is required")
-		}
-		suffix := "aliyuncs.com"
-		if cfg.InternalNetwork {
-			endpoint = fmt.Sprintf("https://oss-%s-internal.%s", region, suffix)
-		} else {
-			endpoint = fmt.Sprintf("https://oss-%s.%s", region, suffix)
-		}
-	}
-
-	// Delegate to S3 engine with assembled endpoint.
-	s3Config := map[string]any{
-		"endpoint":        endpoint,
-		"region":          cfg.Region,
-		"bucket":          cfg.Bucket,
-		"accessKeyId":     cfg.AccessKeyID,
-		"secretAccessKey": cfg.SecretAccessKey,
-		"forcePathStyle":  false, // Aliyun OSS uses virtual-hosted style
-	}
-	return f.s3Factory.New(ctx, s3Config)
-}

server/internal/storage/ftp/provider.go

@@ -1,226 +0,0 @@
-package ftp
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"io"
-	"path"
-	"strings"
-	"time"
-
-	"backupx/server/internal/storage"
-
-	"github.com/jlaffaye/ftp"
-)
-
-// Provider implements storage.StorageProvider for FTP.
-type Provider struct {
-	config storage.FTPConfig
-}
-
-// Factory creates FTP storage providers.
-type Factory struct{}
-
-// NewFactory returns a new FTP Factory.
-func NewFactory() Factory {
-	return Factory{}
-}
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeFTP }
-func (Factory) SensitiveFields() []string  { return []string{"username", "password"} }
-
-func (f Factory) New(_ context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[storage.FTPConfig](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(cfg.Host) == "" {
-		return nil, fmt.Errorf("FTP host is required")
-	}
-	if cfg.Port == 0 {
-		cfg.Port = 21
-	}
-	return &Provider{config: cfg}, nil
-}
-
-func (p *Provider) Type() storage.ProviderType { return storage.ProviderTypeFTP }
-
-// dial establishes a connection to the FTP server and logs in.
-func (p *Provider) dial() (*ftp.ServerConn, error) {
-	addr := fmt.Sprintf("%s:%d", p.config.Host, p.config.Port)
-
-	var opts []ftp.DialOption
-	opts = append(opts, ftp.DialWithTimeout(30*time.Second))
-	if p.config.UseTLS {
-		opts = append(opts, ftp.DialWithExplicitTLS(nil))
-	}
-
-	conn, err := ftp.Dial(addr, opts...)
-	if err != nil {
-		return nil, fmt.Errorf("connect to FTP server %s: %w", addr, err)
-	}
-
-	username := p.config.Username
-	if username == "" {
-		username = "anonymous"
-	}
-	if err := conn.Login(username, p.config.Password); err != nil {
-		conn.Quit()
-		return nil, fmt.Errorf("FTP login: %w", err)
-	}
-
-	return conn, nil
-}
-
-func (p *Provider) TestConnection(_ context.Context) error {
-	conn, err := p.dial()
-	if err != nil {
-		return err
-	}
-	defer conn.Quit()
-
-	basePath := p.normalizeBasePath()
-	if err := p.ensureDir(conn, basePath); err != nil {
-		return fmt.Errorf("ensure FTP base path: %w", err)
-	}
-	_, err = conn.List(basePath)
-	if err != nil {
-		return fmt.Errorf("list FTP base path: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) Upload(_ context.Context, objectKey string, reader io.Reader, _ int64, _ map[string]string) error {
-	conn, err := p.dial()
-	if err != nil {
-		return err
-	}
-	defer conn.Quit()
-
-	objectPath := p.resolvePath(objectKey)
-	dir := path.Dir(objectPath)
-	if err := p.ensureDir(conn, dir); err != nil {
-		return fmt.Errorf("create FTP directories: %w", err)
-	}
-
-	// Read all data into buffer since FTP STOR needs the full stream
-	data, err := io.ReadAll(reader)
-	if err != nil {
-		return fmt.Errorf("read upload data: %w", err)
-	}
-
-	if err := conn.Stor(objectPath, bytes.NewReader(data)); err != nil {
-		return fmt.Errorf("FTP upload: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) Download(_ context.Context, objectKey string) (io.ReadCloser, error) {
-	conn, err := p.dial()
-	if err != nil {
-		return nil, err
-	}
-
-	objectPath := p.resolvePath(objectKey)
-	resp, err := conn.Retr(objectPath)
-	if err != nil {
-		conn.Quit()
-		return nil, fmt.Errorf("FTP download: %w", err)
-	}
-
-	// Wrap the response to also close the FTP connection when done
-	return &ftpReadCloser{ReadCloser: resp, conn: conn}, nil
-}
-
-func (p *Provider) Delete(_ context.Context, objectKey string) error {
-	conn, err := p.dial()
-	if err != nil {
-		return err
-	}
-	defer conn.Quit()
-
-	objectPath := p.resolvePath(objectKey)
-	if err := conn.Delete(objectPath); err != nil {
-		return fmt.Errorf("FTP delete: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) List(_ context.Context, prefix string) ([]storage.ObjectInfo, error) {
-	conn, err := p.dial()
-	if err != nil {
-		return nil, err
-	}
-	defer conn.Quit()
-
-	basePath := p.normalizeBasePath()
-	entries, err := conn.List(basePath)
-	if err != nil {
-		return nil, fmt.Errorf("FTP list: %w", err)
-	}
-
-	items := make([]storage.ObjectInfo, 0, len(entries))
-	for _, entry := range entries {
-		if entry.Type == ftp.EntryTypeFolder {
-			continue
-		}
-		key := strings.TrimPrefix(path.Join(strings.TrimPrefix(basePath, "/"), entry.Name), "/")
-		if prefix != "" && !strings.HasPrefix(key, prefix) {
-			continue
-		}
-		items = append(items, storage.ObjectInfo{
-			Key:       key,
-			Size:      int64(entry.Size),
-			UpdatedAt: entry.Time.UTC(),
-		})
-	}
-	return items, nil
-}
-
-// normalizeBasePath returns a cleaned base path with leading slash.
-func (p *Provider) normalizeBasePath() string {
-	clean := path.Clean("/" + strings.TrimSpace(p.config.BasePath))
-	if clean == "." {
-		return "/"
-	}
-	return clean
-}
-
-// resolvePath returns the full FTP path for the given object key.
-func (p *Provider) resolvePath(objectKey string) string {
-	cleanKey := path.Clean("/" + strings.TrimSpace(objectKey))
-	return path.Clean(path.Join(p.normalizeBasePath(), cleanKey))
-}
-
-// ensureDir creates all directories in the path recursively.
-func (p *Provider) ensureDir(conn *ftp.ServerConn, dirPath string) error {
-	parts := strings.Split(strings.Trim(dirPath, "/"), "/")
-	current := ""
-	for _, part := range parts {
-		if part == "" {
-			continue
-		}
-		current = current + "/" + part
-		if err := conn.MakeDir(current); err != nil {
-			// Ignore errors if directory already exists
-			// FTP doesn't have a standard "mkdir if not exists"
-			_ = err
-		}
-	}
-	return nil
-}
-
-// ftpReadCloser wraps an io.ReadCloser from FTP and closes the connection when done.
-type ftpReadCloser struct {
-	io.ReadCloser
-	conn *ftp.ServerConn
-}
-
-func (f *ftpReadCloser) Close() error {
-	err := f.ReadCloser.Close()
-	if f.conn != nil {
-		f.conn.Quit()
-	}
-	return err
-}

server/internal/storage/googledrive/provider.go

@@ -1,299 +0,0 @@
-package googledrive
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"path"
-	"strings"
-	"time"
-
-	"backupx/server/internal/storage"
-	"golang.org/x/oauth2"
-	googleoauth "golang.org/x/oauth2/google"
-	"google.golang.org/api/drive/v3"
-	"google.golang.org/api/option"
-)
-
-
-type fileInfo struct {
-	ID           string
-	Name         string
-	Size         int64
-	ModifiedTime time.Time
-}
-
-type client interface {
-	TestConnection(context.Context, string) error
-	Upload(context.Context, string, string, io.Reader) error
-	Download(context.Context, string, string) (io.ReadCloser, error)
-	Delete(context.Context, string, string) error
-	List(context.Context, string, string) ([]storage.ObjectInfo, error)
-	EnsureFolder(ctx context.Context, parentID, name string) (string, error)
-}
-
-type Provider struct {
-	client      client
-	rootFolder  string // user-configured folderId, empty means Drive root
-	folderCache map[string]string // cache: path -> folderID
-}
-
-type Factory struct {
-	newClient func(context.Context, storage.GoogleDriveConfig) (client, error)
-}
-
-func NewFactory() Factory {
-	return Factory{newClient: newDriveClient}
-}
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeGoogleDrive }
-func (Factory) SensitiveFields() []string {
-	return []string{"clientId", "clientSecret", "refreshToken"}
-}
-
-func (f Factory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[storage.GoogleDriveConfig](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-	cfg = cfg.Normalize()
-	if strings.TrimSpace(cfg.ClientID) == "" || strings.TrimSpace(cfg.ClientSecret) == "" {
-		return nil, fmt.Errorf("google drive client credentials are required")
-	}
-	if strings.TrimSpace(cfg.RefreshToken) == "" {
-		return nil, fmt.Errorf("google drive refresh token is required")
-	}
-	newClient := f.newClient
-	if newClient == nil {
-		newClient = NewFactory().newClient
-	}
-	client, err := newClient(ctx, cfg)
-	if err != nil {
-		return nil, err
-	}
-	return &Provider{
-		client:      client,
-		rootFolder:  strings.TrimSpace(cfg.FolderID),
-		folderCache: make(map[string]string),
-	}, nil
-}
-
-func (p *Provider) Type() storage.ProviderType { return storage.ProviderTypeGoogleDrive }
-
-// ensureFolderPath creates nested folders for a path like "BackupX/file/260308"
-// and returns the deepest folder's ID.
-func (p *Provider) ensureFolderPath(ctx context.Context, folderPath string) (string, error) {
-	if folderPath == "" || folderPath == "." {
-		return p.rootFolder, nil
-	}
-	if cached, ok := p.folderCache[folderPath]; ok {
-		return cached, nil
-	}
-	parts := strings.Split(path.Clean(folderPath), "/")
-	parentID := p.rootFolder
-	builtPath := ""
-	for _, part := range parts {
-		if part == "" || part == "." {
-			continue
-		}
-		if builtPath == "" {
-			builtPath = part
-		} else {
-			builtPath = builtPath + "/" + part
-		}
-		if cached, ok := p.folderCache[builtPath]; ok {
-			parentID = cached
-			continue
-		}
-		folderID, err := p.client.EnsureFolder(ctx, parentID, part)
-		if err != nil {
-			return "", fmt.Errorf("ensure folder %s: %w", builtPath, err)
-		}
-		p.folderCache[builtPath] = folderID
-		parentID = folderID
-	}
-	return parentID, nil
-}
-
-func (p *Provider) TestConnection(ctx context.Context) error {
-	return p.client.TestConnection(ctx, p.rootFolder)
-}
-
-func (p *Provider) Upload(ctx context.Context, objectKey string, reader io.Reader, _ int64, _ map[string]string) error {
-	dir := path.Dir(objectKey)
-	folderID, err := p.ensureFolderPath(ctx, dir)
-	if err != nil {
-		return err
-	}
-	return p.client.Upload(ctx, folderID, objectKey, reader)
-}
-
-func (p *Provider) Download(ctx context.Context, objectKey string) (io.ReadCloser, error) {
-	dir := path.Dir(objectKey)
-	folderID, err := p.ensureFolderPath(ctx, dir)
-	if err != nil {
-		return nil, err
-	}
-	return p.client.Download(ctx, folderID, objectKey)
-}
-
-func (p *Provider) Delete(ctx context.Context, objectKey string) error {
-	dir := path.Dir(objectKey)
-	folderID, err := p.ensureFolderPath(ctx, dir)
-	if err != nil {
-		return err
-	}
-	return p.client.Delete(ctx, folderID, objectKey)
-}
-
-func (p *Provider) List(ctx context.Context, prefix string) ([]storage.ObjectInfo, error) {
-	dir := path.Dir(prefix)
-	folderID, err := p.ensureFolderPath(ctx, dir)
-	if err != nil {
-		return nil, err
-	}
-	return p.client.List(ctx, folderID, prefix)
-}
-
-type driveClient struct {
-	service *drive.Service
-}
-
-func newDriveClient(ctx context.Context, cfg storage.GoogleDriveConfig) (client, error) {
-	cfg = cfg.Normalize()
-	oauthCfg := &oauth2.Config{
-		ClientID:     cfg.ClientID,
-		ClientSecret: cfg.ClientSecret,
-		RedirectURL:  cfg.RedirectURL,
-		Endpoint:     googleoauth.Endpoint,
-		Scopes:       []string{drive.DriveScope},
-	}
-	httpClient := oauthCfg.Client(ctx, &oauth2.Token{RefreshToken: cfg.RefreshToken})
-	service, err := drive.NewService(ctx, option.WithHTTPClient(httpClient))
-	if err != nil {
-		return nil, fmt.Errorf("create google drive service: %w", err)
-	}
-	return &driveClient{service: service}, nil
-}
-
-func (c *driveClient) TestConnection(ctx context.Context, folderID string) error {
-	if strings.TrimSpace(folderID) == "" {
-		_, err := c.service.About.Get().Fields("user").Context(ctx).Do()
-		if err != nil {
-			return fmt.Errorf("test google drive connection: %w", err)
-		}
-		return nil
-	}
-	_, err := c.service.Files.Get(folderID).Fields("id").Context(ctx).Do()
-	if err != nil {
-		return fmt.Errorf("test google drive folder: %w", err)
-	}
-	return nil
-}
-
-func (c *driveClient) EnsureFolder(ctx context.Context, parentID, name string) (string, error) {
-	// Search for existing folder
-	query := fmt.Sprintf("name = '%s' and mimeType = 'application/vnd.google-apps.folder' and trashed = false", escapeQuery(name))
-	if strings.TrimSpace(parentID) != "" {
-		query += fmt.Sprintf(" and '%s' in parents", escapeQuery(parentID))
-	} else {
-		query += " and 'root' in parents"
-	}
-	result, err := c.service.Files.List().Q(query).PageSize(1).Fields("files(id)").Context(ctx).Do()
-	if err != nil {
-		return "", fmt.Errorf("search for folder %s: %w", name, err)
-	}
-	if len(result.Files) > 0 {
-		return result.Files[0].Id, nil
-	}
-	// Create the folder
-	folder := &drive.File{
-		Name:     name,
-		MimeType: "application/vnd.google-apps.folder",
-	}
-	if strings.TrimSpace(parentID) != "" {
-		folder.Parents = []string{parentID}
-	}
-	created, err := c.service.Files.Create(folder).Fields("id").Context(ctx).Do()
-	if err != nil {
-		return "", fmt.Errorf("create folder %s: %w", name, err)
-	}
-	return created.Id, nil
-}
-
-func (c *driveClient) Upload(ctx context.Context, folderID, objectKey string, reader io.Reader) error {
-	file := &drive.File{Name: path.Base(objectKey)}
-	if strings.TrimSpace(folderID) != "" {
-		file.Parents = []string{folderID}
-	}
-	_, err := c.service.Files.Create(file).Media(reader).Context(ctx).Do()
-	if err != nil {
-		return fmt.Errorf("upload google drive object: %w", err)
-	}
-	return nil
-}
-
-func (c *driveClient) Download(ctx context.Context, folderID, objectKey string) (io.ReadCloser, error) {
-	file, err := c.findFile(ctx, folderID, objectKey)
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.service.Files.Get(file.ID).Context(ctx).Download()
-	if err != nil {
-		return nil, fmt.Errorf("download google drive object: %w", err)
-	}
-	return response.Body, nil
-}
-
-func (c *driveClient) Delete(ctx context.Context, folderID, objectKey string) error {
-	file, err := c.findFile(ctx, folderID, objectKey)
-	if err != nil {
-		return err
-	}
-	if err := c.service.Files.Delete(file.ID).Context(ctx).Do(); err != nil {
-		return fmt.Errorf("delete google drive object: %w", err)
-	}
-	return nil
-}
-
-func (c *driveClient) List(ctx context.Context, folderID, prefix string) ([]storage.ObjectInfo, error) {
-	query := "trashed = false"
-	if strings.TrimSpace(folderID) != "" {
-		query += fmt.Sprintf(" and '%s' in parents", escapeQuery(folderID))
-	}
-	if strings.TrimSpace(prefix) != "" {
-		query += fmt.Sprintf(" and name contains '%s'", escapeQuery(prefix))
-	}
-	result, err := c.service.Files.List().Q(query).Fields("files(id,name,size,modifiedTime)").Context(ctx).Do()
-	if err != nil {
-		return nil, fmt.Errorf("list google drive objects: %w", err)
-	}
-	items := make([]storage.ObjectInfo, 0, len(result.Files))
-	for _, file := range result.Files {
-		modifiedAt, _ := time.Parse(time.RFC3339, file.ModifiedTime)
-		items = append(items, storage.ObjectInfo{Key: file.Name, Size: file.Size, UpdatedAt: modifiedAt.UTC()})
-	}
-	return items, nil
-}
-
-func (c *driveClient) findFile(ctx context.Context, folderID, objectKey string) (*fileInfo, error) {
-	query := fmt.Sprintf("name = '%s' and trashed = false", escapeQuery(path.Base(objectKey)))
-	if strings.TrimSpace(folderID) != "" {
-		query += fmt.Sprintf(" and '%s' in parents", escapeQuery(folderID))
-	}
-	result, err := c.service.Files.List().Q(query).PageSize(1).Fields("files(id,name,size,modifiedTime)").Context(ctx).Do()
-	if err != nil {
-		return nil, fmt.Errorf("query google drive object: %w", err)
-	}
-	if len(result.Files) == 0 {
-		return nil, fmt.Errorf("google drive object not found: %s", objectKey)
-	}
-	file := result.Files[0]
-	modifiedAt, _ := time.Parse(time.RFC3339, file.ModifiedTime)
-	return &fileInfo{ID: file.Id, Name: file.Name, Size: file.Size, ModifiedTime: modifiedAt.UTC()}, nil
-}
-
-func escapeQuery(value string) string {
-	return strings.ReplaceAll(value, "'", "\\'")
-}
-

server/internal/storage/googledrive/provider_test.go

@@ -1,75 +0,0 @@
-package googledrive
-
-import (
-	"context"
-	"io"
-	"strings"
-	"testing"
-	"time"
-
-	"backupx/server/internal/storage"
-)
-
-type fakeClient struct{ data map[string]string }
-
-func (c *fakeClient) TestConnection(context.Context, string) error { return nil }
-func (c *fakeClient) Upload(_ context.Context, _ string, objectKey string, reader io.Reader) error {
-	content, _ := io.ReadAll(reader)
-	c.data[objectKey] = string(content)
-	return nil
-}
-func (c *fakeClient) Download(_ context.Context, _ string, objectKey string) (io.ReadCloser, error) {
-	return io.NopCloser(strings.NewReader(c.data[objectKey])), nil
-}
-func (c *fakeClient) Delete(_ context.Context, _ string, objectKey string) error {
-	delete(c.data, objectKey)
-	return nil
-}
-func (c *fakeClient) List(_ context.Context, _ string, prefix string) ([]storage.ObjectInfo, error) {
-	items := make([]storage.ObjectInfo, 0)
-	for key, value := range c.data {
-		if prefix == "" || strings.HasPrefix(key, prefix) {
-			items = append(items, storage.ObjectInfo{Key: key, Size: int64(len(value)), UpdatedAt: time.Now().UTC()})
-		}
-	}
-	return items, nil
-}
-func (c *fakeClient) EnsureFolder(_ context.Context, _, name string) (string, error) {
-	return "fake-folder-" + name, nil
-}
-
-func TestGoogleDriveProviderCRUD(t *testing.T) {
-	factory := Factory{newClient: func(context.Context, storage.GoogleDriveConfig) (client, error) {
-		return &fakeClient{data: make(map[string]string)}, nil
-	}}
-	providerAny, err := factory.New(context.Background(), map[string]any{"clientId": "id", "clientSecret": "secret", "refreshToken": "refresh"})
-	if err != nil {
-		t.Fatalf("Factory.New returned error: %v", err)
-	}
-	provider := providerAny.(*Provider)
-	if err := provider.TestConnection(context.Background()); err != nil {
-		t.Fatalf("TestConnection returned error: %v", err)
-	}
-	if err := provider.Upload(context.Background(), "backup.tar.gz", strings.NewReader("payload"), 7, nil); err != nil {
-		t.Fatalf("Upload returned error: %v", err)
-	}
-	reader, err := provider.Download(context.Background(), "backup.tar.gz")
-	if err != nil {
-		t.Fatalf("Download returned error: %v", err)
-	}
-	defer reader.Close()
-	content, _ := io.ReadAll(reader)
-	if string(content) != "payload" {
-		t.Fatalf("unexpected content: %s", string(content))
-	}
-	items, err := provider.List(context.Background(), "backup")
-	if err != nil {
-		t.Fatalf("List returned error: %v", err)
-	}
-	if len(items) != 1 || items[0].Key != "backup.tar.gz" {
-		t.Fatalf("unexpected list result: %#v", items)
-	}
-	if err := provider.Delete(context.Background(), "backup.tar.gz"); err != nil {
-		t.Fatalf("Delete returned error: %v", err)
-	}
-}

server/internal/storage/localdisk/provider.go

@@ -1,137 +0,0 @@
-package localdisk
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"backupx/server/internal/storage"
-)
-
-type Provider struct {
-	basePath string
-}
-
-type Factory struct{}
-
-func NewFactory() Factory { return Factory{} }
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeLocalDisk }
-func (Factory) SensitiveFields() []string  { return nil }
-
-func (Factory) New(_ context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[storage.LocalDiskConfig](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(cfg.BasePath) == "" {
-		return nil, fmt.Errorf("local disk basePath is required")
-	}
-	return &Provider{basePath: filepath.Clean(cfg.BasePath)}, nil
-}
-
-func (p *Provider) Type() storage.ProviderType { return storage.ProviderTypeLocalDisk }
-
-func (p *Provider) TestConnection(_ context.Context) error {
-	if err := os.MkdirAll(p.basePath, 0o755); err != nil {
-		return fmt.Errorf("ensure local disk base path: %w", err)
-	}
-	tempFile, err := os.CreateTemp(p.basePath, ".backupx-connection-test-*")
-	if err != nil {
-		return fmt.Errorf("write access check failed: %w", err)
-	}
-	name := tempFile.Name()
-	_ = tempFile.Close()
-	_ = os.Remove(name)
-	return nil
-}
-
-func (p *Provider) Upload(_ context.Context, objectKey string, reader io.Reader, _ int64, _ map[string]string) error {
-	targetPath, err := p.resolvePath(objectKey)
-	if err != nil {
-		return err
-	}
-	if err := os.MkdirAll(filepath.Dir(targetPath), 0o755); err != nil {
-		return fmt.Errorf("create local disk directories: %w", err)
-	}
-	file, err := os.Create(targetPath)
-	if err != nil {
-		return fmt.Errorf("create local disk object: %w", err)
-	}
-	defer file.Close()
-	if _, err := io.Copy(file, reader); err != nil {
-		return fmt.Errorf("write local disk object: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) Download(_ context.Context, objectKey string) (io.ReadCloser, error) {
-	targetPath, err := p.resolvePath(objectKey)
-	if err != nil {
-		return nil, err
-	}
-	file, err := os.Open(targetPath)
-	if err != nil {
-		return nil, fmt.Errorf("open local disk object: %w", err)
-	}
-	return file, nil
-}
-
-func (p *Provider) Delete(_ context.Context, objectKey string) error {
-	targetPath, err := p.resolvePath(objectKey)
-	if err != nil {
-		return err
-	}
-	if err := os.Remove(targetPath); err != nil && !os.IsNotExist(err) {
-		return fmt.Errorf("delete local disk object: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) List(_ context.Context, prefix string) ([]storage.ObjectInfo, error) {
-	items := make([]storage.ObjectInfo, 0)
-	err := filepath.WalkDir(p.basePath, func(path string, entry fs.DirEntry, walkErr error) error {
-		if walkErr != nil {
-			return walkErr
-		}
-		if entry.IsDir() {
-			return nil
-		}
-		rel, err := filepath.Rel(p.basePath, path)
-		if err != nil {
-			return err
-		}
-		key := filepath.ToSlash(rel)
-		if prefix != "" && !strings.HasPrefix(key, prefix) {
-			return nil
-		}
-		info, err := entry.Info()
-		if err != nil {
-			return err
-		}
-		items = append(items, storage.ObjectInfo{Key: key, Size: info.Size(), UpdatedAt: info.ModTime().UTC()})
-		return nil
-	})
-	if err != nil && !os.IsNotExist(err) {
-		return nil, fmt.Errorf("list local disk objects: %w", err)
-	}
-	return items, nil
-}
-
-func (p *Provider) resolvePath(objectKey string) (string, error) {
-	cleanBase := filepath.Clean(p.basePath)
-	cleanKey := filepath.Clean(filepath.FromSlash(strings.TrimSpace(objectKey)))
-	if cleanKey == "." || cleanKey == string(filepath.Separator) || cleanKey == "" {
-		return "", fmt.Errorf("object key is required")
-	}
-	fullPath := filepath.Clean(filepath.Join(cleanBase, cleanKey))
-	baseWithSep := cleanBase + string(filepath.Separator)
-	if fullPath != cleanBase && !strings.HasPrefix(fullPath, baseWithSep) {
-		return "", fmt.Errorf("object key escapes base path")
-	}
-	return fullPath, nil
-}

server/internal/storage/localdisk/provider_test.go

@@ -1,52 +0,0 @@
-package localdisk
-
-import (
-	"context"
-	"io"
-	"strings"
-	"testing"
-)
-
-func TestLocalDiskProviderCRUD(t *testing.T) {
-	providerAny, err := (Factory{}).New(context.Background(), map[string]any{"basePath": t.TempDir()})
-	if err != nil {
-		t.Fatalf("Factory.New returned error: %v", err)
-	}
-	provider := providerAny.(*Provider)
-	if err := provider.TestConnection(context.Background()); err != nil {
-		t.Fatalf("TestConnection returned error: %v", err)
-	}
-	if err := provider.Upload(context.Background(), "daily/backup.txt", strings.NewReader("hello"), 5, nil); err != nil {
-		t.Fatalf("Upload returned error: %v", err)
-	}
-	reader, err := provider.Download(context.Background(), "daily/backup.txt")
-	if err != nil {
-		t.Fatalf("Download returned error: %v", err)
-	}
-	defer reader.Close()
-	content, _ := io.ReadAll(reader)
-	if string(content) != "hello" {
-		t.Fatalf("expected downloaded content to match, got %s", string(content))
-	}
-	items, err := provider.List(context.Background(), "daily")
-	if err != nil {
-		t.Fatalf("List returned error: %v", err)
-	}
-	if len(items) != 1 || items[0].Key != "daily/backup.txt" {
-		t.Fatalf("unexpected list result: %#v", items)
-	}
-	if err := provider.Delete(context.Background(), "daily/backup.txt"); err != nil {
-		t.Fatalf("Delete returned error: %v", err)
-	}
-}
-
-func TestLocalDiskProviderRejectsTraversal(t *testing.T) {
-	providerAny, err := (Factory{}).New(context.Background(), map[string]any{"basePath": t.TempDir()})
-	if err != nil {
-		t.Fatalf("Factory.New returned error: %v", err)
-	}
-	provider := providerAny.(*Provider)
-	if _, err := provider.resolvePath("../escape.txt"); err == nil {
-		t.Fatalf("expected traversal to be rejected")
-	}
-}

server/internal/storage/qiniu/factory.go

@@ -1,73 +0,0 @@
-// Package qiniu provides a Qiniu Cloud Kodo storage factory that delegates to the S3-compatible engine.
-// Qiniu Kodo is S3-compatible; we auto-assemble the endpoint from the user-provided region.
-package qiniu
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"backupx/server/internal/storage"
-	"backupx/server/internal/storage/s3"
-)
-
-// Config is the user-facing configuration for Qiniu Kodo.
-type Config struct {
-	Region          string `json:"region"` // e.g. z0, z1, z2, na0, as0
-	Bucket          string `json:"bucket"`
-	AccessKey       string `json:"accessKeyId"`
-	SecretKey       string `json:"secretAccessKey"`
-	Endpoint        string `json:"endpoint"` // optional override
-}
-
-// regionEndpoints maps Qiniu storage region codes to their S3-compatible endpoints.
-var regionEndpoints = map[string]string{
-	"z0":  "https://s3-cn-east-1.qiniucs.com",
-	"cn-east-2": "https://s3-cn-east-2.qiniucs.com",
-	"z1":  "https://s3-cn-north-1.qiniucs.com",
-	"z2":  "https://s3-cn-south-1.qiniucs.com",
-	"na0": "https://s3-us-north-1.qiniucs.com",
-	"as0": "https://s3-ap-southeast-1.qiniucs.com",
-}
-
-// Factory creates Qiniu Kodo providers by composing the S3 engine.
-type Factory struct {
-	s3Factory s3.Factory
-}
-
-func NewFactory() Factory {
-	return Factory{s3Factory: s3.NewFactory()}
-}
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeQiniuKodo }
-func (Factory) SensitiveFields() []string  { return []string{"accessKeyId", "secretAccessKey"} }
-
-func (f Factory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[Config](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := strings.TrimSpace(cfg.Endpoint)
-	if endpoint == "" {
-		region := strings.TrimSpace(cfg.Region)
-		if region == "" {
-			return nil, fmt.Errorf("qiniu kodo region is required")
-		}
-		var ok bool
-		endpoint, ok = regionEndpoints[region]
-		if !ok {
-			return nil, fmt.Errorf("unsupported qiniu region: %s (supported: z0, cn-east-2, z1, z2, na0, as0)", region)
-		}
-	}
-
-	s3Config := map[string]any{
-		"endpoint":        endpoint,
-		"region":          cfg.Region,
-		"bucket":          cfg.Bucket,
-		"accessKeyId":     cfg.AccessKey,
-		"secretAccessKey": cfg.SecretKey,
-		"forcePathStyle":  true, // Qiniu S3-compatible uses path-style
-	}
-	return f.s3Factory.New(ctx, s3Config)
-}

server/internal/storage/rclone/backends.go

@@ -0,0 +1,5 @@
+// Package rclone 提供基于 rclone 的统一存储后端实现。
+// 引入全部 rclone backend，支持 70+ 存储后端。
+package rclone
+
+import _ "github.com/rclone/rclone/backend/all"

server/internal/storage/rclone/config.go

@@ -0,0 +1,36 @@
+package rclone
+
+import (
+	"context"
+
+	"github.com/rclone/rclone/fs"
+	"github.com/rclone/rclone/fs/accounting"
+)
+
+// TransferConfig 控制 rclone 传输层行为。
+type TransferConfig struct {
+	LowLevelRetries int    // 底层 HTTP 请求重试次数，0 保持 rclone 默认（10）
+	BandwidthLimit  string // 带宽限制，如 "10M"、"1M:500k"（上传:下载），空或 "0" 不限
+}
+
+// ConfiguredContext 返回注入了 rclone 传输配置的 context。
+// 各 rclone 后端在 fs.NewFs 时读取 context 中的配置，自动应用重试和限速。
+func ConfiguredContext(ctx context.Context, cfg TransferConfig) context.Context {
+	ctx, ci := fs.AddConfig(ctx)
+	if cfg.LowLevelRetries > 0 {
+		ci.LowLevelRetries = cfg.LowLevelRetries
+	}
+	if cfg.BandwidthLimit != "" && cfg.BandwidthLimit != "0" {
+		var bwTable fs.BwTimetable
+		if err := bwTable.Set(cfg.BandwidthLimit); err == nil {
+			ci.BwLimit = bwTable
+		}
+	}
+	return ctx
+}
+
+// StartAccounting 初始化 rclone 的传输统计和令牌桶限速系统。
+// 应在应用启动时调用一次。
+func StartAccounting(ctx context.Context) {
+	accounting.Start(ctx)
+}

server/internal/storage/rclone/factory.go

@@ -0,0 +1,508 @@
+package rclone
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"backupx/server/internal/storage"
+
+	"github.com/rclone/rclone/fs"
+)
+
+// ---------------------------------------------------------------------------
+// 辅助函数
+// ---------------------------------------------------------------------------
+
+// quoteParam 对 rclone 连接字符串中含特殊字符的值加单引号保护。
+func quoteParam(s string) string {
+	if s == "" {
+		return s
+	}
+	if !strings.ContainsAny(s, ",:='") {
+		return s
+	}
+	return "'" + strings.ReplaceAll(s, "'", "''") + "'"
+}
+
+// newFs 创建 rclone fs.Fs 实例并包装为 Provider。
+func newFs(ctx context.Context, providerType storage.ProviderType, remote string) (*Provider, error) {
+	rfs, err := fs.NewFs(ctx, remote)
+	if err != nil {
+		return nil, fmt.Errorf("create rclone fs for %s: %w", providerType, err)
+	}
+	return newProvider(providerType, rfs), nil
+}
+
+// ---------------------------------------------------------------------------
+// LocalDisk
+// ---------------------------------------------------------------------------
+
+type LocalDiskFactory struct{}
+
+func NewLocalDiskFactory() LocalDiskFactory { return LocalDiskFactory{} }
+
+func (LocalDiskFactory) Type() storage.ProviderType { return storage.ProviderTypeLocalDisk }
+func (LocalDiskFactory) SensitiveFields() []string   { return nil }
+
+func (LocalDiskFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[storage.LocalDiskConfig](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	basePath := strings.TrimSpace(cfg.BasePath)
+	if basePath == "" {
+		return nil, fmt.Errorf("local disk basePath is required")
+	}
+	return newFs(ctx, storage.ProviderTypeLocalDisk, basePath)
+}
+
+// ---------------------------------------------------------------------------
+// S3
+// ---------------------------------------------------------------------------
+
+type S3Factory struct{}
+
+func NewS3Factory() S3Factory { return S3Factory{} }
+
+func (S3Factory) Type() storage.ProviderType { return storage.ProviderTypeS3 }
+func (S3Factory) SensitiveFields() []string   { return []string{"accessKeyId", "secretAccessKey"} }
+
+func (S3Factory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[storage.S3Config](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	if strings.TrimSpace(cfg.Bucket) == "" {
+		return nil, fmt.Errorf("s3 bucket is required")
+	}
+	if strings.TrimSpace(cfg.AccessKeyID) == "" || strings.TrimSpace(cfg.SecretAccessKey) == "" {
+		return nil, fmt.Errorf("s3 credentials are required")
+	}
+	return newFs(ctx, storage.ProviderTypeS3, buildS3Remote("Other", cfg.AccessKeyID, cfg.SecretAccessKey, cfg.Endpoint, cfg.Region, cfg.Bucket, cfg.ForcePathStyle))
+}
+
+// buildS3Remote 构建 S3 兼容存储的 rclone 连接字符串。
+func buildS3Remote(provider, keyID, secret, endpoint, region, bucket string, pathStyle bool) string {
+	var b strings.Builder
+	b.WriteString(":s3,provider=")
+	b.WriteString(quoteParam(provider))
+	b.WriteString(",access_key_id=")
+	b.WriteString(quoteParam(keyID))
+	b.WriteString(",secret_access_key=")
+	b.WriteString(quoteParam(secret))
+	if strings.TrimSpace(endpoint) != "" {
+		b.WriteString(",endpoint=")
+		b.WriteString(quoteParam(strings.TrimRight(endpoint, "/")))
+	}
+	if strings.TrimSpace(region) != "" {
+		b.WriteString(",region=")
+		b.WriteString(quoteParam(region))
+	}
+	if pathStyle {
+		b.WriteString(",force_path_style=true")
+	}
+	b.WriteString(",env_auth=false,no_check_bucket=true:")
+	b.WriteString(bucket)
+	return b.String()
+}
+
+// ---------------------------------------------------------------------------
+// WebDAV
+// ---------------------------------------------------------------------------
+
+type WebDAVFactory struct{}
+
+func NewWebDAVFactory() WebDAVFactory { return WebDAVFactory{} }
+
+func (WebDAVFactory) Type() storage.ProviderType { return storage.ProviderTypeWebDAV }
+func (WebDAVFactory) SensitiveFields() []string   { return []string{"username", "password"} }
+
+func (WebDAVFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[storage.WebDAVConfig](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	if strings.TrimSpace(cfg.Endpoint) == "" {
+		return nil, fmt.Errorf("webdav endpoint is required")
+	}
+	remote := fmt.Sprintf(":webdav,url=%s,user=%s,pass=%s:%s",
+		quoteParam(strings.TrimRight(cfg.Endpoint, "/")),
+		quoteParam(cfg.Username),
+		quoteParam(cfg.Password),
+		strings.TrimSpace(cfg.BasePath))
+	return newFs(ctx, storage.ProviderTypeWebDAV, remote)
+}
+
+// ---------------------------------------------------------------------------
+// Google Drive
+// ---------------------------------------------------------------------------
+
+type GoogleDriveFactory struct{}
+
+func NewGoogleDriveFactory() GoogleDriveFactory { return GoogleDriveFactory{} }
+
+func (GoogleDriveFactory) Type() storage.ProviderType { return storage.ProviderTypeGoogleDrive }
+func (GoogleDriveFactory) SensitiveFields() []string {
+	return []string{"clientId", "clientSecret", "refreshToken"}
+}
+
+func (GoogleDriveFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[storage.GoogleDriveConfig](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	cfg = cfg.Normalize()
+	if strings.TrimSpace(cfg.ClientID) == "" || strings.TrimSpace(cfg.ClientSecret) == "" {
+		return nil, fmt.Errorf("google drive client credentials are required")
+	}
+	if strings.TrimSpace(cfg.RefreshToken) == "" {
+		return nil, fmt.Errorf("google drive refresh token is required")
+	}
+	// 构造 rclone 所需的 OAuth2 token JSON
+	tokenJSON := fmt.Sprintf(`{"access_token":"","token_type":"Bearer","refresh_token":"%s","expiry":"0001-01-01T00:00:00Z"}`,
+		strings.ReplaceAll(cfg.RefreshToken, `"`, `\"`))
+
+	var b strings.Builder
+	b.WriteString(":drive,client_id=")
+	b.WriteString(quoteParam(cfg.ClientID))
+	b.WriteString(",client_secret=")
+	b.WriteString(quoteParam(cfg.ClientSecret))
+	b.WriteString(",token=")
+	b.WriteString(quoteParam(tokenJSON))
+	if strings.TrimSpace(cfg.FolderID) != "" {
+		b.WriteString(",root_folder_id=")
+		b.WriteString(quoteParam(cfg.FolderID))
+	}
+	b.WriteString(":")
+	return newFs(ctx, storage.ProviderTypeGoogleDrive, b.String())
+}
+
+// ---------------------------------------------------------------------------
+// FTP
+// ---------------------------------------------------------------------------
+
+type FTPFactory struct{}
+
+func NewFTPFactory() FTPFactory { return FTPFactory{} }
+
+func (FTPFactory) Type() storage.ProviderType { return storage.ProviderTypeFTP }
+func (FTPFactory) SensitiveFields() []string   { return []string{"username", "password"} }
+
+func (FTPFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[storage.FTPConfig](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	if strings.TrimSpace(cfg.Host) == "" {
+		return nil, fmt.Errorf("FTP host is required")
+	}
+	port := cfg.Port
+	if port == 0 {
+		port = 21
+	}
+	username := strings.TrimSpace(cfg.Username)
+	if username == "" {
+		username = "anonymous"
+	}
+	var b strings.Builder
+	b.WriteString(fmt.Sprintf(":ftp,host=%s,port=%d,user=%s,pass=%s",
+		quoteParam(cfg.Host), port, quoteParam(username), quoteParam(cfg.Password)))
+	if cfg.UseTLS {
+		b.WriteString(",tls=true,explicit_tls=true")
+	}
+	b.WriteString(":")
+	basePath := strings.TrimSpace(cfg.BasePath)
+	if basePath != "" {
+		b.WriteString(basePath)
+	}
+	return newFs(ctx, storage.ProviderTypeFTP, b.String())
+}
+
+// ---------------------------------------------------------------------------
+// 阿里云 OSS（委托 S3 引擎）
+// ---------------------------------------------------------------------------
+
+type AliyunOSSFactory struct{}
+
+func NewAliyunOSSFactory() AliyunOSSFactory { return AliyunOSSFactory{} }
+
+func (AliyunOSSFactory) Type() storage.ProviderType { return storage.ProviderTypeAliyunOSS }
+func (AliyunOSSFactory) SensitiveFields() []string   { return []string{"accessKeyId", "secretAccessKey"} }
+
+// AliyunConfig 是阿里云 OSS 的用户配置。
+type AliyunConfig struct {
+	Region          string `json:"region"`
+	Bucket          string `json:"bucket"`
+	AccessKeyID     string `json:"accessKeyId"`
+	SecretAccessKey string `json:"secretAccessKey"`
+	Endpoint        string `json:"endpoint"`
+	InternalNetwork bool   `json:"internalNetwork"`
+}
+
+func (AliyunOSSFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[AliyunConfig](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	endpoint := strings.TrimSpace(cfg.Endpoint)
+	if endpoint == "" {
+		region := strings.TrimSpace(cfg.Region)
+		if region == "" {
+			return nil, fmt.Errorf("aliyun oss region is required")
+		}
+		if cfg.InternalNetwork {
+			endpoint = fmt.Sprintf("https://oss-%s-internal.aliyuncs.com", region)
+		} else {
+			endpoint = fmt.Sprintf("https://oss-%s.aliyuncs.com", region)
+		}
+	}
+	return newFs(ctx, storage.ProviderTypeAliyunOSS, buildS3Remote("Alibaba", cfg.AccessKeyID, cfg.SecretAccessKey, endpoint, cfg.Region, cfg.Bucket, false))
+}
+
+// ---------------------------------------------------------------------------
+// 腾讯云 COS（委托 S3 引擎）
+// ---------------------------------------------------------------------------
+
+type TencentCOSFactory struct{}
+
+func NewTencentCOSFactory() TencentCOSFactory { return TencentCOSFactory{} }
+
+func (TencentCOSFactory) Type() storage.ProviderType { return storage.ProviderTypeTencentCOS }
+func (TencentCOSFactory) SensitiveFields() []string   { return []string{"accessKeyId", "secretAccessKey"} }
+
+// TencentConfig 是腾讯云 COS 的用户配置。
+type TencentConfig struct {
+	Region    string `json:"region"`
+	Bucket    string `json:"bucket"`
+	SecretID  string `json:"accessKeyId"`
+	SecretKey string `json:"secretAccessKey"`
+	Endpoint  string `json:"endpoint"`
+}
+
+func (TencentCOSFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[TencentConfig](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	endpoint := strings.TrimSpace(cfg.Endpoint)
+	if endpoint == "" {
+		region := strings.TrimSpace(cfg.Region)
+		if region == "" {
+			return nil, fmt.Errorf("tencent cos region is required")
+		}
+		endpoint = fmt.Sprintf("https://cos.%s.myqcloud.com", region)
+	}
+	return newFs(ctx, storage.ProviderTypeTencentCOS, buildS3Remote("TencentCOS", cfg.SecretID, cfg.SecretKey, endpoint, cfg.Region, cfg.Bucket, false))
+}
+
+// ---------------------------------------------------------------------------
+// 七牛云 Kodo（委托 S3 引擎）
+// ---------------------------------------------------------------------------
+
+type QiniuKodoFactory struct{}
+
+func NewQiniuKodoFactory() QiniuKodoFactory { return QiniuKodoFactory{} }
+
+func (QiniuKodoFactory) Type() storage.ProviderType { return storage.ProviderTypeQiniuKodo }
+func (QiniuKodoFactory) SensitiveFields() []string   { return []string{"accessKeyId", "secretAccessKey"} }
+
+// QiniuConfig 是七牛云 Kodo 的用户配置。
+type QiniuConfig struct {
+	Region    string `json:"region"`
+	Bucket    string `json:"bucket"`
+	AccessKey string `json:"accessKeyId"`
+	SecretKey string `json:"secretAccessKey"`
+	Endpoint  string `json:"endpoint"`
+}
+
+// regionEndpoints 映射七牛区域代码到 S3 兼容 endpoint。
+var regionEndpoints = map[string]string{
+	"z0":        "https://s3-cn-east-1.qiniucs.com",
+	"cn-east-2": "https://s3-cn-east-2.qiniucs.com",
+	"z1":        "https://s3-cn-north-1.qiniucs.com",
+	"z2":        "https://s3-cn-south-1.qiniucs.com",
+	"na0":       "https://s3-us-north-1.qiniucs.com",
+	"as0":       "https://s3-ap-southeast-1.qiniucs.com",
+}
+
+func (QiniuKodoFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	cfg, err := storage.DecodeConfig[QiniuConfig](rawConfig)
+	if err != nil {
+		return nil, err
+	}
+	endpoint := strings.TrimSpace(cfg.Endpoint)
+	if endpoint == "" {
+		region := strings.TrimSpace(cfg.Region)
+		if region == "" {
+			return nil, fmt.Errorf("qiniu kodo region is required")
+		}
+		var ok bool
+		endpoint, ok = regionEndpoints[region]
+		if !ok {
+			return nil, fmt.Errorf("unsupported qiniu region: %s (supported: z0, cn-east-2, z1, z2, na0, as0)", region)
+		}
+	}
+	return newFs(ctx, storage.ProviderTypeQiniuKodo, buildS3Remote("Qiniu", cfg.AccessKey, cfg.SecretKey, endpoint, cfg.Region, cfg.Bucket, true))
+}
+
+// ---------------------------------------------------------------------------
+// 通用 Rclone 后端（支持全部 70+ 后端）
+// ---------------------------------------------------------------------------
+
+type RcloneFactory struct{}
+
+func NewRcloneFactory() RcloneFactory { return RcloneFactory{} }
+
+func (RcloneFactory) Type() storage.ProviderType { return storage.ProviderTypeRclone }
+func (RcloneFactory) SensitiveFields() []string   { return []string{"pass", "password", "secret_access_key", "client_secret", "token"} }
+
+func (RcloneFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	backend, _ := rawConfig["backend"].(string)
+	backend = strings.TrimSpace(backend)
+	if backend == "" {
+		return nil, fmt.Errorf("rclone backend type is required")
+	}
+	root, _ := rawConfig["root"].(string)
+	root = strings.TrimSpace(root)
+
+	// 构建连接字符串：:backend,key1=val1,key2=val2:root
+	var b strings.Builder
+	b.WriteString(":")
+	b.WriteString(backend)
+	for key, val := range rawConfig {
+		if key == "backend" || key == "root" {
+			continue
+		}
+		strVal := fmt.Sprintf("%v", val)
+		if strings.TrimSpace(strVal) == "" {
+			continue
+		}
+		b.WriteString(",")
+		b.WriteString(key)
+		b.WriteString("=")
+		b.WriteString(quoteParam(strVal))
+	}
+	b.WriteString(":")
+	b.WriteString(root)
+
+	return newFs(ctx, storage.ProviderTypeRclone, b.String())
+}
+
+// ListBackends 返回所有可用的 rclone 后端及其配置选项。
+func ListBackends() []BackendInfo {
+	var backends []BackendInfo
+	for _, ri := range fs.Registry {
+		if ri.Name == "union" || ri.Name == "crypt" || ri.Name == "chunker" || ri.Name == "compress" || ri.Name == "hasher" || ri.Name == "combine" {
+			continue // 跳过组合/加密类后端
+		}
+		info := BackendInfo{
+			Name:        ri.Name,
+			Description: ri.Description,
+		}
+		for _, opt := range ri.Options {
+			if opt.Hide != 0 {
+				continue
+			}
+			// 跳过 rclone 为每个后端自动添加的通用选项
+			if opt.Name == "description" {
+				continue
+			}
+			info.Options = append(info.Options, BackendOption{
+				Key:        opt.Name,
+				Label:      opt.Help,
+				Required:   opt.Required,
+				IsPassword: opt.IsPassword,
+			})
+		}
+		backends = append(backends, info)
+	}
+	return backends
+}
+
+// BackendInfo 描述一个 rclone 后端。
+type BackendInfo struct {
+	Name        string          `json:"name"`
+	Description string          `json:"description"`
+	Options     []BackendOption `json:"options"`
+}
+
+// BackendOption 描述一个后端配置选项。
+type BackendOption struct {
+	Key        string `json:"key"`
+	Label      string `json:"label"`
+	Required   bool   `json:"required"`
+	IsPassword bool   `json:"isPassword"`
+}
+
+// ---------------------------------------------------------------------------
+// 通用 BackendFactory — 为任意 rclone 后端自动生成独立 Factory
+// ---------------------------------------------------------------------------
+
+// GenericBackendFactory 为单个 rclone 后端创建独立的 ProviderFactory。
+// 用户存储目标的 type 直接是后端名（如 "sftp"），与 "s3"、"ftp" 完全平级。
+type GenericBackendFactory struct {
+	backendType string
+	sensitive   []string
+}
+
+// NewBackendFactory 为指定 rclone 后端创建一个 Factory。
+func NewBackendFactory(backendType string) GenericBackendFactory {
+	var sensitive []string
+	for _, ri := range fs.Registry {
+		if ri.Name == backendType {
+			for _, opt := range ri.Options {
+				if opt.IsPassword {
+					sensitive = append(sensitive, opt.Name)
+				}
+			}
+			break
+		}
+	}
+	return GenericBackendFactory{backendType: backendType, sensitive: sensitive}
+}
+
+func (f GenericBackendFactory) Type() storage.ProviderType { return storage.ProviderType(f.backendType) }
+func (f GenericBackendFactory) SensitiveFields() []string   { return f.sensitive }
+
+func (f GenericBackendFactory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
+	root, _ := rawConfig["root"].(string)
+	root = strings.TrimSpace(root)
+
+	var b strings.Builder
+	b.WriteString(":")
+	b.WriteString(f.backendType)
+	for key, val := range rawConfig {
+		if key == "root" {
+			continue
+		}
+		strVal := fmt.Sprintf("%v", val)
+		if strings.TrimSpace(strVal) == "" {
+			continue
+		}
+		b.WriteString(",")
+		b.WriteString(key)
+		b.WriteString("=")
+		b.WriteString(quoteParam(strVal))
+	}
+	b.WriteString(":")
+	b.WriteString(root)
+
+	return newFs(ctx, storage.ProviderType(f.backendType), b.String())
+}
+
+// RegisterAllBackends 将所有 rclone 后端注册为独立 Factory 到 Registry。
+// 已存在的内置类型（s3, ftp 等）不会被覆盖。
+func RegisterAllBackends(registry *storage.Registry) {
+	builtinTypes := map[string]bool{
+		"local_disk": true, "s3": true, "webdav": true, "google_drive": true,
+		"ftp": true, "aliyun_oss": true, "tencent_cos": true, "qiniu_kodo": true,
+		"rclone": true, "local": true,
+	}
+	for _, info := range ListBackends() {
+		if builtinTypes[info.Name] {
+			continue
+		}
+		registry.Register(NewBackendFactory(info.Name))
+	}
+}

server/internal/storage/rclone/provider.go

@@ -0,0 +1,134 @@
+package rclone
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"backupx/server/internal/storage"
+
+	"github.com/rclone/rclone/fs"
+	"github.com/rclone/rclone/fs/object"
+	"github.com/rclone/rclone/fs/walk"
+)
+
+// Provider 包装 rclone fs.Fs，实现 storage.StorageProvider 接口。
+type Provider struct {
+	providerType storage.ProviderType
+	rfs          fs.Fs
+}
+
+func newProvider(providerType storage.ProviderType, rfs fs.Fs) *Provider {
+	return &Provider{providerType: providerType, rfs: rfs}
+}
+
+func (p *Provider) Type() storage.ProviderType { return p.providerType }
+
+// TestConnection 验证连通性。对本地磁盘会先确保目录存在。
+func (p *Provider) TestConnection(ctx context.Context) error {
+	// 确保根目录存在（本地磁盘等后端需要预创建）
+	if err := p.rfs.Mkdir(ctx, ""); err != nil {
+		return fmt.Errorf("rclone test connection (mkdir): %w", err)
+	}
+	_, err := p.rfs.List(ctx, "")
+	if err != nil {
+		return fmt.Errorf("rclone test connection: %w", err)
+	}
+	return nil
+}
+
+// Upload 通过 rclone fs.Fs.Put 上传文件。
+func (p *Provider) Upload(ctx context.Context, objectKey string, reader io.Reader, size int64, _ map[string]string) error {
+	dir := pathDir(objectKey)
+	if dir != "" && dir != "." {
+		if err := p.rfs.Mkdir(ctx, dir); err != nil {
+			return fmt.Errorf("rclone mkdir %s: %w", dir, err)
+		}
+	}
+	info := object.NewStaticObjectInfo(objectKey, time.Now(), size, true, nil, nil)
+	if _, err := p.rfs.Put(ctx, reader, info); err != nil {
+		return fmt.Errorf("rclone upload %s: %w", objectKey, err)
+	}
+	return nil
+}
+
+// Download 通过 rclone 获取对象并返回 io.ReadCloser。
+func (p *Provider) Download(ctx context.Context, objectKey string) (io.ReadCloser, error) {
+	obj, err := p.rfs.NewObject(ctx, objectKey)
+	if err != nil {
+		return nil, fmt.Errorf("rclone find object %s: %w", objectKey, err)
+	}
+	reader, err := obj.Open(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("rclone download %s: %w", objectKey, err)
+	}
+	return reader, nil
+}
+
+// Delete 通过 rclone 删除远端对象。
+func (p *Provider) Delete(ctx context.Context, objectKey string) error {
+	obj, err := p.rfs.NewObject(ctx, objectKey)
+	if err != nil {
+		return fmt.Errorf("rclone find object %s: %w", objectKey, err)
+	}
+	if err := obj.Remove(ctx); err != nil {
+		return fmt.Errorf("rclone delete %s: %w", objectKey, err)
+	}
+	return nil
+}
+
+// List 递归列出指定前缀下的所有对象。
+func (p *Provider) List(ctx context.Context, prefix string) ([]storage.ObjectInfo, error) {
+	var items []storage.ObjectInfo
+	err := walk.ListR(ctx, p.rfs, prefix, true, -1, walk.ListObjects, func(entries fs.DirEntries) error {
+		for _, entry := range entries {
+			obj, ok := entry.(fs.Object)
+			if !ok {
+				continue
+			}
+			key := obj.Remote()
+			if prefix != "" && !strings.HasPrefix(key, prefix) {
+				continue
+			}
+			items = append(items, storage.ObjectInfo{
+				Key:       key,
+				Size:      obj.Size(),
+				UpdatedAt: obj.ModTime(ctx),
+			})
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("rclone list %s: %w", prefix, err)
+	}
+	return items, nil
+}
+
+// About 查询远端存储空间。并非所有 rclone 后端都支持。
+func (p *Provider) About(ctx context.Context) (*storage.StorageUsageInfo, error) {
+	about := p.rfs.Features().About
+	if about == nil {
+		return nil, fmt.Errorf("rclone about: backend %s does not support About", p.providerType)
+	}
+	usage, err := about(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("rclone about: %w", err)
+	}
+	return &storage.StorageUsageInfo{
+		Total:   usage.Total,
+		Used:    usage.Used,
+		Free:    usage.Free,
+		Objects: usage.Objects,
+	}, nil
+}
+
+// pathDir 返回 objectKey 的目录部分（正斜杠分隔）。
+func pathDir(objectKey string) string {
+	idx := strings.LastIndex(objectKey, "/")
+	if idx < 0 {
+		return ""
+	}
+	return objectKey[:idx]
+}

server/internal/storage/rclone/provider_test.go

@@ -0,0 +1,202 @@
+package rclone
+
+import (
+	"context"
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestProviderLocalDiskCRUD(t *testing.T) {
+	factory := NewLocalDiskFactory()
+	provider, err := factory.New(context.Background(), map[string]any{"basePath": t.TempDir()})
+	if err != nil {
+		t.Fatalf("Factory.New returned error: %v", err)
+	}
+	if err := provider.TestConnection(context.Background()); err != nil {
+		t.Fatalf("TestConnection returned error: %v", err)
+	}
+
+	// Upload
+	if err := provider.Upload(context.Background(), "daily/backup.txt", strings.NewReader("hello"), 5, nil); err != nil {
+		t.Fatalf("Upload returned error: %v", err)
+	}
+
+	// Download
+	reader, err := provider.Download(context.Background(), "daily/backup.txt")
+	if err != nil {
+		t.Fatalf("Download returned error: %v", err)
+	}
+	defer reader.Close()
+	content, _ := io.ReadAll(reader)
+	if string(content) != "hello" {
+		t.Fatalf("expected 'hello', got %q", string(content))
+	}
+
+	// List with prefix
+	items, err := provider.List(context.Background(), "daily")
+	if err != nil {
+		t.Fatalf("List returned error: %v", err)
+	}
+	if len(items) != 1 || items[0].Key != "daily/backup.txt" {
+		t.Fatalf("unexpected list result: %#v", items)
+	}
+
+	// Delete
+	if err := provider.Delete(context.Background(), "daily/backup.txt"); err != nil {
+		t.Fatalf("Delete returned error: %v", err)
+	}
+
+	// List after delete should be empty
+	items, err = provider.List(context.Background(), "daily")
+	if err != nil {
+		t.Fatalf("List after delete returned error: %v", err)
+	}
+	if len(items) != 0 {
+		t.Fatalf("expected empty list after delete, got %d items", len(items))
+	}
+}
+
+func TestProviderLocalDiskRequiresBasePath(t *testing.T) {
+	_, err := NewLocalDiskFactory().New(context.Background(), map[string]any{"basePath": ""})
+	if err == nil {
+		t.Fatal("expected error for empty basePath")
+	}
+}
+
+func TestProviderS3RequiresBucketAndCredentials(t *testing.T) {
+	factory := NewS3Factory()
+	_, err := factory.New(context.Background(), map[string]any{"bucket": "", "accessKeyId": "a", "secretAccessKey": "b"})
+	if err == nil || !strings.Contains(err.Error(), "bucket") {
+		t.Fatalf("expected bucket required error, got %v", err)
+	}
+	_, err = factory.New(context.Background(), map[string]any{"bucket": "demo", "accessKeyId": "", "secretAccessKey": "b"})
+	if err == nil || !strings.Contains(err.Error(), "credentials") {
+		t.Fatalf("expected credentials required error, got %v", err)
+	}
+}
+
+func TestQuoteParam(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"simple", "simple"},
+		{"", ""},
+		{"has,comma", "'has,comma'"},
+		{"has:colon", "'has:colon'"},
+		{"has=equals", "'has=equals'"},
+		{"has'quote", "'has''quote'"},
+		{"a,b:c=d'e", "'a,b:c=d''e'"},
+	}
+	for _, tt := range tests {
+		got := quoteParam(tt.input)
+		if got != tt.expected {
+			t.Errorf("quoteParam(%q) = %q, want %q", tt.input, got, tt.expected)
+		}
+	}
+}
+
+func TestBuildS3Remote(t *testing.T) {
+	remote := buildS3Remote("Alibaba", "keyID", "secret", "https://oss-cn-hangzhou.aliyuncs.com", "cn-hangzhou", "my-bucket", false)
+	if !strings.Contains(remote, "provider=Alibaba") {
+		t.Fatalf("expected provider=Alibaba in remote: %s", remote)
+	}
+	if !strings.Contains(remote, ":my-bucket") {
+		t.Fatalf("expected :my-bucket suffix in remote: %s", remote)
+	}
+	if !strings.HasPrefix(remote, ":s3,") {
+		t.Fatalf("expected :s3, prefix in remote: %s", remote)
+	}
+}
+
+func TestRcloneFactoryCRUD(t *testing.T) {
+	dir := t.TempDir()
+	factory := NewRcloneFactory()
+	// 使用 rclone 的 local 后端
+	provider, err := factory.New(context.Background(), map[string]any{
+		"backend": "local",
+		"root":    dir,
+	})
+	if err != nil {
+		t.Fatalf("RcloneFactory.New returned error: %v", err)
+	}
+	if err := provider.Upload(context.Background(), "test.txt", strings.NewReader("rclone"), 6, nil); err != nil {
+		t.Fatalf("Upload via rclone factory returned error: %v", err)
+	}
+	reader, err := provider.Download(context.Background(), "test.txt")
+	if err != nil {
+		t.Fatalf("Download returned error: %v", err)
+	}
+	defer reader.Close()
+	content, _ := io.ReadAll(reader)
+	if string(content) != "rclone" {
+		t.Fatalf("expected 'rclone', got %q", string(content))
+	}
+	if err := provider.Delete(context.Background(), "test.txt"); err != nil {
+		t.Fatalf("Delete returned error: %v", err)
+	}
+}
+
+func TestRcloneFactoryRequiresBackend(t *testing.T) {
+	_, err := NewRcloneFactory().New(context.Background(), map[string]any{"root": "/tmp"})
+	if err == nil || !strings.Contains(err.Error(), "backend") {
+		t.Fatalf("expected backend required error, got %v", err)
+	}
+}
+
+func TestListBackends(t *testing.T) {
+	backends := ListBackends()
+	if len(backends) < 30 {
+		t.Fatalf("expected at least 30 backends, got %d", len(backends))
+	}
+	// 确认 sftp 在列表中
+	found := false
+	for _, b := range backends {
+		if b.Name == "sftp" {
+			found = true
+			if len(b.Options) == 0 {
+				t.Fatal("sftp backend should have options")
+			}
+			break
+		}
+	}
+	if !found {
+		t.Fatal("sftp backend not found in ListBackends()")
+	}
+}
+
+func TestProviderAbout(t *testing.T) {
+	factory := NewLocalDiskFactory()
+	provider, err := factory.New(context.Background(), map[string]any{"basePath": t.TempDir()})
+	if err != nil {
+		t.Fatalf("Factory.New returned error: %v", err)
+	}
+	// local 后端支持 About
+	rcloneProvider := provider.(*Provider)
+	usage, err := rcloneProvider.About(context.Background())
+	if err != nil {
+		t.Fatalf("About returned error: %v", err)
+	}
+	if usage.Total == nil || *usage.Total <= 0 {
+		t.Fatalf("expected non-zero total disk space, got %v", usage.Total)
+	}
+}
+
+func TestPathDir(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"BackupX/file/260308/backup.tar.gz", "BackupX/file/260308"},
+		{"backup.tar.gz", ""},
+		{"a/b", "a"},
+		{"", ""},
+	}
+	for _, tt := range tests {
+		got := pathDir(tt.input)
+		if got != tt.expected {
+			t.Errorf("pathDir(%q) = %q, want %q", tt.input, got, tt.expected)
+		}
+	}
+}

server/internal/storage/s3/provider.go

@@ -1,126 +0,0 @@
-package s3
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-	"time"
-
-	"backupx/server/internal/storage"
-	awscore "github.com/aws/aws-sdk-go-v2/aws"
-	"github.com/aws/aws-sdk-go-v2/credentials"
-	awss3 "github.com/aws/aws-sdk-go-v2/service/s3"
-)
-
-type client interface {
-	HeadBucket(context.Context, *awss3.HeadBucketInput, ...func(*awss3.Options)) (*awss3.HeadBucketOutput, error)
-	PutObject(context.Context, *awss3.PutObjectInput, ...func(*awss3.Options)) (*awss3.PutObjectOutput, error)
-	GetObject(context.Context, *awss3.GetObjectInput, ...func(*awss3.Options)) (*awss3.GetObjectOutput, error)
-	DeleteObject(context.Context, *awss3.DeleteObjectInput, ...func(*awss3.Options)) (*awss3.DeleteObjectOutput, error)
-	ListObjectsV2(context.Context, *awss3.ListObjectsV2Input, ...func(*awss3.Options)) (*awss3.ListObjectsV2Output, error)
-}
-
-type Provider struct {
-	client client
-	bucket string
-}
-
-type Factory struct {
-	newClient func(cfg storage.S3Config) client
-}
-
-func NewFactory() Factory {
-	return Factory{newClient: func(cfg storage.S3Config) client {
-		region := strings.TrimSpace(cfg.Region)
-		if region == "" {
-			region = "us-east-1"
-		}
-		awsConfig := awscore.Config{
-			Region:      region,
-			Credentials: credentials.NewStaticCredentialsProvider(cfg.AccessKeyID, cfg.SecretAccessKey, ""),
-		}
-		return awss3.NewFromConfig(awsConfig, func(options *awss3.Options) {
-			options.UsePathStyle = cfg.ForcePathStyle
-			if strings.TrimSpace(cfg.Endpoint) != "" {
-				options.BaseEndpoint = awscore.String(strings.TrimRight(cfg.Endpoint, "/"))
-			}
-		})
-	}}
-}
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeS3 }
-func (Factory) SensitiveFields() []string  { return []string{"accessKeyId", "secretAccessKey"} }
-
-func (f Factory) New(_ context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[storage.S3Config](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(cfg.Bucket) == "" {
-		return nil, fmt.Errorf("s3 bucket is required")
-	}
-	if strings.TrimSpace(cfg.AccessKeyID) == "" || strings.TrimSpace(cfg.SecretAccessKey) == "" {
-		return nil, fmt.Errorf("s3 credentials are required")
-	}
-	newClient := f.newClient
-	if newClient == nil {
-		factory := NewFactory()
-		newClient = factory.newClient
-	}
-	return &Provider{client: newClient(cfg), bucket: cfg.Bucket}, nil
-}
-
-func (p *Provider) Type() storage.ProviderType { return storage.ProviderTypeS3 }
-
-func (p *Provider) TestConnection(ctx context.Context) error {
-	_, err := p.client.HeadBucket(ctx, &awss3.HeadBucketInput{Bucket: awscore.String(p.bucket)})
-	if err != nil {
-		return fmt.Errorf("test s3 connection: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) Upload(ctx context.Context, objectKey string, reader io.Reader, _ int64, metadata map[string]string) error {
-	_, err := p.client.PutObject(ctx, &awss3.PutObjectInput{Bucket: awscore.String(p.bucket), Key: awscore.String(objectKey), Body: reader, Metadata: metadata})
-	if err != nil {
-		return fmt.Errorf("upload s3 object: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) Download(ctx context.Context, objectKey string) (io.ReadCloser, error) {
-	result, err := p.client.GetObject(ctx, &awss3.GetObjectInput{Bucket: awscore.String(p.bucket), Key: awscore.String(objectKey)})
-	if err != nil {
-		return nil, fmt.Errorf("download s3 object: %w", err)
-	}
-	return result.Body, nil
-}
-
-func (p *Provider) Delete(ctx context.Context, objectKey string) error {
-	_, err := p.client.DeleteObject(ctx, &awss3.DeleteObjectInput{Bucket: awscore.String(p.bucket), Key: awscore.String(objectKey)})
-	if err != nil {
-		return fmt.Errorf("delete s3 object: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) List(ctx context.Context, prefix string) ([]storage.ObjectInfo, error) {
-	result, err := p.client.ListObjectsV2(ctx, &awss3.ListObjectsV2Input{Bucket: awscore.String(p.bucket), Prefix: awscore.String(prefix)})
-	if err != nil {
-		return nil, fmt.Errorf("list s3 objects: %w", err)
-	}
-	items := make([]storage.ObjectInfo, 0, len(result.Contents))
-	for _, object := range result.Contents {
-		updatedAt := time.Time{}
-		if object.LastModified != nil {
-			updatedAt = object.LastModified.UTC()
-		}
-		size := int64(0)
-		if object.Size != nil {
-			size = *object.Size
-		}
-		items = append(items, storage.ObjectInfo{Key: awscore.ToString(object.Key), Size: size, UpdatedAt: updatedAt})
-	}
-	return items, nil
-}

server/internal/storage/s3/provider_test.go

@@ -1,78 +0,0 @@
-package s3
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"strings"
-	"testing"
-	"time"
-
-	"backupx/server/internal/storage"
-
-	awscore "github.com/aws/aws-sdk-go-v2/aws"
-	awss3 "github.com/aws/aws-sdk-go-v2/service/s3"
-	awss3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
-)
-
-type fakeClient struct{ data map[string]string }
-
-func (c *fakeClient) HeadBucket(context.Context, *awss3.HeadBucketInput, ...func(*awss3.Options)) (*awss3.HeadBucketOutput, error) {
-	return &awss3.HeadBucketOutput{}, nil
-}
-
-func (c *fakeClient) PutObject(_ context.Context, input *awss3.PutObjectInput, _ ...func(*awss3.Options)) (*awss3.PutObjectOutput, error) {
-	body, _ := io.ReadAll(input.Body)
-	c.data[awscore.ToString(input.Key)] = string(body)
-	return &awss3.PutObjectOutput{}, nil
-}
-
-func (c *fakeClient) GetObject(_ context.Context, input *awss3.GetObjectInput, _ ...func(*awss3.Options)) (*awss3.GetObjectOutput, error) {
-	return &awss3.GetObjectOutput{Body: io.NopCloser(strings.NewReader(c.data[awscore.ToString(input.Key)]))}, nil
-}
-
-func (c *fakeClient) DeleteObject(_ context.Context, input *awss3.DeleteObjectInput, _ ...func(*awss3.Options)) (*awss3.DeleteObjectOutput, error) {
-	delete(c.data, awscore.ToString(input.Key))
-	return &awss3.DeleteObjectOutput{}, nil
-}
-
-func (c *fakeClient) ListObjectsV2(_ context.Context, _ *awss3.ListObjectsV2Input, _ ...func(*awss3.Options)) (*awss3.ListObjectsV2Output, error) {
-	now := time.Now().UTC()
-	return &awss3.ListObjectsV2Output{Contents: []awss3types.Object{{Key: awscore.String("backup.tar.gz"), Size: awscore.Int64(10), LastModified: &now}}}, nil
-}
-
-func TestS3ProviderCRUD(t *testing.T) {
-	factory := Factory{newClient: func(cfg storage.S3Config) client {
-		return &fakeClient{data: make(map[string]string)}
-	}}
-	providerAny, err := factory.New(context.Background(), map[string]any{"bucket": "demo", "accessKeyId": "a", "secretAccessKey": "b"})
-	if err != nil {
-		t.Fatalf("Factory.New returned error: %v", err)
-	}
-	provider := providerAny.(*Provider)
-	if err := provider.TestConnection(context.Background()); err != nil {
-		t.Fatalf("TestConnection returned error: %v", err)
-	}
-	if err := provider.Upload(context.Background(), "backup.tar.gz", bytes.NewBufferString("payload"), 7, nil); err != nil {
-		t.Fatalf("Upload returned error: %v", err)
-	}
-	reader, err := provider.Download(context.Background(), "backup.tar.gz")
-	if err != nil {
-		t.Fatalf("Download returned error: %v", err)
-	}
-	defer reader.Close()
-	content, _ := io.ReadAll(reader)
-	if string(content) != "payload" {
-		t.Fatalf("unexpected content: %s", string(content))
-	}
-	items, err := provider.List(context.Background(), "backup")
-	if err != nil {
-		t.Fatalf("List returned error: %v", err)
-	}
-	if len(items) != 1 || items[0].Key != "backup.tar.gz" {
-		t.Fatalf("unexpected list result: %#v", items)
-	}
-	if err := provider.Delete(context.Background(), "backup.tar.gz"); err != nil {
-		t.Fatalf("Delete returned error: %v", err)
-	}
-}

server/internal/storage/s3provider/provider.go

@@ -1,9 +0,0 @@
-package s3provider
-
-import "backupx/server/internal/storage/s3"
-
-type Factory = s3.Factory
-
-func NewFactory() Factory {
-	return s3.NewFactory()
-}

server/internal/storage/tencent/factory.go

@@ -1,60 +0,0 @@
-// Package tencent provides a Tencent Cloud COS storage factory that delegates to the S3-compatible engine.
-// Tencent COS is fully S3-compatible; we auto-assemble the endpoint from region and appId.
-package tencent
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"backupx/server/internal/storage"
-	"backupx/server/internal/storage/s3"
-)
-
-// Config is the user-facing configuration for Tencent COS.
-type Config struct {
-	Region          string `json:"region"`
-	Bucket          string `json:"bucket"` // format: bucketname-appid
-	SecretID        string `json:"accessKeyId"`
-	SecretKey       string `json:"secretAccessKey"`
-	Endpoint        string `json:"endpoint"` // optional override
-}
-
-// Factory creates Tencent COS providers by composing the S3 engine.
-type Factory struct {
-	s3Factory s3.Factory
-}
-
-func NewFactory() Factory {
-	return Factory{s3Factory: s3.NewFactory()}
-}
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeTencentCOS }
-func (Factory) SensitiveFields() []string  { return []string{"accessKeyId", "secretAccessKey"} }
-
-func (f Factory) New(ctx context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[Config](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	endpoint := strings.TrimSpace(cfg.Endpoint)
-	if endpoint == "" {
-		region := strings.TrimSpace(cfg.Region)
-		if region == "" {
-			return nil, fmt.Errorf("tencent cos region is required")
-		}
-		// Tencent COS S3-compatible endpoint format
-		endpoint = fmt.Sprintf("https://cos.%s.myqcloud.com", region)
-	}
-
-	s3Config := map[string]any{
-		"endpoint":        endpoint,
-		"region":          cfg.Region,
-		"bucket":          cfg.Bucket,
-		"accessKeyId":     cfg.SecretID,
-		"secretAccessKey": cfg.SecretKey,
-		"forcePathStyle":  false, // COS uses virtual-hosted style
-	}
-	return f.s3Factory.New(ctx, s3Config)
-}

server/internal/storage/types.go

@@ -20,6 +20,7 @@ const (
 	ProviderTypeTencentCOS  ProviderType = "tencent_cos"
 	ProviderTypeQiniuKodo   ProviderType = "qiniu_kodo"
 	ProviderTypeFTP         ProviderType = "ftp"
+	ProviderTypeRclone      ProviderType = "rclone"
 )
 
 const (
@@ -52,6 +53,20 @@ type ProviderFactory interface {
 	Type() ProviderType
 }
 
+// StorageAbout 是可选能力接口，支持查询远端存储空间。
+// 并非所有后端都支持（如 S3/FTP 不支持），通过 type assertion 检测。
+type StorageAbout interface {
+	About(ctx context.Context) (*StorageUsageInfo, error)
+}
+
+// StorageUsageInfo 描述远端存储的空间使用情况。
+type StorageUsageInfo struct {
+	Total   *int64 `json:"total,omitempty"`   // 总空间（字节）
+	Used    *int64 `json:"used,omitempty"`    // 已用空间
+	Free    *int64 `json:"free,omitempty"`    // 可用空间
+	Objects *int64 `json:"objects,omitempty"` // 对象数量
+}
+
 func DecodeConfig[T any](raw map[string]any) (T, error) {
 	var cfg T
 	encoded, err := json.Marshal(raw)

server/internal/storage/webdav/provider.go

@@ -1,126 +0,0 @@
-package webdav
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"strings"
-
-	"backupx/server/internal/storage"
-	gowebdav "github.com/studio-b12/gowebdav"
-)
-
-type client interface {
-	ReadDir(path string) ([]os.FileInfo, error)
-	WriteStream(path string, stream io.Reader, perm os.FileMode) error
-	ReadStream(path string) (io.ReadCloser, error)
-	Remove(path string) error
-	MkdirAll(path string, perm os.FileMode) error
-	Stat(path string) (os.FileInfo, error)
-}
-
-type Provider struct {
-	client   client
-	basePath string
-}
-
-type Factory struct {
-	newClient func(cfg storage.WebDAVConfig) client
-}
-
-func NewFactory() Factory {
-	return Factory{newClient: func(cfg storage.WebDAVConfig) client {
-		return gowebdav.NewClient(strings.TrimRight(cfg.Endpoint, "/"), cfg.Username, cfg.Password)
-	}}
-}
-
-func (Factory) Type() storage.ProviderType { return storage.ProviderTypeWebDAV }
-func (Factory) SensitiveFields() []string  { return []string{"username", "password"} }
-
-func (f Factory) New(_ context.Context, rawConfig map[string]any) (storage.StorageProvider, error) {
-	cfg, err := storage.DecodeConfig[storage.WebDAVConfig](rawConfig)
-	if err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(cfg.Endpoint) == "" {
-		return nil, fmt.Errorf("webdav endpoint is required")
-	}
-	newClient := f.newClient
-	if newClient == nil {
-		factory := NewFactory()
-		newClient = factory.newClient
-	}
-	return &Provider{client: newClient(cfg), basePath: normalizeBasePath(cfg.BasePath)}, nil
-}
-
-func (p *Provider) Type() storage.ProviderType { return storage.ProviderTypeWebDAV }
-
-func (p *Provider) TestConnection(_ context.Context) error {
-	if err := p.client.MkdirAll(p.basePath, 0o755); err != nil {
-		return fmt.Errorf("ensure webdav base path: %w", err)
-	}
-	if _, err := p.client.Stat(p.basePath); err != nil {
-		return fmt.Errorf("stat webdav base path: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) Upload(_ context.Context, objectKey string, reader io.Reader, _ int64, _ map[string]string) error {
-	objectPath := p.resolvePath(objectKey)
-	if err := p.client.MkdirAll(path.Dir(objectPath), 0o755); err != nil {
-		return fmt.Errorf("create webdav directories: %w", err)
-	}
-	if err := p.client.WriteStream(objectPath, reader, 0o644); err != nil {
-		return fmt.Errorf("write webdav object: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) Download(_ context.Context, objectKey string) (io.ReadCloser, error) {
-	reader, err := p.client.ReadStream(p.resolvePath(objectKey))
-	if err != nil {
-		return nil, fmt.Errorf("read webdav object: %w", err)
-	}
-	return reader, nil
-}
-
-func (p *Provider) Delete(_ context.Context, objectKey string) error {
-	if err := p.client.Remove(p.resolvePath(objectKey)); err != nil {
-		return fmt.Errorf("delete webdav object: %w", err)
-	}
-	return nil
-}
-
-func (p *Provider) List(_ context.Context, prefix string) ([]storage.ObjectInfo, error) {
-	entries, err := p.client.ReadDir(p.basePath)
-	if err != nil {
-		return nil, fmt.Errorf("list webdav directory: %w", err)
-	}
-	items := make([]storage.ObjectInfo, 0, len(entries))
-	for _, entry := range entries {
-		if entry.IsDir() {
-			continue
-		}
-		key := strings.TrimPrefix(path.Join(strings.TrimPrefix(p.basePath, "/"), entry.Name()), "/")
-		if prefix != "" && !strings.HasPrefix(key, prefix) {
-			continue
-		}
-		items = append(items, storage.ObjectInfo{Key: key, Size: entry.Size(), UpdatedAt: entry.ModTime().UTC()})
-	}
-	return items, nil
-}
-
-func normalizeBasePath(value string) string {
-	clean := path.Clean("/" + strings.TrimSpace(value))
-	if clean == "." {
-		return "/"
-	}
-	return clean
-}
-
-func (p *Provider) resolvePath(objectKey string) string {
-	cleanKey := path.Clean("/" + strings.TrimSpace(objectKey))
-	return path.Clean(path.Join(p.basePath, cleanKey))
-}

server/internal/storage/webdav/provider_test.go

@@ -1,79 +0,0 @@
-package webdav
-
-import (
-	"context"
-	"io"
-	"os"
-	"strings"
-	"testing"
-	"time"
-
-	"backupx/server/internal/storage"
-)
-
-type fakeFileInfo struct {
-	name string
-	size int64
-	mod  time.Time
-	dir  bool
-}
-
-func (f fakeFileInfo) Name() string       { return f.name }
-func (f fakeFileInfo) Size() int64        { return f.size }
-func (f fakeFileInfo) Mode() os.FileMode  { return 0 }
-func (f fakeFileInfo) ModTime() time.Time { return f.mod }
-func (f fakeFileInfo) IsDir() bool        { return f.dir }
-func (f fakeFileInfo) Sys() any           { return nil }
-
-type fakeClient struct{ data map[string]string }
-
-func (c *fakeClient) ReadDir(_ string) ([]os.FileInfo, error) {
-	return []os.FileInfo{fakeFileInfo{name: "backup.tar.gz", size: int64(len(c.data["/storage/backup.tar.gz"])), mod: time.Now().UTC()}}, nil
-}
-func (c *fakeClient) WriteStream(path string, stream io.Reader, _ os.FileMode) error {
-	content, _ := io.ReadAll(stream)
-	c.data[path] = string(content)
-	return nil
-}
-func (c *fakeClient) ReadStream(path string) (io.ReadCloser, error) {
-	return io.NopCloser(strings.NewReader(c.data[path])), nil
-}
-func (c *fakeClient) Remove(path string) error               { delete(c.data, path); return nil }
-func (c *fakeClient) MkdirAll(_ string, _ os.FileMode) error { return nil }
-func (c *fakeClient) Stat(path string) (os.FileInfo, error) {
-	return fakeFileInfo{name: path, dir: true}, nil
-}
-
-func TestWebDAVProviderCRUD(t *testing.T) {
-	factory := Factory{newClient: func(storage.WebDAVConfig) client { return &fakeClient{data: make(map[string]string)} }}
-	providerAny, err := factory.New(context.Background(), map[string]any{"endpoint": "http://dav.example.com", "basePath": "/storage"})
-	if err != nil {
-		t.Fatalf("Factory.New returned error: %v", err)
-	}
-	provider := providerAny.(*Provider)
-	if err := provider.TestConnection(context.Background()); err != nil {
-		t.Fatalf("TestConnection returned error: %v", err)
-	}
-	if err := provider.Upload(context.Background(), "backup.tar.gz", strings.NewReader("payload"), 7, nil); err != nil {
-		t.Fatalf("Upload returned error: %v", err)
-	}
-	reader, err := provider.Download(context.Background(), "backup.tar.gz")
-	if err != nil {
-		t.Fatalf("Download returned error: %v", err)
-	}
-	defer reader.Close()
-	content, _ := io.ReadAll(reader)
-	if string(content) != "payload" {
-		t.Fatalf("unexpected content: %s", string(content))
-	}
-	items, err := provider.List(context.Background(), "storage")
-	if err != nil {
-		t.Fatalf("List returned error: %v", err)
-	}
-	if len(items) != 1 || items[0].Key != "storage/backup.tar.gz" {
-		t.Fatalf("unexpected list result: %#v", items)
-	}
-	if err := provider.Delete(context.Background(), "backup.tar.gz"); err != nil {
-		t.Fatalf("Delete returned error: %v", err)
-	}
-}

server/internal/storage/webdavprovider/provider.go

@@ -1,9 +0,0 @@
-package webdavprovider
-
-import "backupx/server/internal/storage/webdav"
-
-type Factory = webdav.Factory
-
-func NewFactory() Factory {
-	return webdav.NewFactory()
-}

web/src/components/CronInput/CronInput.tsx

@@ -1,196 +1,327 @@
-import { Input, Space, Switch, Tabs, Typography, Radio, Checkbox, Select } from '@arco-design/web-react'
-import { useEffect, useState } from 'react'
+import { Button, Divider, Input, Select, Space, Switch, Typography } from '@arco-design/web-react'
+import { useEffect, useMemo, useState } from 'react'
 
 export interface CronInputProps {
   value?: string
   onChange?: (value: string) => void
 }
 
-const DEFAULT_CRON = '* * * * *'
+const DEFAULT_CRON = '0 2 * * *'
 
-type CronPart = 'minute' | 'hour' | 'day' | 'month' | 'week'
-
-interface CronState {
-  minute: string
-  hour: string
-  day: string
-  month: string
-  week: string
-}
-
-function parseCron(expr: string): CronState {
-  const parts = (expr || DEFAULT_CRON).trim().split(/\s+/)
-  return {
-    minute: parts[0] || '*',
-    hour: parts[1] || '*',
-    day: parts[2] || '*',
-    month: parts[3] || '*',
-    week: parts[4] || '*',
-  }
-}
-
-function stringifyCron(state: CronState): string {
-  return `${state.minute} ${state.hour} ${state.day} ${state.month} ${state.week}`
-}
-
-function generateOptions(min: number, max: number) {
-  return Array.from({ length: max - min + 1 }, (_, i) => ({
-    label: String(i + min),
-    value: String(i + min),
-  }))
-}
-
-const MINUTES_OPTIONS = generateOptions(0, 59)
-const HOURS_OPTIONS = generateOptions(0, 23)
-const DAYS_OPTIONS = generateOptions(1, 31)
-const MONTHS_OPTIONS = generateOptions(1, 12)
-const WEEKS_OPTIONS = [
-  { label: '星期日', value: '0' },
-  { label: '星期一', value: '1' },
-  { label: '星期二', value: '2' },
-  { label: '星期三', value: '3' },
-  { label: '星期四', value: '4' },
-  { label: '星期五', value: '5' },
-  { label: '星期六', value: '6' },
+// 常用预设
+const PRESETS = [
+  { label: '每天 02:00', value: '0 2 * * *' },
+  { label: '每天 00:00', value: '0 0 * * *' },
+  { label: '每 6 小时', value: '0 */6 * * *' },
+  { label: '每 12 小时', value: '0 */12 * * *' },
+  { label: '每周日 03:00', value: '0 3 * * 0' },
+  { label: '每月 1 日 02:00', value: '0 2 1 * *' },
+  { label: '每 30 分钟', value: '*/30 * * * *' },
+  { label: '每小时整点', value: '0 * * * *' },
 ]
 
+const HOUR_OPTIONS = Array.from({ length: 24 }, (_, i) => ({
+  label: `${String(i).padStart(2, '0')} 时`,
+  value: String(i),
+}))
+
+const MINUTE_OPTIONS = Array.from({ length: 12 }, (_, i) => ({
+  label: `${String(i * 5).padStart(2, '0')} 分`,
+  value: String(i * 5),
+}))
+
+const WEEKDAY_OPTIONS = [
+  { label: '周一', value: '1' },
+  { label: '周二', value: '2' },
+  { label: '周三', value: '3' },
+  { label: '周四', value: '4' },
+  { label: '周五', value: '5' },
+  { label: '周六', value: '6' },
+  { label: '周日', value: '0' },
+]
+
+const DAY_OPTIONS = Array.from({ length: 31 }, (_, i) => ({
+  label: `${i + 1} 日`,
+  value: String(i + 1),
+}))
+
+type ScheduleMode = 'daily' | 'weekly' | 'monthly' | 'interval'
+
+// 将 cron 表达式转为自然语言中文描述
+function describeCron(expr: string): string {
+  const parts = expr.trim().split(/\s+/)
+  if (parts.length !== 5) return ''
+  const [minute, hour, day, _month, week] = parts
+
+  // 每 N 分钟
+  if (minute.includes('/') && hour === '*' && day === '*' && week === '*') {
+    return `每 ${minute.split('/')[1]} 分钟执行一次`
+  }
+  // 每 N 小时
+  if (minute !== '*' && hour.includes('/') && day === '*' && week === '*') {
+    return `每 ${hour.split('/')[1]} 小时执行一次（在第 ${minute} 分）`
+  }
+  // 每小时
+  if (minute !== '*' && hour === '*' && day === '*' && week === '*') {
+    return `每小时的第 ${minute} 分执行`
+  }
+
+  const hh = hour.padStart(2, '0')
+  const mm = minute.padStart(2, '0')
+  const time = `${hh}:${mm}`
+
+  // 每周某天
+  if (day === '*' && week !== '*') {
+    const weekNames: Record<string, string> = { '0': '日', '1': '一', '2': '二', '3': '三', '4': '四', '5': '五', '6': '六', '7': '日' }
+    const days = week.split(',').map((w) => `周${weekNames[w] || w}`).join('、')
+    return `每${days} ${time} 执行`
+  }
+  // 每月某日
+  if (day !== '*' && week === '*') {
+    return `每月 ${day} 日 ${time} 执行`
+  }
+  // 每天
+  if (day === '*' && week === '*' && hour !== '*' && !hour.includes('/')) {
+    return `每天 ${time} 执行`
+  }
+
+  return ''
+}
+
 export function CronInput({ value, onChange }: CronInputProps) {
-  const [internalValue, setInternalValue] = useState(value || DEFAULT_CRON)
+  const [cronExpr, setCronExpr] = useState(value || DEFAULT_CRON)
   const [isAdvanced, setIsAdvanced] = useState(false)
-  const [state, setState] = useState<CronState>(parseCron(internalValue))
+  const [showCustom, setShowCustom] = useState(false)
 
-  // Sync prop to internal state
+  // 自定义模式的状态
+  const [mode, setMode] = useState<ScheduleMode>('daily')
+  const [customHour, setCustomHour] = useState('2')
+  const [customMinute, setCustomMinute] = useState('0')
+  const [customWeekdays, setCustomWeekdays] = useState<string[]>(['0'])
+  const [customDay, setCustomDay] = useState('1')
+  const [customInterval, setCustomInterval] = useState('6')
+
+  // 从 prop 同步
   useEffect(() => {
-    if (value !== undefined && value !== internalValue) {
-      setInternalValue(value || DEFAULT_CRON)
-      if (!isAdvanced) {
-        setState(parseCron(value || DEFAULT_CRON))
-      }
+    if (value !== undefined && value !== cronExpr) {
+      setCronExpr(value || DEFAULT_CRON)
     }
-  }, [value, isAdvanced, internalValue])
+  }, [value])
 
-  const notifyChange = (nextValue: string) => {
-    setInternalValue(nextValue)
-    if (onChange) {
-      onChange(nextValue)
-    }
+  const description = useMemo(() => describeCron(cronExpr), [cronExpr])
+  const isPreset = PRESETS.some((p) => p.value === cronExpr)
+
+  const emit = (expr: string) => {
+    setCronExpr(expr)
+    onChange?.(expr)
   }
 
-  const handleStateChange = (part: CronPart, val: string) => {
-    const nextState = { ...state, [part]: val }
-    setState(nextState)
-    notifyChange(stringifyCron(nextState))
-  }
-
-  const renderPartTab = (
-    part: CronPart,
-    title: string,
-    options: { label: string; value: string }[],
-    allowAnyVal = '*',
+  // 从自定义选择器构建 cron
+  const buildCustomCron = (
+    m: ScheduleMode,
+    h: string,
+    min: string,
+    weekdays: string[],
+    day: string,
+    interval: string,
   ) => {
-    const currentVal = state[part]
-    const isAny = currentVal === allowAnyVal || currentVal === '*' || currentVal === '?'
-    const isSpecific = !isAny && !currentVal.includes('/') && !currentVal.includes('-')
-    
-    // For simplicity in this visual editor, we only support "every" (*) and "specific values" (1,2,3).
-    const type = isAny ? 'any' : 'specific'
-    const specificValues = isSpecific ? currentVal.split(',') : []
+    switch (m) {
+      case 'daily':
+        return `${min} ${h} * * *`
+      case 'weekly':
+        return `${min} ${h} * * ${weekdays.sort().join(',') || '0'}`
+      case 'monthly':
+        return `${min} ${h} ${day} * *`
+      case 'interval':
+        return `0 */${interval} * * *`
+      default:
+        return DEFAULT_CRON
+    }
+  }
 
-    return (
-      <div style={{ padding: '16px 0' }}>
-        <Radio.Group
-          direction="vertical"
-          value={type}
-          onChange={(val) => {
-            if (val === 'any') {
-              handleStateChange(part, allowAnyVal)
-            } else {
-              handleStateChange(part, options[0].value) // Default to first valid item
-            }
-          }}
-        >
-          <Radio value="any">
-            <Typography.Text>通配 ({allowAnyVal}) - 任意{title}</Typography.Text>
-          </Radio>
-          <Radio value="specific">
-            <Typography.Text>指定{title}</Typography.Text>
-          </Radio>
-        </Radio.Group>
+  const handleCustomChange = (updates: {
+    mode?: ScheduleMode
+    hour?: string
+    minute?: string
+    weekdays?: string[]
+    day?: string
+    interval?: string
+  }) => {
+    const m = updates.mode ?? mode
+    const h = updates.hour ?? customHour
+    const min = updates.minute ?? customMinute
+    const w = updates.weekdays ?? customWeekdays
+    const d = updates.day ?? customDay
+    const iv = updates.interval ?? customInterval
 
-        {type === 'specific' && (
-          <div style={{ paddingLeft: 24, marginTop: 12 }}>
-            <Select
-              mode="multiple"
-              placeholder={`请选择${title}`}
-              value={specificValues}
-              options={options}
-              onChange={(vals: string[]) => {
-                if (vals.length === 0) {
-                  handleStateChange(part, allowAnyVal)
-                } else {
-                  // Sort numerically to keep things neat
-                  const sorted = [...vals].sort((a, b) => Number(a) - Number(b))
-                  handleStateChange(part, sorted.join(','))
-                }
-              }}
-              style={{ width: '100%', maxWidth: 400 }}
-              allowClear
-            />
-          </div>
-        )}
-      </div>
-    )
+    if (updates.mode !== undefined) setMode(m)
+    if (updates.hour !== undefined) setCustomHour(h)
+    if (updates.minute !== undefined) setCustomMinute(min)
+    if (updates.weekdays !== undefined) setCustomWeekdays(w)
+    if (updates.day !== undefined) setCustomDay(d)
+    if (updates.interval !== undefined) setCustomInterval(iv)
+
+    emit(buildCustomCron(m, h, min, w, d, iv))
   }
 
   return (
-    <div className="cron-input-container">
-      <div style={{ marginBottom: 12, display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
-        <Input
-          value={internalValue}
-          onChange={(val) => {
-            setInternalValue(val)
-            if (isAdvanced && onChange) {
-              onChange(val)
-            }
-          }}
-          readOnly={!isAdvanced}
-          style={{ width: 240, fontFamily: 'monospace' }}
-          placeholder="* * * * *"
-        />
-        <Space>
-          <Typography.Text type="secondary">高级模式 (手动输入)</Typography.Text>
-          <Switch
-            checked={isAdvanced}
-            onChange={(checked) => {
-              setIsAdvanced(checked)
-              if (!checked) {
-                // When switching back to visual, parse the current raw value
-                setState(parseCron(internalValue))
-                notifyChange(stringifyCron(parseCron(internalValue)))
-              }
+    <div>
+      {/* 预设按钮 */}
+      <Space wrap size="small" style={{ marginBottom: 12 }}>
+        {PRESETS.map((preset) => (
+          <Button
+            key={preset.value}
+            size="small"
+            type={cronExpr === preset.value ? 'primary' : 'secondary'}
+            onClick={() => {
+              emit(preset.value)
+              setShowCustom(false)
+              setIsAdvanced(false)
             }}
-          />
-        </Space>
+          >
+            {preset.label}
+          </Button>
+        ))}
+        <Button
+          size="small"
+          type={!isPreset && !isAdvanced ? 'primary' : 'secondary'}
+          onClick={() => {
+            setShowCustom(true)
+            setIsAdvanced(false)
+          }}
+        >
+          自定义...
+        </Button>
+      </Space>
+
+      {/* 中文描述 + cron 表达式 */}
+      <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 8 }}>
+        <Input
+          value={cronExpr}
+          readOnly={!isAdvanced}
+          style={{ width: 180, fontFamily: 'monospace', fontSize: 13 }}
+          placeholder="0 2 * * *"
+          onChange={(val) => {
+            if (isAdvanced) emit(val)
+          }}
+        />
+        {description && (
+          <Typography.Text type="secondary">{description}</Typography.Text>
+        )}
+        <div style={{ marginLeft: 'auto' }}>
+          <Space size="mini">
+            <Typography.Text type="secondary" style={{ fontSize: 12 }}>手动输入</Typography.Text>
+            <Switch
+              size="small"
+              checked={isAdvanced}
+              onChange={(checked) => {
+                setIsAdvanced(checked)
+                setShowCustom(false)
+                if (!checked) {
+                  setCronExpr(cronExpr)
+                }
+              }}
+            />
+          </Space>
+        </div>
       </div>
 
-      {!isAdvanced && (
-        <Tabs type="card-gutter" size="small">
-          <Tabs.TabPane key="minute" title="分钟">
-            {renderPartTab('minute', '分钟', MINUTES_OPTIONS, '*')}
-          </Tabs.TabPane>
-          <Tabs.TabPane key="hour" title="小时">
-            {renderPartTab('hour', '小时', HOURS_OPTIONS, '*')}
-          </Tabs.TabPane>
-          <Tabs.TabPane key="day" title="日">
-            {renderPartTab('day', '日', DAYS_OPTIONS, '*')}
-          </Tabs.TabPane>
-          <Tabs.TabPane key="month" title="月">
-            {renderPartTab('month', '月', MONTHS_OPTIONS, '*')}
-          </Tabs.TabPane>
-          <Tabs.TabPane key="week" title="周">
-            {renderPartTab('week', '周', WEEKS_OPTIONS, '*')}
-          </Tabs.TabPane>
-        </Tabs>
+      {/* 自定义选择器 */}
+      {showCustom && !isAdvanced && (
+        <div style={{ padding: '12px 16px', background: 'var(--color-fill-1)', borderRadius: 6 }}>
+          <Space size="large" style={{ marginBottom: 12 }}>
+            <Button size="small" type={mode === 'daily' ? 'primary' : 'text'} onClick={() => handleCustomChange({ mode: 'daily' })}>
+              每天
+            </Button>
+            <Button size="small" type={mode === 'weekly' ? 'primary' : 'text'} onClick={() => handleCustomChange({ mode: 'weekly' })}>
+              每周
+            </Button>
+            <Button size="small" type={mode === 'monthly' ? 'primary' : 'text'} onClick={() => handleCustomChange({ mode: 'monthly' })}>
+              每月
+            </Button>
+            <Button size="small" type={mode === 'interval' ? 'primary' : 'text'} onClick={() => handleCustomChange({ mode: 'interval' })}>
+              间隔
+            </Button>
+          </Space>
+
+          {mode === 'interval' ? (
+            <Space align="center">
+              <Typography.Text>每</Typography.Text>
+              <Select
+                size="small"
+                value={customInterval}
+                style={{ width: 80 }}
+                options={[
+                  { label: '1', value: '1' },
+                  { label: '2', value: '2' },
+                  { label: '3', value: '3' },
+                  { label: '4', value: '4' },
+                  { label: '6', value: '6' },
+                  { label: '8', value: '8' },
+                  { label: '12', value: '12' },
+                ]}
+                onChange={(val) => handleCustomChange({ interval: val })}
+              />
+              <Typography.Text>小时执行一次</Typography.Text>
+            </Space>
+          ) : (
+            <>
+              {mode === 'weekly' && (
+                <div style={{ marginBottom: 8 }}>
+                  <Space wrap size="mini">
+                    {WEEKDAY_OPTIONS.map((opt) => (
+                      <Button
+                        key={opt.value}
+                        size="mini"
+                        type={customWeekdays.includes(opt.value) ? 'primary' : 'secondary'}
+                        onClick={() => {
+                          const next = customWeekdays.includes(opt.value)
+                            ? customWeekdays.filter((v) => v !== opt.value)
+                            : [...customWeekdays, opt.value]
+                          handleCustomChange({ weekdays: next.length > 0 ? next : [opt.value] })
+                        }}
+                      >
+                        {opt.label}
+                      </Button>
+                    ))}
+                  </Space>
+                </div>
+              )}
+              {mode === 'monthly' && (
+                <div style={{ marginBottom: 8 }}>
+                  <Space align="center">
+                    <Typography.Text>每月</Typography.Text>
+                    <Select
+                      size="small"
+                      value={customDay}
+                      style={{ width: 90 }}
+                      options={DAY_OPTIONS}
+                      onChange={(val) => handleCustomChange({ day: val })}
+                    />
+                  </Space>
+                </div>
+              )}
+              <Space align="center">
+                <Typography.Text>执行时间</Typography.Text>
+                <Select
+                  size="small"
+                  value={customHour}
+                  style={{ width: 90 }}
+                  options={HOUR_OPTIONS}
+                  onChange={(val) => handleCustomChange({ hour: val })}
+                />
+                <Typography.Text>:</Typography.Text>
+                <Select
+                  size="small"
+                  value={customMinute}
+                  style={{ width: 90 }}
+                  options={MINUTE_OPTIONS}
+                  onChange={(val) => handleCustomChange({ minute: val })}
+                />
+              </Space>
+            </>
+          )}
+        </div>
       )}
     </div>
   )

web/src/components/backup-records/BackupRecordLogDrawer.tsx

@@ -1,7 +1,7 @@
 import { Alert, Button, Descriptions, Drawer, Space, Spin, Tag, Typography } from '@arco-design/web-react'
 import { useEffect, useMemo, useState } from 'react'
 import { deleteBackupRecord, downloadBackupRecord, getBackupRecord, restoreBackupRecord, streamBackupRecordLogs } from '../../services/backup-records'
-import type { BackupLogEvent, BackupRecordDetail, BackupRecordStatus } from '../../types/backup-records'
+import type { BackupLogEvent, BackupRecordDetail, BackupRecordStatus, StorageUploadResultItem } from '../../types/backup-records'
 import { resolveErrorMessage } from '../../utils/error'
 import { formatBytes, formatDateTime, formatDuration } from '../../utils/format'
 
@@ -221,6 +221,19 @@ export function BackupRecordLogDrawer({ visible, recordId, onCancel, onChanged }
               删除
             </Button>
           </Space>
+          {record.storageUploadResults && record.storageUploadResults.length > 1 && (
+            <div>
+              <Typography.Title heading={6}>存储目标上传结果</Typography.Title>
+              <Descriptions
+                column={1}
+                data={record.storageUploadResults.map((r: StorageUploadResultItem) => ({
+                  label: r.storageTargetName,
+                  value: r.status === 'success' ? '上传成功' : `上传失败: ${r.error || '未知错误'}`,
+                }))}
+              />
+            </div>
+          )}
+
           <div>
             <Typography.Title heading={6}>执行日志</Typography.Title>
             <div className="log-viewer">{logText || '暂无日志输出'}</div>

web/src/components/backup-tasks/BackupTaskDetailDrawer.tsx

@@ -29,7 +29,7 @@ export function BackupTaskDetailDrawer({ visible, task, onCancel }: BackupTaskDe
             border
             data={[
               { label: 'Cron', value: task.cronExpr || '仅手动执行' },
-              { label: '存储目标', value: task.storageTargetName || task.storageTargetId },
+              { label: '存储目标', value: task.storageTargetNames?.length > 0 ? task.storageTargetNames.join('、') : (task.storageTargetName || task.storageTargetId) },
               { label: '保留天数', value: task.retentionDays },
               { label: '最大保留份数', value: task.maxBackups },
               { label: '压缩', value: task.compression },
@@ -40,7 +40,15 @@ export function BackupTaskDetailDrawer({ visible, task, onCancel }: BackupTaskDe
             ]}
           />
           {task.type === 'file' ? (
-            <Descriptions border column={1} data={[{ label: '源路径', value: task.sourcePath || '-' }, { label: '排除规则', value: task.excludePatterns.join(', ') || '-' }]} />
+            <Descriptions border column={1} data={[
+              {
+                label: '源路径',
+                value: task.sourcePaths?.length > 0
+                  ? task.sourcePaths.join('\n')
+                  : (task.sourcePath || '-'),
+              },
+              { label: '排除规则', value: task.excludePatterns.join(', ') || '-' },
+            ]} />
           ) : null}
           {task.type === 'sqlite' ? <Descriptions border column={1} data={[{ label: 'SQLite 路径', value: task.dbPath || '-' }]} /> : null}
           {task.type === 'mysql' || task.type === 'postgresql' ? (

web/src/components/backup-tasks/BackupTaskFormDrawer.tsx

@@ -1,8 +1,13 @@
-import { Alert, Button, Divider, Drawer, Input, InputNumber, Select, Space, Steps, Switch, Typography } from '@arco-design/web-react'
+import { Alert, Button, Divider, Drawer, Input, InputNumber, Select, Space, Steps, Switch, Typography, Grid } from '@arco-design/web-react'
+import { IconDelete, IconPlus } from '@arco-design/web-react/icon'
 import { useEffect, useMemo, useState } from 'react'
 import { CronInput } from '../CronInput'
-import type { StorageTargetSummary } from '../../types/storage-targets'
+import type { StorageTargetDetail, StorageTargetPayload, StorageTargetSummary } from '../../types/storage-targets'
+import type { StorageConnectionTestResult } from '../../types/storage-targets'
 import type { BackupTaskDetail, BackupTaskPayload, BackupTaskType } from '../../types/backup-tasks'
+import { DatabasePicker } from '../common/DatabasePicker'
+import { DirectoryPicker } from '../common/DirectoryPicker'
+import { StorageTargetFormDrawer } from '../storage-targets/StorageTargetFormDrawer'
 import {
   backupCompressionOptions,
   backupTaskTypeOptions,
@@ -17,17 +22,24 @@ interface BackupTaskFormDrawerProps {
   loading: boolean
   initialValue: BackupTaskDetail | null
   storageTargets: StorageTargetSummary[]
+  localNodeId?: number
   onCancel: () => void
   onSubmit: (value: BackupTaskPayload, taskId?: number) => Promise<void>
+  onCreateStorageTarget?: (value: StorageTargetPayload) => Promise<StorageTargetDetail>
+  onTestStorageTarget?: (value: StorageTargetPayload, targetId?: number) => Promise<StorageConnectionTestResult>
+  onGoogleDriveAuth?: (value: StorageTargetPayload, targetId?: number) => Promise<void>
+  onStorageTargetCreated?: () => Promise<void>
 }
 
-function createEmptyDraft(storageTargetId?: number): BackupTaskPayload {
+function createEmptyDraft(storageTargets?: StorageTargetSummary[]): BackupTaskPayload {
+  const defaultIds = storageTargets && storageTargets.length > 0 ? [storageTargets[0].id] : []
   return {
     name: '',
     type: 'file',
     enabled: true,
     cronExpr: '',
     sourcePath: '',
+    sourcePaths: [''],
     excludePatterns: [],
     dbHost: '',
     dbPort: 0,
@@ -35,7 +47,8 @@ function createEmptyDraft(storageTargetId?: number): BackupTaskPayload {
     dbPassword: '',
     dbName: '',
     dbPath: '',
-    storageTargetId: storageTargetId ?? 0,
+    storageTargetId: defaultIds[0] ?? 0,
+    storageTargetIds: defaultIds,
     nodeId: 0,
     tags: '',
     retentionDays: 30,
@@ -45,11 +58,14 @@ function createEmptyDraft(storageTargetId?: number): BackupTaskPayload {
   }
 }
 
-export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTargets, onCancel, onSubmit }: BackupTaskFormDrawerProps) {
+export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTargets, localNodeId, onCancel, onSubmit, onCreateStorageTarget, onTestStorageTarget, onGoogleDriveAuth, onStorageTargetCreated }: BackupTaskFormDrawerProps) {
   const [draft, setDraft] = useState<BackupTaskPayload>(createEmptyDraft())
   const [excludePatternsText, setExcludePatternsText] = useState('')
   const [currentStep, setCurrentStep] = useState(0)
   const [error, setError] = useState('')
+  const [quickCreateVisible, setQuickCreateVisible] = useState(false)
+  const [quickCreateLoading, setQuickCreateLoading] = useState(false)
+  const [quickCreateTesting, setQuickCreateTesting] = useState(false)
 
   useEffect(() => {
     if (!visible) {
@@ -57,7 +73,7 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
     }
 
     if (!initialValue) {
-      const nextDraft = createEmptyDraft(storageTargets[0]?.id)
+      const nextDraft = createEmptyDraft(storageTargets)
       setDraft(nextDraft)
       setExcludePatternsText('')
       setCurrentStep(0)
@@ -65,12 +81,24 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
       return
     }
 
+    const editTargetIds = initialValue.storageTargetIds?.length > 0
+      ? initialValue.storageTargetIds
+      : initialValue.storageTargetId > 0
+        ? [initialValue.storageTargetId]
+        : []
+    // 编辑时：sourcePaths 优先，为空回退 sourcePath
+    const editSourcePaths = initialValue.sourcePaths?.length > 0
+      ? initialValue.sourcePaths
+      : initialValue.sourcePath
+        ? [initialValue.sourcePath]
+        : ['']
     setDraft({
       name: initialValue.name,
       type: initialValue.type,
       enabled: initialValue.enabled,
       cronExpr: initialValue.cronExpr,
       sourcePath: initialValue.sourcePath,
+      sourcePaths: editSourcePaths,
       excludePatterns: initialValue.excludePatterns,
       dbHost: initialValue.dbHost,
       dbPort: initialValue.dbPort,
@@ -78,7 +106,8 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
       dbPassword: '',
       dbName: initialValue.dbName,
       dbPath: initialValue.dbPath,
-      storageTargetId: initialValue.storageTargetId,
+      storageTargetId: editTargetIds[0] ?? 0,
+      storageTargetIds: editTargetIds,
       nodeId: (initialValue as any).nodeId ?? 0,
       tags: (initialValue as any).tags ?? '',
       retentionDays: initialValue.retentionDays,
@@ -92,7 +121,17 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
   }, [initialValue, storageTargets, visible])
 
   const storageTargetOptions = useMemo(
-    () => storageTargets.map((item) => ({ label: item.name, value: item.id, disabled: !item.enabled })),
+    () => {
+      const sorted = [...storageTargets].sort((a, b) => {
+        if (a.starred !== b.starred) return a.starred ? -1 : 1
+        return 0
+      })
+      return sorted.map((item) => ({
+        label: item.starred ? `★ ${item.name}` : item.name,
+        value: item.id,
+        disabled: !item.enabled,
+      }))
+    },
     [storageTargets],
   )
 
@@ -105,6 +144,7 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
       ...current,
       type: value,
       sourcePath: value === 'file' ? current.sourcePath : '',
+      sourcePaths: value === 'file' ? current.sourcePaths : [''],
       excludePatterns: value === 'file' ? current.excludePatterns : [],
       dbHost: value === 'mysql' || value === 'postgresql' || value === 'saphana' ? current.dbHost : '',
       dbPort: value === 'mysql' || value === 'postgresql' || value === 'saphana' ? current.dbPort || getDefaultPort(value) : 0,
@@ -122,8 +162,8 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
     if (!value.name.trim()) {
       return '请输入任务名称'
     }
-    if (!value.storageTargetId) {
-      return '请选择存储目标'
+    if (!value.storageTargetIds || value.storageTargetIds.length === 0) {
+      return '请选择至少一个存储目标'
     }
     if (value.cronExpr.trim() && value.cronExpr.trim().split(/\s+/).length < 5) {
       return 'Cron 表达式至少需要 5 段'
@@ -134,8 +174,11 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
     if (value.maxBackups < 0) {
       return '最大保留份数不能小于 0'
     }
-    if (isFileBackupTask(value.type) && !value.sourcePath.trim()) {
-      return '请输入源路径'
+    if (isFileBackupTask(value.type)) {
+      const validPaths = (value.sourcePaths ?? []).filter((p) => p.trim())
+      if (validPaths.length === 0 && !value.sourcePath.trim()) {
+        return '请输入至少一个源路径'
+      }
     }
     if (isSQLiteBackupTask(value.type) && !value.dbPath.trim()) {
       return '请输入 SQLite 数据库路径'
@@ -161,8 +204,11 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
   }
 
   async function handleSubmit() {
+    const validSourcePaths = (draft.sourcePaths ?? []).filter((p) => p.trim())
     const nextValue: BackupTaskPayload = {
       ...draft,
+      sourcePaths: validSourcePaths,
+      sourcePath: validSourcePaths[0] ?? draft.sourcePath,
       excludePatterns: excludePatternsText
         .split('\n')
         .map((item) => item.trim())
@@ -203,14 +249,65 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
     )
   }
 
+  function updateSourcePath(index: number, value: string) {
+    setDraft((current) => {
+      const next = [...(current.sourcePaths ?? [''])]
+      next[index] = value
+      return { ...current, sourcePaths: next, sourcePath: next[0] ?? '' }
+    })
+  }
+
+  function addSourcePath() {
+    setDraft((current) => ({
+      ...current,
+      sourcePaths: [...(current.sourcePaths ?? ['']), ''],
+    }))
+  }
+
+  function removeSourcePath(index: number) {
+    setDraft((current) => {
+      const next = [...(current.sourcePaths ?? [''])]
+      next.splice(index, 1)
+      if (next.length === 0) next.push('')
+      return { ...current, sourcePaths: next, sourcePath: next[0] ?? '' }
+    })
+  }
+
   function renderSourceStep() {
+    const paths = draft.sourcePaths?.length > 0 ? draft.sourcePaths : ['']
     return (
       <Space direction="vertical" size="large" style={{ width: '100%' }}>
         {isFileBackupTask(draft.type) ? (
           <>
             <div>
               <Typography.Text>源路径</Typography.Text>
-              <Input value={draft.sourcePath} placeholder="例如：/var/www/html" onChange={(value) => updateDraft({ sourcePath: value })} />
+              <Space direction="vertical" size="medium" style={{ width: '100%' }}>
+                {paths.map((p, index) => (
+                  <Grid.Row key={index} gutter={8} align="center">
+                    <Grid.Col flex="auto">
+                      <DirectoryPicker
+                        value={p}
+                        placeholder={`源路径 ${index + 1}，例如：/var/www/html`}
+                        mode="directory"
+                        nodeId={localNodeId}
+                        onChange={(value) => updateSourcePath(index, value)}
+                      />
+                    </Grid.Col>
+                    <Grid.Col flex="none">
+                      <Button
+                        type="text"
+                        icon={<IconDelete />}
+                        status="danger"
+                        disabled={paths.length <= 1}
+                        onClick={() => removeSourcePath(index)}
+                      />
+                    </Grid.Col>
+                  </Grid.Row>
+                ))}
+                <Button type="dashed" long icon={<IconPlus />} onClick={addSourcePath}>
+                  添加源路径
+                </Button>
+              </Space>
             </div>
             <div>
               <Typography.Text>排除规则</Typography.Text>
@@ -227,7 +324,13 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
         {isSQLiteBackupTask(draft.type) ? (
           <div>
             <Typography.Text>SQLite 数据库文件</Typography.Text>
-            <Input value={draft.dbPath} placeholder="例如：/data/app.db" onChange={(value) => updateDraft({ dbPath: value })} />
+            <DirectoryPicker
+              value={draft.dbPath}
+              placeholder="例如：/data/app.db"
+              mode="file"
+              nodeId={localNodeId}
+              onChange={(value) => updateDraft({ dbPath: value })}
+            />
           </div>
         ) : null}
 
@@ -251,7 +354,19 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
             </div>
             <div>
               <Typography.Text>数据库名称</Typography.Text>
-              <Input value={draft.dbName} placeholder="例如：app_prod" onChange={(value) => updateDraft({ dbName: value })} />
+              {(draft.type === 'mysql' || draft.type === 'postgresql') ? (
+                <DatabasePicker
+                  dbType={draft.type}
+                  dbHost={draft.dbHost}
+                  dbPort={draft.dbPort}
+                  dbUser={draft.dbUser}
+                  dbPassword={draft.dbPassword}
+                  value={draft.dbName}
+                  onChange={(value) => updateDraft({ dbName: value })}
+                />
+              ) : (
+                <Input value={draft.dbName} placeholder="例如：app_prod" onChange={(value) => updateDraft({ dbName: value })} />
+              )}
             </div>
           </>
         ) : null}
@@ -259,12 +374,53 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
     )
   }
 
+  async function handleQuickCreateSubmit(value: StorageTargetPayload) {
+    if (!onCreateStorageTarget) return
+    setQuickCreateLoading(true)
+    try {
+      const created = await onCreateStorageTarget(value)
+      setQuickCreateVisible(false)
+      if (onStorageTargetCreated) {
+        await onStorageTargetCreated()
+      }
+      const currentIds = draft.storageTargetIds ?? []
+      const nextIds = [...currentIds, created.id]
+      updateDraft({ storageTargetIds: nextIds, storageTargetId: nextIds[0] ?? 0 })
+    } finally {
+      setQuickCreateLoading(false)
+    }
+  }
+
+  async function handleQuickCreateTest(value: StorageTargetPayload, targetId?: number): Promise<StorageConnectionTestResult> {
+    if (!onTestStorageTarget) return { success: false, message: '测试不可用' }
+    setQuickCreateTesting(true)
+    try {
+      return await onTestStorageTarget(value, targetId)
+    } finally {
+      setQuickCreateTesting(false)
+    }
+  }
+
   function renderPolicyStep() {
     return (
       <Space direction="vertical" size="large" style={{ width: '100%' }}>
         <div>
           <Typography.Text>存储目标</Typography.Text>
-          <Select value={draft.storageTargetId || undefined} placeholder="请选择存储目标" options={storageTargetOptions} onChange={(value) => updateDraft({ storageTargetId: Number(value) })} />
+          <Space style={{ width: '100%' }} align="start">
+            <Select
+              style={{ flex: 1 }}
+              mode="multiple"
+              value={draft.storageTargetIds?.length > 0 ? draft.storageTargetIds : undefined}
+              placeholder="请选择存储目标（可多选）"
+              options={storageTargetOptions}
+              onChange={(values: number[]) => updateDraft({ storageTargetIds: values, storageTargetId: values[0] ?? 0 })}
+            />
+            {onCreateStorageTarget && (
+              <Button type="outline" size="small" onClick={() => setQuickCreateVisible(true)}>
+                + 快速新建
+              </Button>
+            )}
+          </Space>
         </div>
         <div>
           <Typography.Text>压缩策略</Typography.Text>
@@ -320,6 +476,19 @@ export function BackupTaskFormDrawer({ visible, loading, initialValue, storageTa
           )}
         </Space>
       </Space>
+
+      {onCreateStorageTarget && (
+        <StorageTargetFormDrawer
+          visible={quickCreateVisible}
+          loading={quickCreateLoading}
+          testing={quickCreateTesting}
+          initialValue={null}
+          onCancel={() => setQuickCreateVisible(false)}
+          onSubmit={handleQuickCreateSubmit}
+          onTest={handleQuickCreateTest}
+          onGoogleDriveAuth={onGoogleDriveAuth ?? (async () => {})}
+        />
+      )}
     </Drawer>
   )
 }

web/src/components/common/DatabasePicker.tsx

@@ -0,0 +1,120 @@
+import { Button, Checkbox, Input, Message, Space, Spin, Typography } from '@arco-design/web-react'
+import { useState } from 'react'
+import { discoverDatabases } from '../../services/database'
+
+interface DatabasePickerProps {
+  dbType: 'mysql' | 'postgresql'
+  dbHost: string
+  dbPort: number
+  dbUser: string
+  dbPassword: string
+  value: string
+  onChange: (value: string) => void
+}
+
+export function DatabasePicker({ dbType, dbHost, dbPort, dbUser, dbPassword, value, onChange }: DatabasePickerProps) {
+  const [databases, setDatabases] = useState<string[]>([])
+  const [loading, setLoading] = useState(false)
+  const [discovered, setDiscovered] = useState(false)
+  const [error, setError] = useState('')
+
+  const selectedDbs = value
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+
+  const canDiscover = dbHost.trim() && dbPort > 0 && dbUser.trim() && dbPassword.trim()
+
+  async function handleDiscover() {
+    setLoading(true)
+    setError('')
+    try {
+      const result = await discoverDatabases({
+        type: dbType,
+        host: dbHost.trim(),
+        port: dbPort,
+        user: dbUser.trim(),
+        password: dbPassword.trim(),
+      })
+      setDatabases(result)
+      setDiscovered(true)
+      if (result.length === 0) {
+        setError('未发现用户数据库')
+      }
+    } catch (discoverError: any) {
+      const msg = discoverError?.response?.data?.message ?? discoverError?.message ?? '发现数据库失败'
+      setError(msg)
+      Message.error(msg)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  function handleToggle(db: string, checked: boolean) {
+    let next: string[]
+    if (checked) {
+      next = [...selectedDbs, db]
+    } else {
+      next = selectedDbs.filter((d) => d !== db)
+    }
+    onChange(next.join(','))
+  }
+
+  function handleSelectAll() {
+    onChange(databases.join(','))
+  }
+
+  function handleDeselectAll() {
+    onChange('')
+  }
+
+  return (
+    <Space direction="vertical" size="medium" style={{ width: '100%' }}>
+      <Space style={{ width: '100%' }}>
+        <Input
+          style={{ flex: 1 }}
+          value={value}
+          placeholder="数据库名称（多个以逗号分隔）"
+          onChange={onChange}
+        />
+        <Button
+          type="outline"
+          size="small"
+          loading={loading}
+          disabled={!canDiscover}
+          onClick={handleDiscover}
+        >
+          发现数据库
+        </Button>
+      </Space>
+
+      {error && <Typography.Text type="error">{error}</Typography.Text>}
+
+      {loading && <Spin size={16} />}
+
+      {discovered && databases.length > 0 && (
+        <div style={{ border: '1px solid var(--color-border-2)', borderRadius: 4, padding: '8px 12px', maxHeight: 200, overflow: 'auto' }}>
+          <Space size="mini" style={{ marginBottom: 8 }}>
+            <Button type="text" size="mini" onClick={handleSelectAll}>
+              全选
+            </Button>
+            <Button type="text" size="mini" onClick={handleDeselectAll}>
+              清空
+            </Button>
+          </Space>
+          <Space direction="vertical" size={4}>
+            {databases.map((db) => (
+              <Checkbox
+                key={db}
+                checked={selectedDbs.includes(db)}
+                onChange={(checked) => handleToggle(db, checked)}
+              >
+                {db}
+              </Checkbox>
+            ))}
+          </Space>
+        </div>
+      )}
+    </Space>
+  )
+}

web/src/components/common/DirectoryPicker.tsx

@@ -0,0 +1,155 @@
+import { Button, Input, Message, Modal, Space, Spin, Tree, Typography } from '@arco-design/web-react'
+import { IconFolder, IconFile } from '@arco-design/web-react/icon'
+import { useCallback, useState } from 'react'
+import { listNodeDirectory } from '../../services/nodes'
+import type { DirEntry } from '../../types/nodes'
+
+interface DirectoryPickerProps {
+  value: string
+  onChange: (path: string) => void
+  placeholder?: string
+  mode?: 'directory' | 'file'
+  nodeId?: number
+}
+
+interface TreeNodeData {
+  key: string
+  title: string
+  icon?: React.ReactNode
+  isLeaf: boolean
+  children?: TreeNodeData[]
+  loaded?: boolean
+}
+
+function entriesToTreeNodes(entries: DirEntry[], mode: 'directory' | 'file'): TreeNodeData[] {
+  return entries
+    .filter((entry) => mode === 'file' || entry.isDir)
+    .map((entry) => ({
+      key: entry.path,
+      title: entry.name,
+      icon: entry.isDir ? <IconFolder /> : <IconFile />,
+      isLeaf: !entry.isDir,
+    }))
+}
+
+export function DirectoryPicker({ value, onChange, placeholder, mode = 'directory', nodeId }: DirectoryPickerProps) {
+  const [modalVisible, setModalVisible] = useState(false)
+  const [treeData, setTreeData] = useState<TreeNodeData[]>([])
+  const [loading, setLoading] = useState(false)
+  const [selectedPath, setSelectedPath] = useState('')
+
+  const loadDirectory = useCallback(
+    async (path: string): Promise<TreeNodeData[]> => {
+      if (nodeId === undefined) return []
+      try {
+        const entries = await listNodeDirectory(nodeId, path)
+        return entriesToTreeNodes(entries, mode)
+      } catch {
+        Message.error(`加载目录失败: ${path}`)
+        return []
+      }
+    },
+    [nodeId, mode],
+  )
+
+  async function handleOpen() {
+    setModalVisible(true)
+    setSelectedPath(value || '')
+    setLoading(true)
+    try {
+      const rootNodes = await loadDirectory('/')
+      setTreeData(rootNodes)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  // ArcoDesign Tree loadMore: node.props.dataRef 指向 treeData 中的原始对象
+  async function handleLoadMore(treeNode: any): Promise<void> {
+    const nodeKey = treeNode.props.dataRef?.key ?? treeNode.props._key
+    if (!nodeKey) return
+
+    const children = await loadDirectory(nodeKey)
+
+    setTreeData((prev) => {
+      function insertChildren(nodes: TreeNodeData[]): TreeNodeData[] {
+        return nodes.map((n) => {
+          if (n.key === nodeKey) {
+            return { ...n, children, loaded: true }
+          }
+          if (n.children && n.children.length > 0) {
+            return { ...n, children: insertChildren(n.children) }
+          }
+          return n
+        })
+      }
+      return insertChildren(prev)
+    })
+  }
+
+  function handleConfirm() {
+    if (selectedPath) {
+      onChange(selectedPath)
+    }
+    setModalVisible(false)
+  }
+
+  // 没有 nodeId 时退化为普通输入框
+  if (nodeId === undefined) {
+    return <Input value={value} placeholder={placeholder} onChange={onChange} />
+  }
+
+  return (
+    <>
+      <Space style={{ width: '100%' }}>
+        <Input style={{ flex: 1 }} value={value} placeholder={placeholder} onChange={onChange} />
+        <Button type="outline" size="small" onClick={handleOpen}>
+          浏览
+        </Button>
+      </Space>
+
+      <Modal
+        title={mode === 'directory' ? '选择目录' : '选择文件'}
+        visible={modalVisible}
+        onCancel={() => setModalVisible(false)}
+        onOk={handleConfirm}
+        okText="选择"
+        cancelText="取消"
+        style={{ width: 560 }}
+        okButtonProps={{ disabled: !selectedPath }}
+        unmountOnExit
+      >
+        {selectedPath && (
+          <div style={{ padding: '8px 12px', marginBottom: 12, background: 'var(--color-fill-2)', borderRadius: 4 }}>
+            <Typography.Text copyable style={{ fontSize: 13 }}>
+              {selectedPath}
+            </Typography.Text>
+          </div>
+        )}
+        {loading ? (
+          <Spin style={{ display: 'block', textAlign: 'center', padding: 40 }} />
+        ) : treeData.length === 0 ? (
+          <Typography.Text type="secondary" style={{ display: 'block', textAlign: 'center', padding: 40 }}>
+            目录为空
+          </Typography.Text>
+        ) : (
+          <div style={{ maxHeight: 420, overflow: 'auto', border: '1px solid var(--color-border)', borderRadius: 4, padding: '4px 0' }}>
+            <Tree
+              blockNode
+              showLine
+              treeData={treeData as any}
+              selectedKeys={selectedPath ? [selectedPath] : []}
+              onSelect={(keys) => {
+                if (keys.length > 0) {
+                  setSelectedPath(keys[0] as string)
+                }
+              }}
+              loadMore={handleLoadMore}
+              icons={{ switcherIcon: <IconFolder style={{ fontSize: 14 }} /> }}
+            />
+          </div>
+        )}
+      </Modal>
+    </>
+  )
+}

web/src/components/storage-targets/StorageTargetFormDrawer.tsx

@@ -1,7 +1,8 @@
 import { Alert, Button, Divider, Drawer, Input, Select, Space, Switch, Typography } from '@arco-design/web-react'
 import { useEffect, useMemo, useState } from 'react'
-import { getStorageTargetFieldConfigs, getStorageTargetTypeLabel, storageTargetTypeOptions } from './field-config'
+import { getStorageTargetFieldConfigs, getStorageTargetTypeLabel, isBuiltinType, builtinTypeOptions } from './field-config'
 import type { StorageConnectionTestResult, StorageTargetDetail, StorageTargetPayload, StorageTargetType } from '../../types/storage-targets'
+import { listRcloneBackends, type RcloneBackendInfo } from '../../services/rclone'
 
 interface StorageTargetFormDrawerProps {
   visible: boolean
@@ -15,33 +16,29 @@ interface StorageTargetFormDrawerProps {
 }
 
 function createEmptyDraft(type: StorageTargetType = 'local_disk'): StorageTargetPayload {
-  return {
-    name: '',
-    type,
-    description: '',
-    enabled: true,
-    config: {},
-  }
+  return { name: '', type, description: '', enabled: true, config: {} }
 }
 
 export function StorageTargetFormDrawer({
-  visible,
-  loading,
-  testing,
-  initialValue,
-  onCancel,
-  onSubmit,
-  onTest,
-  onGoogleDriveAuth,
+  visible, loading, testing, initialValue, onCancel, onSubmit, onTest, onGoogleDriveAuth,
 }: StorageTargetFormDrawerProps) {
   const [draft, setDraft] = useState<StorageTargetPayload>(createEmptyDraft())
   const [error, setError] = useState('')
   const [testResult, setTestResult] = useState<StorageConnectionTestResult | null>(null)
+  const [rcloneBackends, setRcloneBackends] = useState<RcloneBackendInfo[]>([])
+  const [backendsLoaded, setBackendsLoaded] = useState(false)
+
+  // 加载 rclone 后端列表
+  useEffect(() => {
+    if (visible && !backendsLoaded) {
+      listRcloneBackends()
+        .then((data) => { setRcloneBackends(data); setBackendsLoaded(true) })
+        .catch(() => setBackendsLoaded(true))
+    }
+  }, [visible, backendsLoaded])
 
   useEffect(() => {
-    if (!visible) {
-      return
-    }
+    if (!visible) return
     if (!initialValue) {
       setDraft(createEmptyDraft())
       setError('')
@@ -59,97 +56,137 @@ export function StorageTargetFormDrawer({
     setTestResult(null)
   }, [initialValue, visible])
 
-  const fieldConfigs = useMemo(() => getStorageTargetFieldConfigs(draft.type), [draft.type])
+  // 合并类型选项：内置 + 全部 rclone 后端
+  const allTypeOptions = useMemo(() => {
+    const builtinValues = new Set(builtinTypeOptions.map((o) => o.value))
+    const rcloneOptions = rcloneBackends
+      .filter((b) => !builtinValues.has(b.name) && b.name !== 'local' && b.name !== 'rclone')
+      .map((b) => ({ label: `${b.name.toUpperCase()} — ${b.description}`, value: b.name }))
+    return [
+      ...builtinTypeOptions.map((o) => ({ ...o, label: o.label, value: o.value as string })),
+      ...rcloneOptions,
+    ]
+  }, [rcloneBackends])
+
+  // 当前类型是否为非内置（rclone 动态后端）
+  const isDynamicType = !isBuiltinType(draft.type)
+  const staticFields = isBuiltinType(draft.type) ? getStorageTargetFieldConfigs(draft.type) : []
+
+  // 当前 rclone 后端的动态字段
+  const dynamicBackend = useMemo(() => {
+    if (!isDynamicType) return null
+    return rcloneBackends.find((b) => b.name === draft.type) || null
+  }, [isDynamicType, draft.type, rcloneBackends])
 
   function updateConfig(key: string, value: string | boolean) {
-    setDraft((current) => ({
-      ...current,
-      config: {
-        ...current.config,
-        [key]: value,
-      },
-    }))
+    setDraft((c) => ({ ...c, config: { ...c.config, [key]: value } }))
   }
 
   function validate(value: StorageTargetPayload) {
-    if (!value.name.trim()) {
-      return '请输入存储目标名称'
-    }
-    for (const field of fieldConfigs) {
-      if (!field.required) {
-        continue
-      }
-      const currentValue = value.config[field.key]
-      if (field.type === 'switch') {
-        continue
-      }
-      if (typeof currentValue !== 'string' || !currentValue.trim()) {
-        return `请填写${field.label}`
+    if (!value.name.trim()) return '请输入存储目标名称'
+    if (!value.type.trim()) return '请选择存储类型'
+    if (isBuiltinType(value.type)) {
+      for (const field of staticFields) {
+        if (!field.required || field.type === 'switch') continue
+        const v = value.config[field.key]
+        if (typeof v !== 'string' || !v.trim()) return `请填写${field.label}`
       }
     }
     return ''
   }
 
   async function handleSubmit() {
-    const validationError = validate(draft)
-    if (validationError) {
-      setError(validationError)
-      return
-    }
-    setError('')
-    await onSubmit(draft, initialValue?.id)
+    const e = validate(draft); if (e) { setError(e); return }
+    setError(''); await onSubmit(draft, initialValue?.id)
   }
-
   async function handleTest() {
-    const validationError = validate(draft)
-    if (validationError) {
-      setError(validationError)
-      return
-    }
-    setError('')
-    const result = await onTest(draft, initialValue?.id)
-    setTestResult(result)
+    const e = validate(draft); if (e) { setError(e); return }
+    setError(''); setTestResult(await onTest(draft, initialValue?.id))
+  }
+  async function handleGoogleDriveAuth() {
+    const e = validate(draft); if (e) { setError(e); return }
+    setError(''); await onGoogleDriveAuth(draft, initialValue?.id)
   }
 
-  async function handleGoogleDriveAuth() {
-    const validationError = validate(draft)
-    if (validationError) {
-      setError(validationError)
-      return
-    }
-    setError('')
-    await onGoogleDriveAuth(draft, initialValue?.id)
+  // 渲染静态字段（内置类型）
+  function renderStaticFields() {
+    return staticFields.map((field) => {
+      const value = draft.config[field.key]
+      const normalized = typeof value === 'boolean' ? value : typeof value === 'string' ? value : field.type === 'switch' ? false : ''
+      return (
+        <div key={field.key}>
+          <Typography.Text>{field.label}{field.required ? ' *' : ''}</Typography.Text>
+          {field.type === 'switch' ? (
+            <Space align="center" size="medium">
+              <Switch checked={Boolean(normalized)} onChange={(v) => updateConfig(field.key, v)} />
+              {field.description && <Typography.Text type="secondary">{field.description}</Typography.Text>}
+            </Space>
+          ) : field.type === 'password' ? (
+            <Input.Password value={String(normalized)} placeholder={field.placeholder} onChange={(v) => updateConfig(field.key, v)} />
+          ) : (
+            <Input value={String(normalized)} placeholder={field.placeholder} onChange={(v) => updateConfig(field.key, v)} />
+          )}
+          {field.description && field.type !== 'switch' && (
+            <Typography.Paragraph type="secondary" style={{ marginBottom: 0, marginTop: 4 }}>{field.description}</Typography.Paragraph>
+          )}
+          {initialValue?.maskedFields?.includes(field.key) && !draft.config[field.key] && (
+            <Typography.Paragraph type="secondary" style={{ marginBottom: 0, marginTop: 4 }}>已存在敏感配置，留空则保持不变。</Typography.Paragraph>
+          )}
+        </div>
+      )
+    })
+  }
+
+  // 渲染动态字段（rclone 后端）
+  function renderDynamicFields() {
+    return (
+      <>
+        <div>
+          <Typography.Text>远端路径</Typography.Text>
+          <Input value={(draft.config.root as string) || ''} placeholder="如 /backups 或 bucket 名" onChange={(v) => updateConfig('root', v)} />
+          <Typography.Paragraph type="secondary" style={{ marginBottom: 0, marginTop: 4 }}>远端根路径、桶名或挂载点，留空使用根目录</Typography.Paragraph>
+        </div>
+        {dynamicBackend && dynamicBackend.options.length > 0 && dynamicBackend.options.map((opt) => (
+          <div key={opt.key}>
+            <Typography.Text>{opt.key}{opt.required ? ' *' : ''}</Typography.Text>
+            {opt.isPassword ? (
+              <Input.Password value={(draft.config[opt.key] as string) || ''} placeholder={opt.label} onChange={(v) => updateConfig(opt.key, v)} />
+            ) : (
+              <Input value={(draft.config[opt.key] as string) || ''} placeholder={opt.label} onChange={(v) => updateConfig(opt.key, v)} />
+            )}
+            {opt.label && (
+              <Typography.Paragraph type="secondary" style={{ marginBottom: 0, marginTop: 2, fontSize: 12 }} ellipsis={{ rows: 2, expandable: true }}>{opt.label}</Typography.Paragraph>
+            )}
+          </div>
+        ))}
+      </>
+    )
   }
 
   return (
-    <Drawer
-      width={560}
-      title={initialValue ? '编辑存储目标' : '新建存储目标'}
-      visible={visible}
-      onCancel={onCancel}
-      unmountOnExit={false}
-    >
+    <Drawer width={560} title={initialValue ? '编辑存储目标' : '新建存储目标'} visible={visible} onCancel={onCancel} unmountOnExit={false}>
       <Space direction="vertical" size="large" style={{ width: '100%' }}>
         {error ? <Alert type="error" content={error} /> : <Alert type="info" content="存储目标提供备份文件的最终去向，请确保服务端网络连通性并通过测试。" />}
-        {testResult ? <Alert type={testResult.success ? 'success' : 'warning'} content={testResult.message} /> : null}
+        {testResult && <Alert type={testResult.success ? 'success' : 'warning'} content={testResult.message} />}
 
         <div>
           <Typography.Text>名称</Typography.Text>
-          <Input value={draft.name} placeholder="例如：生产环境 MinIO" onChange={(value) => setDraft((current) => ({ ...current, name: value }))} />
+          <Input value={draft.name} placeholder="例如：生产环境 MinIO" onChange={(v) => setDraft((c) => ({ ...c, name: v }))} />
         </div>
 
         <div>
-          <Typography.Text>类型</Typography.Text>
+          <Typography.Text>存储类型</Typography.Text>
           <Select
-            value={draft.type}
-            options={storageTargetTypeOptions as unknown as { label: string; value: string }[]}
+            showSearch
+            value={draft.type || undefined}
+            placeholder="搜索存储类型（如 SFTP、Azure Blob、Dropbox...）"
+            options={allTypeOptions}
+            filterOption={(input, option) => {
+              const label = (option?.props?.children ?? option?.props?.label ?? '') as string
+              return label.toLowerCase().includes(input.toLowerCase())
+            }}
             onChange={(value) => {
-              const nextType = value as StorageTargetType
-              setDraft((current) => ({
-                ...current,
-                type: nextType,
-                config: {},
-              }))
+              setDraft((c) => ({ ...c, type: value as string, config: {} }))
               setTestResult(null)
             }}
           />
@@ -157,16 +194,12 @@ export function StorageTargetFormDrawer({
 
         <div>
           <Typography.Text>描述</Typography.Text>
-          <Input.TextArea
-            value={draft.description}
-            placeholder="可选描述，例如备份上传到 NAS 或 Google Drive"
-            onChange={(value) => setDraft((current) => ({ ...current, description: value }))}
-          />
+          <Input.TextArea value={draft.description} placeholder="可选描述" onChange={(v) => setDraft((c) => ({ ...c, description: v }))} />
         </div>
 
         <Space align="center" size="medium">
           <Typography.Text>启用</Typography.Text>
-          <Switch checked={draft.enabled} onChange={(checked) => setDraft((current) => ({ ...current, enabled: checked }))} />
+          <Switch checked={draft.enabled} onChange={(v) => setDraft((c) => ({ ...c, enabled: v }))} />
         </Space>
 
         <Divider orientation="left">环境配置</Divider>
@@ -176,58 +209,18 @@ export function StorageTargetFormDrawer({
             {getStorageTargetTypeLabel(draft.type)}
           </Typography.Title>
           <Space direction="vertical" size="large" style={{ width: '100%' }}>
-            {fieldConfigs.map((field) => {
-              const value = draft.config[field.key]
-              const normalizedValue = typeof value === 'boolean' ? value : typeof value === 'string' ? value : field.type === 'switch' ? false : ''
-
-              return (
-                <div key={field.key}>
-                  <Typography.Text>
-                    {field.label}
-                    {field.required ? ' *' : ''}
-                  </Typography.Text>
-                  {field.type === 'switch' ? (
-                    <Space align="center" size="medium">
-                      <Switch checked={Boolean(normalizedValue)} onChange={(checked) => updateConfig(field.key, checked)} />
-                      {field.description ? <Typography.Text type="secondary">{field.description}</Typography.Text> : null}
-                    </Space>
-                  ) : field.type === 'password' ? (
-                    <Input.Password
-                      value={String(normalizedValue)}
-                      placeholder={field.placeholder}
-                      onChange={(nextValue) => updateConfig(field.key, nextValue)}
-                    />
-                  ) : (
-                    <Input value={String(normalizedValue)} placeholder={field.placeholder} onChange={(nextValue) => updateConfig(field.key, nextValue)} />
-                  )}
-                  {field.description && field.type !== 'switch' ? (
-                    <Typography.Paragraph type="secondary" style={{ marginBottom: 0, marginTop: 4 }}>
-                      {field.description}
-                    </Typography.Paragraph>
-                  ) : null}
-                  {initialValue?.maskedFields?.includes(field.key) && !draft.config[field.key] ? (
-                    <Typography.Paragraph type="secondary" style={{ marginBottom: 0, marginTop: 4 }}>
-                      已存在敏感配置，留空则保持不变。
-                    </Typography.Paragraph>
-                  ) : null}
-                </div>
-              )
-            })}
+            {isDynamicType ? renderDynamicFields() : renderStaticFields()}
           </Space>
         </div>
 
         <Space>
-          <Button loading={testing} onClick={handleTest}>
-            测试连接
-          </Button>
-          {draft.type === 'google_drive' ? (
+          <Button loading={testing} onClick={handleTest}>测试连接</Button>
+          {draft.type === 'google_drive' && (
             <Button type="outline" onClick={handleGoogleDriveAuth}>
               {initialValue ? '重新授权 Google Drive' : '发起 Google Drive 授权'}
             </Button>
-          ) : null}
-          <Button type="primary" loading={loading} onClick={handleSubmit}>
-            保存
-          </Button>
+          )}
+          <Button type="primary" loading={loading} onClick={handleSubmit}>保存</Button>
         </Space>
       </Space>
     </Drawer>

web/src/components/storage-targets/field-config.ts

@@ -1,295 +1,82 @@
 import type { StorageTargetFieldConfig, StorageTargetType } from '../../types/storage-targets'
 
-const FIELD_CONFIG_MAP: Record<StorageTargetType, StorageTargetFieldConfig[]> = {
+// 内置类型的静态字段配置（定制化配置结构）
+const BUILTIN_FIELD_CONFIG: Record<string, StorageTargetFieldConfig[]> = {
   local_disk: [
-    {
-      key: 'basePath',
-      label: '基础目录',
-      type: 'input',
-      required: true,
-      placeholder: '/data/backups',
-      description: 'BackupX 将在该目录下创建和管理备份文件。',
-    },
+    { key: 'basePath', label: '基础目录', type: 'input', required: true, placeholder: '/data/backups', description: 'BackupX 将在该目录下创建和管理备份文件。' },
   ],
   s3: [
-    {
-      key: 'endpoint',
-      label: 'Endpoint',
-      type: 'input',
-      required: true,
-      placeholder: 'https://s3.amazonaws.com',
-    },
-    {
-      key: 'region',
-      label: '区域',
-      type: 'input',
-      required: true,
-      placeholder: 'ap-east-1',
-    },
-    {
-      key: 'bucket',
-      label: 'Bucket',
-      type: 'input',
-      required: true,
-      placeholder: 'backupx-prod',
-    },
-    {
-      key: 'accessKeyId',
-      label: 'Access Key ID',
-      type: 'input',
-      required: true,
-      sensitive: true,
-      placeholder: 'AKIA...',
-    },
-    {
-      key: 'secretAccessKey',
-      label: 'Secret Access Key',
-      type: 'password',
-      required: true,
-      sensitive: true,
-      placeholder: '输入新的 Secret Access Key',
-    },
-    {
-      key: 'forcePathStyle',
-      label: '强制 Path Style',
-      type: 'switch',
-      description: 'MinIO 或部分兼容对象存储通常需要开启。',
-    },
+    { key: 'endpoint', label: 'Endpoint', type: 'input', required: true, placeholder: 'https://s3.amazonaws.com' },
+    { key: 'region', label: '区域', type: 'input', required: true, placeholder: 'ap-east-1' },
+    { key: 'bucket', label: 'Bucket', type: 'input', required: true, placeholder: 'backupx-prod' },
+    { key: 'accessKeyId', label: 'Access Key ID', type: 'input', required: true, sensitive: true, placeholder: 'AKIA...' },
+    { key: 'secretAccessKey', label: 'Secret Access Key', type: 'password', required: true, sensitive: true },
+    { key: 'forcePathStyle', label: '强制 Path Style', type: 'switch', description: 'MinIO 等兼容存储需要开启。' },
   ],
   webdav: [
-    {
-      key: 'endpoint',
-      label: 'WebDAV 地址',
-      type: 'input',
-      required: true,
-      placeholder: 'https://dav.example.com/remote.php/dav/files/admin',
-    },
-    {
-      key: 'username',
-      label: '用户名',
-      type: 'input',
-      required: true,
-      placeholder: 'admin',
-    },
-    {
-      key: 'password',
-      label: '密码',
-      type: 'password',
-      required: true,
-      sensitive: true,
-      placeholder: '输入新的 WebDAV 密码',
-    },
-    {
-      key: 'basePath',
-      label: '基础目录',
-      type: 'input',
-      placeholder: '/backupx',
-    },
+    { key: 'endpoint', label: 'WebDAV 地址', type: 'input', required: true, placeholder: 'https://dav.example.com/...' },
+    { key: 'username', label: '用户名', type: 'input', required: true },
+    { key: 'password', label: '密码', type: 'password', required: true, sensitive: true },
+    { key: 'basePath', label: '基础目录', type: 'input', placeholder: '/backupx' },
   ],
   google_drive: [
-    {
-      key: 'clientId',
-      label: 'Client ID',
-      type: 'input',
-      required: true,
-      sensitive: true,
-      placeholder: 'Google OAuth Client ID',
-    },
-    {
-      key: 'clientSecret',
-      label: 'Client Secret',
-      type: 'password',
-      required: true,
-      sensitive: true,
-      placeholder: '输入新的 Google Client Secret',
-    },
-    {
-      key: 'folderId',
-      label: '目标文件夹 ID',
-      type: 'input',
-      placeholder: '留空则使用根目录',
-    },
+    { key: 'clientId', label: 'Client ID', type: 'input', required: true, sensitive: true },
+    { key: 'clientSecret', label: 'Client Secret', type: 'password', required: true, sensitive: true },
+    { key: 'folderId', label: '目标文件夹 ID', type: 'input', placeholder: '留空则使用根目录' },
   ],
   aliyun_oss: [
-    {
-      key: 'region',
-      label: '区域 (Region)',
-      type: 'input',
-      required: true,
-      placeholder: 'cn-hangzhou',
-      description: '如 cn-hangzhou, cn-shanghai, cn-beijing, cn-shenzhen 等。系统会自动组装 Endpoint。',
-    },
-    {
-      key: 'bucket',
-      label: 'Bucket',
-      type: 'input',
-      required: true,
-      placeholder: 'my-backup-bucket',
-    },
-    {
-      key: 'accessKeyId',
-      label: 'AccessKey ID',
-      type: 'input',
-      required: true,
-      sensitive: true,
-      placeholder: 'LTAI...',
-    },
-    {
-      key: 'secretAccessKey',
-      label: 'AccessKey Secret',
-      type: 'password',
-      required: true,
-      sensitive: true,
-      placeholder: '输入新的 AccessKey Secret',
-    },
-    {
-      key: 'internalNetwork',
-      label: '使用内网 Endpoint',
-      type: 'switch',
-      description: '同一区域的 ECS 实例可启用内网传输，节省流量费用。',
-    },
+    { key: 'region', label: '区域', type: 'input', required: true, placeholder: 'cn-hangzhou' },
+    { key: 'bucket', label: 'Bucket', type: 'input', required: true },
+    { key: 'accessKeyId', label: 'AccessKey ID', type: 'input', required: true, sensitive: true },
+    { key: 'secretAccessKey', label: 'AccessKey Secret', type: 'password', required: true, sensitive: true },
+    { key: 'internalNetwork', label: '使用内网', type: 'switch' },
   ],
   tencent_cos: [
-    {
-      key: 'region',
-      label: '区域 (Region)',
-      type: 'input',
-      required: true,
-      placeholder: 'ap-guangzhou',
-      description: '如 ap-guangzhou, ap-shanghai, ap-beijing, ap-chengdu 等。系统会自动组装 Endpoint。',
-    },
-    {
-      key: 'bucket',
-      label: 'Bucket',
-      type: 'input',
-      required: true,
-      placeholder: 'backup-1250000000',
-      description: '格式为 BucketName-APPID，如 backup-1250000000。',
-    },
-    {
-      key: 'accessKeyId',
-      label: 'SecretId',
-      type: 'input',
-      required: true,
-      sensitive: true,
-      placeholder: 'AKIDxxxxxxxx',
-    },
-    {
-      key: 'secretAccessKey',
-      label: 'SecretKey',
-      type: 'password',
-      required: true,
-      sensitive: true,
-      placeholder: '输入新的 SecretKey',
-    },
+    { key: 'region', label: '区域', type: 'input', required: true, placeholder: 'ap-guangzhou' },
+    { key: 'bucket', label: 'Bucket', type: 'input', required: true, placeholder: 'backup-1250000000' },
+    { key: 'accessKeyId', label: 'SecretId', type: 'input', required: true, sensitive: true },
+    { key: 'secretAccessKey', label: 'SecretKey', type: 'password', required: true, sensitive: true },
   ],
   qiniu_kodo: [
-    {
-      key: 'region',
-      label: '区域 (Region)',
-      type: 'input',
-      required: true,
-      placeholder: 'z0',
-      description: '支持 z0(华东), cn-east-2(华东-浙江2), z1(华北), z2(华南), na0(北美), as0(东南亚)。',
-    },
-    {
-      key: 'bucket',
-      label: 'Bucket',
-      type: 'input',
-      required: true,
-      placeholder: 'my-backup',
-    },
-    {
-      key: 'accessKeyId',
-      label: 'AccessKey',
-      type: 'input',
-      required: true,
-      sensitive: true,
-      placeholder: '七牛云 AccessKey',
-    },
-    {
-      key: 'secretAccessKey',
-      label: 'SecretKey',
-      type: 'password',
-      required: true,
-      sensitive: true,
-      placeholder: '输入新的 SecretKey',
-    },
+    { key: 'region', label: '区域', type: 'input', required: true, placeholder: 'z0' },
+    { key: 'bucket', label: 'Bucket', type: 'input', required: true },
+    { key: 'accessKeyId', label: 'AccessKey', type: 'input', required: true, sensitive: true },
+    { key: 'secretAccessKey', label: 'SecretKey', type: 'password', required: true, sensitive: true },
   ],
   ftp: [
-    {
-      key: 'host',
-      label: '主机地址',
-      type: 'input',
-      required: true,
-      placeholder: 'ftp.example.com',
-    },
-    {
-      key: 'port',
-      label: '端口',
-      type: 'input',
-      placeholder: '21',
-      description: '默认 FTP 端口为 21。',
-    },
-    {
-      key: 'username',
-      label: '用户名',
-      type: 'input',
-      required: true,
-      placeholder: 'backup_user',
-    },
-    {
-      key: 'password',
-      label: '密码',
-      type: 'password',
-      required: true,
-      sensitive: true,
-      placeholder: '输入新的 FTP 密码',
-    },
-    {
-      key: 'basePath',
-      label: '基础目录',
-      type: 'input',
-      placeholder: '/backups',
-      description: 'FTP 服务器上的目标目录，留空使用根目录。',
-    },
-    {
-      key: 'useTLS',
-      label: '使用 TLS (FTPS)',
-      type: 'switch',
-      description: '启用 Explicit TLS 加密连接。',
-    },
+    { key: 'host', label: '主机地址', type: 'input', required: true, placeholder: 'ftp.example.com' },
+    { key: 'port', label: '端口', type: 'input', placeholder: '21' },
+    { key: 'username', label: '用户名', type: 'input', required: true },
+    { key: 'password', label: '密码', type: 'password', required: true, sensitive: true },
+    { key: 'basePath', label: '基础目录', type: 'input', placeholder: '/backups' },
+    { key: 'useTLS', label: 'TLS (FTPS)', type: 'switch' },
   ],
 }
 
-export function getStorageTargetFieldConfigs(type: StorageTargetType) {
-  return FIELD_CONFIG_MAP[type]
+const BUILTIN_TYPES = new Set(Object.keys(BUILTIN_FIELD_CONFIG))
+
+/** 是否为内置类型 */
+export function isBuiltinType(type: StorageTargetType): boolean {
+  return BUILTIN_TYPES.has(type)
 }
 
-export function getStorageTargetTypeLabel(type: StorageTargetType) {
-  switch (type) {
-    case 'local_disk':
-      return '本地磁盘'
-    case 'google_drive':
-      return 'Google Drive'
-    case 's3':
-      return 'S3 Compatible'
-    case 'webdav':
-      return 'WebDAV'
-    case 'aliyun_oss':
-      return '阿里云 OSS'
-    case 'tencent_cos':
-      return '腾讯云 COS'
-    case 'qiniu_kodo':
-      return '七牛云 Kodo'
-    case 'ftp':
-      return 'FTP'
-    default:
-      return type
-  }
+/** 获取静态字段配置 */
+export function getStorageTargetFieldConfigs(type: StorageTargetType): StorageTargetFieldConfig[] {
+  return BUILTIN_FIELD_CONFIG[type] ?? []
 }
 
-export const storageTargetTypeOptions = [
+const BUILTIN_LABELS: Record<string, string> = {
+  local_disk: '本地磁盘', google_drive: 'Google Drive', s3: 'S3 Compatible',
+  webdav: 'WebDAV', aliyun_oss: '阿里云 OSS', tencent_cos: '腾讯云 COS',
+  qiniu_kodo: '七牛云 Kodo', ftp: 'FTP', rclone: 'Rclone',
+}
+
+export function getStorageTargetTypeLabel(type: StorageTargetType): string {
+  return BUILTIN_LABELS[type] || type.toUpperCase()
+}
+
+/** 内置类型选项（下拉框"常用"分组） */
+export const builtinTypeOptions = [
   { label: '本地磁盘', value: 'local_disk' },
   { label: '阿里云 OSS', value: 'aliyun_oss' },
   { label: '腾讯云 COS', value: 'tencent_cos' },
@@ -298,4 +85,4 @@ export const storageTargetTypeOptions = [
   { label: 'Google Drive', value: 'google_drive' },
   { label: 'WebDAV', value: 'webdav' },
   { label: 'FTP', value: 'ftp' },
-] as const
+]

web/src/layouts/AppLayout.tsx

@@ -13,6 +13,7 @@ import {
   IconDown,
   IconCloud,
   IconDesktop,
+  IconList,
 } from '@arco-design/web-react/icon'
 import { useState } from 'react'
 import { Outlet, useLocation, useNavigate } from 'react-router-dom'
@@ -37,6 +38,9 @@ function resolveSelectedKey(pathname: string) {
   if (pathname.startsWith('/settings/notifications')) {
     return '/settings/notifications'
   }
+  if (pathname.startsWith('/audit')) {
+    return '/audit'
+  }
   if (pathname.startsWith('/nodes')) {
     return '/nodes'
   }
@@ -53,6 +57,7 @@ const menuItems = [
   { key: '/storage-targets', label: '存储目标', icon: <IconStorage /> },
   { key: '/nodes', label: '节点管理', icon: <IconDesktop /> },
   { key: '/settings/notifications', label: '通知配置', icon: <IconNotification /> },
+  { key: '/audit', label: '审计日志', icon: <IconList /> },
   { key: '/settings', label: '系统设置', icon: <IconSettings /> },
 ]
 

web/src/pages/audit/AuditLogsPage.tsx

@@ -0,0 +1,154 @@
+import { PageHeader, Select, Space, Table, Tag, Typography } from '@arco-design/web-react'
+import type { ColumnProps } from '@arco-design/web-react/es/Table'
+import { useCallback, useEffect, useState } from 'react'
+import { listAuditLogs } from '../../services/audit'
+import type { AuditLog } from '../../types/audit'
+import { formatDateTime } from '../../utils/format'
+import { resolveErrorMessage } from '../../utils/error'
+
+const categoryOptions = [
+  { label: '全部', value: '' },
+  { label: '认证', value: 'auth' },
+  { label: '存储目标', value: 'storage_target' },
+  { label: '备份任务', value: 'backup_task' },
+  { label: '备份记录', value: 'backup_record' },
+  { label: '系统设置', value: 'settings' },
+]
+
+const categoryLabels: Record<string, string> = {
+  auth: '认证',
+  storage_target: '存储目标',
+  backup_task: '备份任务',
+  backup_record: '备份记录',
+  settings: '系统设置',
+}
+
+const actionLabels: Record<string, string> = {
+  login_success: '登录成功',
+  login_failed: '登录失败',
+  setup: '系统初始化',
+  change_password: '修改密码',
+  create: '创建',
+  update: '更新',
+  delete: '删除',
+  enable: '启用',
+  disable: '停用',
+  run: '执行',
+  restore: '恢复',
+}
+
+const PAGE_SIZE = 20
+
+const columns: ColumnProps<AuditLog>[] = [
+  {
+    title: '时间',
+    dataIndex: 'createdAt',
+    width: 180,
+    render: (_, record) => formatDateTime(record.createdAt),
+  },
+  {
+    title: '分类',
+    dataIndex: 'category',
+    width: 100,
+    render: (_, record) => (
+      <Tag bordered>{categoryLabels[record.category] ?? record.category}</Tag>
+    ),
+  },
+  {
+    title: '操作',
+    dataIndex: 'action',
+    width: 100,
+    render: (_, record) => actionLabels[record.action] ?? record.action,
+  },
+  {
+    title: '用户',
+    dataIndex: 'username',
+    width: 100,
+  },
+  {
+    title: '目标',
+    dataIndex: 'targetName',
+    width: 160,
+    render: (_, record) => record.targetName || record.targetId || '-',
+  },
+  {
+    title: '详情',
+    dataIndex: 'detail',
+    render: (_, record) => record.detail || '-',
+  },
+  {
+    title: 'IP',
+    dataIndex: 'clientIp',
+    width: 130,
+    render: (_, record) => record.clientIp || '-',
+  },
+]
+
+export function AuditLogsPage() {
+  const [logs, setLogs] = useState<AuditLog[]>([])
+  const [total, setTotal] = useState(0)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState('')
+  const [category, setCategory] = useState('')
+  const [page, setPage] = useState(1)
+
+  const fetchData = useCallback(async (cat: string, currentPage: number) => {
+    setLoading(true)
+    try {
+      const result = await listAuditLogs({
+        category: cat || undefined,
+        limit: PAGE_SIZE,
+        offset: (currentPage - 1) * PAGE_SIZE,
+      })
+      setLogs(result.items ?? [])
+      setTotal(result.total ?? 0)
+      setError('')
+    } catch (loadError) {
+      setError(resolveErrorMessage(loadError, '加载审计日志失败'))
+    } finally {
+      setLoading(false)
+    }
+  }, [])
+
+  useEffect(() => {
+    void fetchData(category, page)
+  }, [category, page, fetchData])
+
+  function handleCategoryChange(value: string) {
+    setCategory(value)
+    setPage(1)
+  }
+
+  return (
+    <Space direction="vertical" size="large" style={{ width: '100%' }}>
+      <PageHeader
+        style={{ paddingBottom: 0 }}
+        title="审计日志"
+        subTitle="记录系统中所有关键操作，保障数据操作链可溯源"
+      />
+      {error ? <Typography.Text type="error">{error}</Typography.Text> : null}
+      <Space>
+        <Select
+          style={{ width: 160 }}
+          value={category}
+          options={categoryOptions}
+          onChange={handleCategoryChange}
+          placeholder="筛选分类"
+        />
+      </Space>
+      <Table
+        columns={columns}
+        data={logs}
+        rowKey="id"
+        loading={loading}
+        pagination={{
+          total,
+          current: page,
+          pageSize: PAGE_SIZE,
+          onChange: setPage,
+          showTotal: true,
+        }}
+      />
+    </Space>
+  )
+}

web/src/pages/backup-records/BackupRecordsPage.tsx

@@ -98,6 +98,11 @@ export function BackupRecordsPage() {
         <Space direction="vertical" size={2}>
           <Typography.Text>{record.fileName || '-'}</Typography.Text>
           <Typography.Text type="secondary">{formatBytes(record.fileSize)}</Typography.Text>
+          {record.checksum && (
+            <Typography.Text type="secondary" copyable style={{ fontSize: 11 }}>
+              SHA-256: {record.checksum.substring(0, 16)}...
+            </Typography.Text>
+          )}
         </Space>
       ),
     },

web/src/pages/backup-tasks/BackupTasksPage.tsx

@@ -5,9 +5,10 @@ import { BackupTaskDetailDrawer } from '../../components/backup-tasks/BackupTask
 import { BackupTaskFormDrawer } from '../../components/backup-tasks/BackupTaskFormDrawer'
 import { getBackupTaskStatusColor, getBackupTaskStatusLabel, getBackupTaskTypeLabel } from '../../components/backup-tasks/field-config'
 import { createBackupTask, deleteBackupTask, getBackupTask, listBackupTasks, runBackupTask, toggleBackupTask, updateBackupTask } from '../../services/backup-tasks'
-import { listStorageTargets } from '../../services/storage-targets'
+import { listNodes } from '../../services/nodes'
+import { createStorageTarget, listStorageTargets, startGoogleDriveAuth, testStorageTarget } from '../../services/storage-targets'
 import type { BackupTaskDetail, BackupTaskPayload, BackupTaskSummary } from '../../types/backup-tasks'
-import type { StorageTargetSummary } from '../../types/storage-targets'
+import type { StorageTargetPayload, StorageTargetSummary } from '../../types/storage-targets'
 import { resolveErrorMessage } from '../../utils/error'
 import { formatDateTime } from '../../utils/format'
 
@@ -22,15 +23,20 @@ export function BackupTasksPage() {
   const [editingTask, setEditingTask] = useState<BackupTaskDetail | null>(null)
   const [detailTask, setDetailTask] = useState<BackupTaskDetail | null>(null)
   const [error, setError] = useState('')
+  const [localNodeId, setLocalNodeId] = useState<number | undefined>(undefined)
 
   const enabledStorageTargets = useMemo(() => storageTargets.filter((item) => item.enabled), [storageTargets])
 
   const loadData = useCallback(async () => {
     setLoading(true)
     try {
-      const [taskList, targetList] = await Promise.all([listBackupTasks(), listStorageTargets()])
+      const [taskList, targetList, nodeList] = await Promise.all([listBackupTasks(), listStorageTargets(), listNodes()])
       setTasks(taskList)
       setStorageTargets(targetList)
+      const localNode = nodeList.find((n) => n.isLocal)
+      if (localNode) {
+        setLocalNodeId(localNode.id)
+      }
       setError('')
     } catch (loadError) {
       setError(resolveErrorMessage(loadError, '加载备份任务失败'))
@@ -123,6 +129,28 @@ export function BackupTasksPage() {
     }
   }
 
+  async function handleCreateStorageTarget(value: StorageTargetPayload) {
+    const result = await createStorageTarget(value)
+    Message.success('存储目标已创建')
+    return result
+  }
+
+  async function handleTestStorageTarget(value: StorageTargetPayload) {
+    const result = await testStorageTarget(value)
+    Message.success(result.message)
+    return result
+  }
+
+  async function handleGoogleDriveAuth(value: StorageTargetPayload, targetId?: number) {
+    const result = await startGoogleDriveAuth(value, targetId)
+    window.open(result.authUrl, '_blank')
+  }
+
+  async function reloadStorageTargets() {
+    const targetList = await listStorageTargets()
+    setStorageTargets(targetList)
+  }
+
   const columns = [
     {
       title: '任务名称',
@@ -146,8 +174,18 @@ export function BackupTasksPage() {
     },
     {
       title: '存储目标',
-      dataIndex: 'storageTargetName',
-      render: (value: string) => value || '-',
+      dataIndex: 'storageTargetNames',
+      render: (_: unknown, record: BackupTaskSummary) => {
+        const names = record.storageTargetNames?.length > 0 ? record.storageTargetNames : record.storageTargetName ? [record.storageTargetName] : []
+        if (names.length === 0) return '-'
+        return (
+          <Space size={4} wrap>
+            {names.map((name, i) => (
+              <Tag key={i} color="arcoblue" bordered>{name}</Tag>
+            ))}
+          </Space>
+        )
+      },
     },
     {
       title: '策略',
@@ -228,11 +266,16 @@ export function BackupTasksPage() {
         loading={submitting}
         initialValue={editingTask}
         storageTargets={enabledStorageTargets}
+        localNodeId={localNodeId}
         onCancel={() => {
           setDrawerVisible(false)
           setEditingTask(null)
         }}
         onSubmit={handleSubmit}
+        onCreateStorageTarget={handleCreateStorageTarget}
+        onTestStorageTarget={handleTestStorageTarget}
+        onGoogleDriveAuth={handleGoogleDriveAuth}
+        onStorageTargetCreated={reloadStorageTargets}
       />
 
       <BackupTaskDetailDrawer

web/src/pages/settings/SettingsPage.tsx

@@ -1,88 +1,159 @@
-import { Card, Descriptions, Grid, PageHeader, Space, Typography } from '@arco-design/web-react'
+import { Badge, Button, Card, Descriptions, Grid, Link, Message, PageHeader, Space, Tag, Typography } from '@arco-design/web-react'
 import { useEffect, useState } from 'react'
-import { fetchSystemInfo, type SystemInfo } from '../../services/system'
+import { fetchSystemInfo, checkUpdate, applyUpdate, type SystemInfo, type UpdateCheckResult } from '../../services/system'
 import { resolveErrorMessage } from '../../utils/error'
 import { formatDuration } from '../../utils/format'
 
 const { Row, Col } = Grid
 
-const deploySteps = [
-  '1. 构建前端：cd web && npm run build',
-  '2. 编译后端：cd server && go build -o backupx ./cmd/backupx',
-  '3. 部署静态资源与二进制，并按 deploy/ 目录提供的配置接入 Nginx 与 systemd',
-  '4. 首次启动后访问 Web 控制台，完成管理员初始化与存储目标配置',
-]
+function formatBytes(bytes: number | undefined): string {
+  if (!bytes || bytes <= 0) return '-'
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  let i = 0
+  let size = bytes
+  while (size >= 1024 && i < units.length - 1) {
+    size /= 1024
+    i++
+  }
+  return `${size.toFixed(1)} ${units[i]}`
+}
 
 export function SettingsPage() {
   const [info, setInfo] = useState<SystemInfo | null>(null)
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState('')
+  const [updateResult, setUpdateResult] = useState<UpdateCheckResult | null>(null)
+  const [checking, setChecking] = useState(false)
+  const [applying, setApplying] = useState(false)
 
   useEffect(() => {
     let active = true
     void (async () => {
       try {
         const result = await fetchSystemInfo()
-        if (active) {
-          setInfo(result)
-          setError('')
-        }
+        if (active) { setInfo(result); setError('') }
       } catch (loadError) {
-        if (active) {
-          setError(resolveErrorMessage(loadError, '加载系统设置失败'))
-        }
+        if (active) setError(resolveErrorMessage(loadError, '加载系统信息失败'))
       } finally {
-        if (active) {
-          setLoading(false)
-        }
+        if (active) setLoading(false)
       }
     })()
-    return () => {
-      active = false
-    }
+    return () => { active = false }
   }, [])
 
+  async function handleCheckUpdate() {
+    setChecking(true)
+    try {
+      const result = await checkUpdate()
+      setUpdateResult(result)
+    } catch (e) {
+      setUpdateResult({ currentVersion: info?.version || '-', latestVersion: '-', hasUpdate: false, error: resolveErrorMessage(e, '检查更新失败') })
+    } finally {
+      setChecking(false)
+    }
+  }
+
+  async function handleApplyUpdate() {
+    if (!updateResult?.latestVersion) return
+    setApplying(true)
+    try {
+      const result = await applyUpdate(updateResult.latestVersion)
+      if (result.success) {
+        Message.success('更新已触发，容器即将自动重启...')
+        setTimeout(() => Message.info('请等待 10-30 秒后刷新页面'), 3000)
+      } else {
+        Message.warning(result.message)
+      }
+    } catch (e) {
+      Message.error(resolveErrorMessage(e, '触发更新失败'))
+    } finally {
+      setApplying(false)
+    }
+  }
+
   return (
     <Space direction="vertical" size="large" style={{ width: '100%' }}>
-      <PageHeader
-        style={{ paddingBottom: 16 }}
-        title="系统设置"
-        subTitle="展示当前运行信息、部署入口和交付所需的基础操作说明"
-      >
+      <PageHeader style={{ paddingBottom: 16 }} title="系统设置" subTitle="运行信息、磁盘状态与版本更新">
         {error ? <Typography.Text type="error">{error}</Typography.Text> : null}
       </PageHeader>
 
       <Row gutter={16}>
         <Col span={12}>
           <Card loading={loading} title="运行信息">
-            <Descriptions
-              column={1}
-              border
-              data={[
-                { label: '版本', value: info?.version ?? '-' },
-                { label: '运行模式', value: info?.mode ?? '-' },
-                { label: '运行时长', value: formatDuration(info?.uptimeSeconds) },
-                { label: '启动时间', value: info?.startedAt ?? '-' },
-                { label: '数据库路径', value: info?.databasePath ?? '-' },
-              ]}
-            />
+            <Descriptions column={1} border data={[
+              { label: '版本', value: <Space>{info?.version ?? '-'}<Button size="mini" type="text" loading={checking} onClick={handleCheckUpdate}>检查更新</Button></Space> },
+              { label: '运行模式', value: info?.mode === 'release' ? <Tag color="green">生产</Tag> : <Tag color="orange">{info?.mode ?? '-'}</Tag> },
+              { label: '运行时长', value: formatDuration(info?.uptimeSeconds) },
+              { label: '启动时间', value: info?.startedAt ?? '-' },
+              { label: '数据库路径', value: <Typography.Text copyable>{info?.databasePath ?? '-'}</Typography.Text> },
+            ]} />
           </Card>
         </Col>
         <Col span={12}>
-          <Card title="部署资产">
-            <Space direction="vertical" size="medium" style={{ width: '100%' }}>
-              <Typography.Text>`deploy/nginx.conf`：静态资源托管与 `/api` 反向代理示例。</Typography.Text>
-              <Typography.Text>`deploy/backupx.service`：systemd 服务单元，负责守护 API 进程。</Typography.Text>
-              <Typography.Text>`deploy/install.sh`：一键安装示例脚本，用于创建目录、复制文件并启动服务。</Typography.Text>
-              <Typography.Text>`README.md`：包含完整部署与使用文档。</Typography.Text>
-            </Space>
+          <Card loading={loading} title="磁盘状态">
+            <Descriptions column={1} border data={[
+              { label: '总空间', value: formatBytes(info?.diskTotal) },
+              { label: '已用空间', value: formatBytes(info?.diskUsed) },
+              { label: '可用空间', value: formatBytes(info?.diskFree) },
+              { label: '使用率', value: info?.diskTotal ? `${((info.diskUsed / info.diskTotal) * 100).toFixed(1)}%` : '-' },
+            ]} />
           </Card>
         </Col>
       </Row>
 
-      <Card title="部署步骤">
-        <div className="code-block">{deploySteps.join('\n')}</div>
-      </Card>
+      {/* 更新检查结果 */}
+      {updateResult && (
+        <Card title="版本更新">
+          {updateResult.error ? (
+            <Typography.Text type="warning">{updateResult.error}</Typography.Text>
+          ) : updateResult.hasUpdate ? (
+            <Space direction="vertical" size="medium" style={{ width: '100%' }}>
+              <Space>
+                <Badge status="processing" />
+                <Typography.Text style={{ fontWeight: 600 }}>
+                  有新版本可用：{updateResult.latestVersion}
+                </Typography.Text>
+                <Typography.Text type="secondary">（当前：{updateResult.currentVersion}）</Typography.Text>
+              </Space>
+              {updateResult.publishedAt && (
+                <Typography.Text type="secondary">发布时间：{new Date(updateResult.publishedAt).toLocaleString()}</Typography.Text>
+              )}
+              {updateResult.releaseNotes && (
+                <Card size="small" title="更新说明" style={{ maxHeight: 200, overflow: 'auto' }}>
+                  <Typography.Paragraph style={{ whiteSpace: 'pre-wrap', marginBottom: 0 }}>{updateResult.releaseNotes}</Typography.Paragraph>
+                </Card>
+              )}
+              <Space>
+                <Button type="primary" status="success" loading={applying} onClick={handleApplyUpdate}>
+                  一键更新（Docker）
+                </Button>
+                {updateResult.downloadUrl && (
+                  <Link href={updateResult.downloadUrl} target="_blank">
+                    <Button type="outline">下载二进制包</Button>
+                  </Link>
+                )}
+                {updateResult.releaseUrl && (
+                  <Link href={updateResult.releaseUrl} target="_blank">
+                    <Button type="text">Release 详情</Button>
+                  </Link>
+                )}
+              </Space>
+              {updateResult.dockerImage && (
+                <Card size="small" title="Docker 更新命令">
+                  <Typography.Paragraph copyable code style={{ marginBottom: 0 }}>
+                    {`docker pull ${updateResult.dockerImage}:${updateResult.latestVersion} && docker compose up -d`}
+                  </Typography.Paragraph>
+                </Card>
+              )}
+            </Space>
+          ) : (
+            <Space>
+              <Badge status="success" />
+              <Typography.Text>当前已是最新版本 ({updateResult.currentVersion})</Typography.Text>
+            </Space>
+          )}
+        </Card>
+      )}
     </Space>
   )
 }

web/src/pages/storage-targets/StorageTargetsPage.tsx

@@ -9,6 +9,7 @@ import {
   startGoogleDriveAuth,
   testSavedStorageTarget,
   testStorageTarget,
+  toggleStorageTargetStar,
   updateStorageTarget,
 } from '../../services/storage-targets'
 import type { StorageConnectionTestResult, StorageTargetDetail, StorageTargetPayload, StorageTargetSummary } from '../../types/storage-targets'
@@ -148,6 +149,15 @@ export function StorageTargetsPage() {
     }
   }
 
+  async function handleToggleStar(id: number) {
+    try {
+      await toggleStorageTargetStar(id)
+      await loadTargets()
+    } catch (starError) {
+      Message.error(resolveErrorMessage(starError))
+    }
+  }
+
   async function handleGoogleDriveAuth(value: StorageTargetPayload, targetId?: number) {
     try {
       const result = await startGoogleDriveAuth(value, targetId)
@@ -194,7 +204,7 @@ export function StorageTargetsPage() {
                   <Space size="large" align="start" style={{ marginBottom: 16, width: '100%', justifyContent: 'space-between' }}>
                     <div>
                       <Typography.Title heading={6} style={{ marginBottom: 4 }}>
-                        {target.name}
+                        {target.starred ? '★ ' : ''}{target.name}
                       </Typography.Title>
                       <Space>
                         {getStorageTargetTypeLabel(target.type) && <Tag color="arcoblue" bordered>{getStorageTargetTypeLabel(target.type)}</Tag>}
@@ -211,6 +221,9 @@ export function StorageTargetsPage() {
                   <Typography.Text type="secondary">更新时间：{target.updatedAt}</Typography.Text>
 
                   <Space wrap size="mini">
+                    <Button size="small" type="text" onClick={() => void handleToggleStar(target.id)}>
+                      {target.starred ? '取消收藏' : '收藏'}
+                    </Button>
                     <Button size="small" type="text" onClick={() => void openEdit(target.id)} loading={submitting && editingTarget?.id === target.id}>
                       编辑
                     </Button>

web/src/router/index.tsx

@@ -8,6 +8,7 @@ import { BackupTasksPage } from '../pages/backup-tasks/BackupTasksPage'
 import { GoogleDriveCallbackPage } from '../pages/storage-targets/GoogleDriveCallbackPage'
 import { StorageTargetsPage } from '../pages/storage-targets/StorageTargetsPage'
 import { SettingsPage } from '../pages/settings/SettingsPage'
+import { AuditLogsPage } from '../pages/audit/AuditLogsPage'
 import NodesPage from '../pages/nodes/NodesPage'
 import { ProtectedRoute } from './ProtectedRoute'
 
@@ -32,6 +33,7 @@ export function RouterView() {
         <Route path="settings" element={<SettingsPage />} />
         <Route path="settings/notifications" element={<NotificationsPage />} />
         <Route path="nodes" element={<NodesPage />} />
+        <Route path="audit" element={<AuditLogsPage />} />
         <Route path="system-info" element={<Navigate to="/settings" replace />} />
       </Route>
       <Route path="*" element={<Navigate to="/" replace />} />

web/src/services/audit.ts

@@ -0,0 +1,7 @@
+import { http } from './http'
+import type { AuditLogListResult } from '../types/audit'
+
+export async function listAuditLogs(params: { category?: string; limit?: number; offset?: number }) {
+  const response = await http.get<{ code: string; message: string; data: AuditLogListResult }>('/audit-logs', { params })
+  return response.data.data
+}

web/src/services/database.ts

@@ -0,0 +1,18 @@
+import { http, type ApiEnvelope, unwrapApiEnvelope } from './http'
+
+export interface DatabaseDiscoverPayload {
+  type: 'mysql' | 'postgresql'
+  host: string
+  port: number
+  user: string
+  password: string
+}
+
+interface DatabaseDiscoverResult {
+  databases: string[]
+}
+
+export async function discoverDatabases(payload: DatabaseDiscoverPayload): Promise<string[]> {
+  const response = await http.post<ApiEnvelope<DatabaseDiscoverResult>>('/database/discover', payload, { timeout: 10000 })
+  return unwrapApiEnvelope(response.data).databases ?? []
+}

web/src/services/rclone.ts

@@ -0,0 +1,19 @@
+import { http } from './http'
+
+export interface RcloneBackendOption {
+  key: string
+  label: string
+  required: boolean
+  isPassword: boolean
+}
+
+export interface RcloneBackendInfo {
+  name: string
+  description: string
+  options: RcloneBackendOption[]
+}
+
+export async function listRcloneBackends(): Promise<RcloneBackendInfo[]> {
+  const { data } = await http.get<{ data: RcloneBackendInfo[] }>('/storage-targets/rclone/backends')
+  return data.data
+}

web/src/services/storage-targets.ts

@@ -74,6 +74,11 @@ export interface StorageTargetUsage {
   totalSize: number
 }
 
+export async function toggleStorageTargetStar(id: number) {
+  const response = await http.put<ApiEnvelope<StorageTargetSummary>>(`/storage-targets/${id}/star`)
+  return unwrap(response.data)
+}
+
 export async function getStorageTargetUsage(id: number) {
   const response = await http.get<ApiEnvelope<StorageTargetUsage>>(`/storage-targets/${id}/usage`)
   return unwrap(response.data)

web/src/services/system.ts

@@ -11,11 +11,39 @@ export interface SystemInfo {
   diskUsed: number
 }
 
+export interface UpdateCheckResult {
+  currentVersion: string
+  latestVersion: string
+  hasUpdate: boolean
+  releaseUrl?: string
+  releaseNotes?: string
+  publishedAt?: string
+  downloadUrl?: string
+  dockerImage?: string
+  error?: string
+}
+
 export async function fetchSystemInfo() {
   const response = await http.get<{ code: string; message: string; data: SystemInfo }>('/system/info')
   return response.data.data
 }
 
+export async function checkUpdate() {
+  const response = await http.get<{ code: string; message: string; data: UpdateCheckResult }>('/system/update-check')
+  return response.data.data
+}
+
+export interface UpdateApplyResult {
+  success: boolean
+  message: string
+  output?: string
+}
+
+export async function applyUpdate(version: string) {
+  const response = await http.post<{ code: string; message: string; data: UpdateApplyResult }>('/system/update-apply', { version })
+  return response.data.data
+}
+
 export async function fetchSettings() {
   const response = await http.get<{ code: string; message: string; data: Record<string, string> }>('/settings')
   return response.data.data

web/src/types/audit.ts

@@ -0,0 +1,18 @@
+export interface AuditLog {
+  id: number
+  userId: number
+  username: string
+  category: string
+  action: string
+  targetType: string
+  targetId: string
+  targetName: string
+  detail: string
+  clientIp: string
+  createdAt: string
+}
+
+export interface AuditLogListResult {
+  items: AuditLog[]
+  total: number
+}

web/src/types/backup-records.ts

@@ -19,6 +19,7 @@ export interface BackupRecordSummary {
   status: BackupRecordStatus
   fileName: string
   fileSize: number
+  checksum: string
   storagePath: string
   durationSeconds: number
   errorMessage: string
@@ -26,9 +27,19 @@ export interface BackupRecordSummary {
   completedAt?: string
 }
 
+export interface StorageUploadResultItem {
+  storageTargetId: number
+  storageTargetName: string
+  status: 'success' | 'failed'
+  storagePath?: string
+  fileSize?: number
+  error?: string
+}
+
 export interface BackupRecordDetail extends BackupRecordSummary {
   logContent: string
   logEvents?: BackupLogEvent[]
+  storageUploadResults?: StorageUploadResultItem[]
 }
 
 export interface BackupRecordListFilter {

web/src/types/backup-tasks.ts

@@ -10,6 +10,8 @@ export interface BackupTaskSummary {
   cronExpr: string
   storageTargetId: number
   storageTargetName: string
+  storageTargetIds: number[]
+  storageTargetNames: string[]
   nodeId: number
   nodeName?: string
   tags: string
@@ -24,6 +26,7 @@ export interface BackupTaskSummary {
 
 export interface BackupTaskDetail extends BackupTaskSummary {
   sourcePath: string
+  sourcePaths: string[]
   excludePatterns: string[]
   dbHost: string
   dbPort: number
@@ -40,6 +43,7 @@ export interface BackupTaskPayload {
   enabled: boolean
   cronExpr: string
   sourcePath: string
+  sourcePaths: string[]
   excludePatterns: string[]
   dbHost: string
   dbPort: number
@@ -48,6 +52,7 @@ export interface BackupTaskPayload {
   dbName: string
   dbPath: string
   storageTargetId: number
+  storageTargetIds: number[]
   nodeId: number
   tags: string
   retentionDays: number

web/src/types/storage-targets.ts

@@ -1,4 +1,5 @@
-export type StorageTargetType = 'local_disk' | 'google_drive' | 's3' | 'webdav' | 'aliyun_oss' | 'tencent_cos' | 'qiniu_kodo' | 'ftp'
+// 内置类型 + 全部 rclone 后端名（sftp, azureblob, dropbox 等）
+export type StorageTargetType = string
 export type StorageTestStatus = 'unknown' | 'success' | 'failed'
 export type StorageFieldType = 'input' | 'password' | 'switch'
 
@@ -8,6 +9,7 @@ export interface StorageTargetSummary {
   type: StorageTargetType
   description: string
   enabled: boolean
+  starred: boolean
   updatedAt: string
   lastTestedAt?: string
   lastTestStatus: StorageTestStatus