文档: 更新 README 中英文文档 (#35)

- 存储后端描述更新为 70+ rclone 集成
- API 参考补充新增端点（节点编辑、Rclone 后端列表、版本检查、Agent 心跳）
- 技术栈补充 rclone
- 多节点集群章节补充 IP 检测、节点编辑等新功能描述
- 存储目标添加指南补充 Rclone 类型配置项分层说明
- 任务删除行为说明（清理远端文件、保留记录）
- 版本升级指引从一键更新改为手动 docker compose pull
- 发版示例更新为 v1.4.3

Dockerfile

@@ -55,6 +55,7 @@ RUN apk add --no-cache \
     nginx \
     tzdata \
     ca-certificates \
+    docker-cli docker-cli-compose \
     # Required by mysql/postgresql backup tasks
     mysql-client \
     postgresql16-client \

README.md

@@ -35,10 +35,10 @@
 | 能力 | 说明 |
 |------|------|
 | **备份类型** | 文件/目录（多源路径）、MySQL、PostgreSQL、SQLite、SAP HANA |
-| **存储后端** | 阿里云 OSS、腾讯云 COS、七牛云、S3 兼容(AWS/MinIO/R2)、Google Drive、WebDAV、FTP/FTPS、本地磁盘 |
+| **70+ 存储后端** | 内置阿里云 OSS / 腾讯云 COS / 七牛云 / S3 / Google Drive / WebDAV / FTP + 通过 rclone 集成 SFTP、Azure Blob、Dropbox、OneDrive 等 70+ 后端 |
-| **自动调度** | Cron 定时 + 可视化编辑器 + 自动保留策略（按天数/份数清理） |
+| **自动调度** | Cron 定时 + 可视化编辑器 + 自动保留策略（按天数/份数清理，自动回收空目录） |
-| **多节点** | Master-Agent 集群，统一管理多台服务器的备份 |
+| **多节点** | Master-Agent 集群，统一管理多台服务器的备份，支持远程目录浏览与节点编辑 |
-| **安全** | JWT + bcrypt + AES-256-GCM 加密配置 + 可选备份文件加密 + 审计日志 |
+| **安全** | JWT + bcrypt + AES-256-GCM 加密配置 + 可选备份文件加密 + 完整审计日志 |
 | **通知** | 邮件 / Webhook / Telegram，备份成功或失败时自动推送 |
 | **部署** | 单二进制 + 内嵌 SQLite，Docker 一键启动，零外部依赖 |
 
@@ -120,8 +120,9 @@ make docker-cn           # 或用国内镜像构建 Docker（goproxy.cn / npmmir
 | WebDAV | 服务器地址 + 用户名/密码 |
 | FTP | 主机 + 端口 + 用户名/密码 |
 | 本地磁盘 | 目标目录路径 |
+| SFTP / Azure / Dropbox / OneDrive 等 | 选择对应类型后填写必填项，高级配置可折叠展开 |
 
-> 国内云厂商只需填 Region 和 AccessKey，系统自动组装 Endpoint。
+> 国内云厂商只需填 Region 和 AccessKey，系统自动组装 Endpoint。Rclone 类型的配置项按必填/可选分层展示，高级选项默认折叠。
 
 添加后点击 **测试连接** 确认配置正确。
 
@@ -131,10 +132,12 @@ make docker-cn           # 或用国内镜像构建 Docker（goproxy.cn / npmmir
 
 1. **基础信息** — 任务名称、备份类型、Cron 表达式（留空则仅手动执行）
 2. **源配置** — 文件备份选择源路径（支持多个）、数据库备份填写连接信息
-3. **存储与策略** — 选择存储目标、压缩策略、保留天数、是否加密
+3. **存储与策略** — 选择存储目标（支持多个）、压缩策略、保留天数、是否加密
 
 保存后可以点击 **立即执行** 测试，在 **备份记录** 页面实时查看执行日志。
 
+> 删除备份任务时会自动清理远端存储上的备份文件，但保留备份记录以供审计追溯。
+
 ### 5. 配置通知（可选）
 
 进入 **通知配置** 页面，支持邮件、Webhook、Telegram 三种方式，可分别配置成功/失败时是否推送。
@@ -167,6 +170,8 @@ environment:
   - BACKUPX_BACKUP_MAX_CONCURRENT=4
 ```
 
+版本更新：在 **系统设置** 页面点击「检查更新」查看是否有新版本，然后手动执行 `docker compose pull && docker compose up -d` 完成升级。
+
 ### 裸机部署
 
 ```bash
@@ -243,7 +248,10 @@ BackupX 支持 Master-Agent 模式管理多台服务器：
 2. 在远程服务器部署 Agent 并使用 Token 连接 Master
 3. 创建备份任务时选择对应节点，Master 自动下发任务
 
-创建文件备份任务时，可通过可视化目录浏览器远程选择 Agent 节点上的目录，无需手动输入路径。
+- 本机节点自动检测 IP 地址和版本信息
+- 远程节点通过 Agent 心跳上报系统信息（主机名、IP、OS、架构、版本）
+- 支持在控制台直接编辑节点名称
+- 创建文件备份任务时可通过目录浏览器远程选择 Agent 节点上的目录
 
 ---
 
@@ -268,7 +276,7 @@ make docker-cn           # 国内 Docker 构建（镜像加速）
 ### 发版
 
 ```bash
-git tag v1.2.3 && git push --tags
+git tag v1.4.3 && git push --tags
 # GitHub Actions 自动：编译双架构二进制 → 发布 GitHub Release → 推送 Docker Hub 镜像
 ```
 
@@ -295,12 +303,16 @@ git tag v1.2.3 && git push --tags
 | | `POST /backup/records/:id/restore` | 恢复 |
 | **存储目标** | `GET\|POST /storage-targets` | 列表 / 添加 |
 | | `POST /storage-targets/test` | 测试连接 |
+| | `GET /storage-targets/rclone/backends` | Rclone 后端列表 |
 | **节点** | `GET\|POST /nodes` | 列表 / 添加 |
+| | `PUT /nodes/:id` | 编辑节点 |
 | | `GET /nodes/:id/fs/list` | 目录浏览 |
+| | `POST /agent/heartbeat` | Agent 心跳（Token 认证） |
 | **通知** | `GET\|POST /notifications` | 列表 / 添加 |
 | **仪表盘** | `GET /dashboard/stats` | 概览统计 |
 | **审计日志** | `GET /audit-logs` | 操作审计 |
 | **系统** | `GET /system/info` | 系统信息 |
+| | `GET /system/update-check` | 检查版本更新 |
 
 ---
 
@@ -308,9 +320,9 @@ git tag v1.2.3 && git push --tags
 
 | 组件 | 技术 |
 |------|------|
-| **后端** | Go · Gin · GORM · SQLite · robfig/cron |
+| **后端** | Go · Gin · GORM · SQLite · robfig/cron · rclone |
 | **前端** | React 18 · TypeScript · ArcoDesign · Vite · Zustand · ECharts |
-| **存储** | AWS SDK v2 · Google Drive API v3 · gowebdav · jlaffaye/ftp |
+| **存储** | rclone（70+ 后端）· AWS SDK v2 · Google Drive API v3 |
 | **安全** | JWT · bcrypt · AES-256-GCM |
 
 ## Contributing

README_EN.md

@@ -35,10 +35,10 @@
 | 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 |
+| **70+ Storage Backends** | Built-in Alibaba OSS / Tencent COS / Qiniu / S3 / Google Drive / WebDAV / FTP + 70+ backends via rclone (SFTP, Azure Blob, Dropbox, OneDrive, etc.) |
-| **Scheduling** | Cron-based scheduling + visual editor + auto-retention policy (by days/count) |
+| **Scheduling** | Cron-based + visual editor + auto-retention policy (by days/count, auto empty directory cleanup) |
-| **Multi-Node** | Master-Agent cluster for managing backups across multiple servers |
+| **Multi-Node** | Master-Agent cluster for managing backups across multiple servers with remote directory browsing and node editing |
-| **Security** | JWT + bcrypt + AES-256-GCM encrypted config + optional backup encryption + audit logs |
+| **Security** | JWT + bcrypt + AES-256-GCM encrypted config + optional backup encryption + comprehensive audit logs |
 | **Notifications** | Email / Webhook / Telegram — push on success or failure |
 | **Deployment** | Single binary + embedded SQLite, Docker one-click, zero external dependencies |
 
@@ -120,6 +120,9 @@ Go to **Storage Targets** → **Add**, choose a storage type and enter credentia
 | WebDAV | Server URL + Username/Password |
 | FTP | Host + Port + Username/Password |
 | Local Disk | Target directory path |
+| SFTP / Azure / Dropbox / OneDrive etc. | Select the type, fill in required fields; advanced options are collapsible |
+
+> For Chinese cloud providers, just enter Region and AccessKey — the system auto-assembles the Endpoint. Rclone-type configs separate required fields from optional advanced options (collapsed by default).
 
 Click **Test Connection** to verify.
 
@@ -129,10 +132,12 @@ 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
+3. **Storage & Policy** — Select storage target(s) (supports multiple), compression, retention days, encryption toggle
 
 Save, then click **Run Now** to test. View real-time logs in **Backup Records**.
 
+> Deleting a backup task automatically cleans up remote storage files while preserving backup records for audit purposes.
+
 ### 5. Set Up Notifications (Optional)
 
 Go to **Notifications** to configure Email, Webhook, or Telegram alerts for backup success/failure.
@@ -165,6 +170,8 @@ environment:
   - BACKUPX_BACKUP_MAX_CONCURRENT=4
 ```
 
+To upgrade: go to **System Settings**, click "Check for Updates" to see if a new version is available, then run `docker compose pull && docker compose up -d`.
+
 ### Bare Metal
 
 ```bash
@@ -239,7 +246,10 @@ BackupX supports Master-Agent mode for managing multiple servers:
 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.
+- Local node auto-detects IP address and version
+- Remote nodes report system info via Agent heartbeat (hostname, IP, OS, architecture, version)
+- Node names can be edited directly from the console
+- Visual directory browser lets you pick directories on remote Agent nodes
 
 ---
 
@@ -264,7 +274,7 @@ make docker-cn           # Docker build with China mirrors
 ### Release
 
 ```bash
-git tag v1.2.3 && git push --tags
+git tag v1.4.3 && git push --tags
 # GitHub Actions: compile dual-arch binaries → publish GitHub Release → push Docker Hub image
 ```
 
@@ -291,12 +301,16 @@ All endpoints prefixed with `/api`, authenticated via JWT Bearer Token.
 | | `POST /backup/records/:id/restore` | Restore |
 | **Storage Targets** | `GET\|POST /storage-targets` | List / Add |
 | | `POST /storage-targets/test` | Test connection |
+| | `GET /storage-targets/rclone/backends` | Rclone backend list |
 | **Nodes** | `GET\|POST /nodes` | List / Add |
+| | `PUT /nodes/:id` | Edit node |
 | | `GET /nodes/:id/fs/list` | Directory browser |
+| | `POST /agent/heartbeat` | Agent heartbeat (Token auth) |
 | **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 |
+| | `GET /system/update-check` | Check for updates |
 
 ---
 
@@ -304,9 +318,9 @@ All endpoints prefixed with `/api`, authenticated via JWT Bearer Token.
 
 | Component | Technology |
 |-----------|-----------|
-| **Backend** | Go · Gin · GORM · SQLite · robfig/cron |
+| **Backend** | Go · Gin · GORM · SQLite · robfig/cron · rclone |
 | **Frontend** | React 18 · TypeScript · ArcoDesign · Vite · Zustand · ECharts |
-| **Storage** | AWS SDK v2 · Google Drive API v3 · gowebdav · jlaffaye/ftp |
+| **Storage** | rclone (70+ backends) · AWS SDK v2 · Google Drive API v3 |
 | **Security** | JWT · bcrypt · AES-256-GCM |
 
 ## Contributing

docker-compose.yml

@@ -15,6 +15,7 @@ services:
       - "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

server/internal/app/app.go

@@ -79,6 +79,7 @@ func New(ctx context.Context, cfg config.Config, version string) (*Application,
 	storageTargetService.SetBackupTaskRepository(backupTaskRepo)
 	storageTargetService.SetBackupRecordRepository(backupRecordRepo)
 	backupTaskService := service.NewBackupTaskService(backupTaskRepo, storageTargetRepo, configCipher)
+	backupTaskService.SetRecordsAndStorage(backupRecordRepo, storageRegistry)
 	backupRunnerRegistry := backup.NewRegistry(backup.NewFileRunner(), backup.NewSQLiteRunner(), backup.NewMySQLRunner(nil), backup.NewPostgreSQLRunner(nil), backup.NewSAPHANARunner(nil))
 	logHub := backup.NewLogHub()
 	retentionService := backupretention.NewService(backupRecordRepo)
@@ -110,7 +111,7 @@ func New(ctx context.Context, cfg config.Config, version string) (*Application,
 
 	// Cluster: Node management
 	nodeRepo := repository.NewNodeRepository(db)
-	nodeService := service.NewNodeService(nodeRepo)
+	nodeService := service.NewNodeService(nodeRepo, version)
 	if err := nodeService.EnsureLocalNode(ctx); err != nil {
 		appLogger.Warn("failed to ensure local node", zap.Error(err))
 	}

server/internal/backup/retention/service.go

@@ -11,6 +11,28 @@ import (
 	"backupx/server/internal/storage"
 )
 
+// collectDirPrefixes 从待删除的记录中提取唯一的父目录前缀。
+func collectDirPrefixes(records []model.BackupRecord) []string {
+	seen := make(map[string]struct{})
+	var prefixes []string
+	for _, record := range records {
+		path := strings.TrimSpace(record.StoragePath)
+		if path == "" {
+			continue
+		}
+		idx := strings.LastIndex(path, "/")
+		if idx <= 0 {
+			continue
+		}
+		dir := path[:idx]
+		if _, ok := seen[dir]; !ok {
+			seen[dir] = struct{}{}
+			prefixes = append(prefixes, dir)
+		}
+	}
+	return prefixes
+}
+
 type CleanupResult struct {
 	DeletedRecords int
 	DeletedObjects int
@@ -54,6 +76,17 @@ func (s *Service) Cleanup(ctx context.Context, task *model.BackupTask, provider
 		}
 		result.DeletedRecords++
 	}
+
+	// 清理空目录：收集被删除文件的父目录，尝试移除空目录
+	if dirCleaner, ok := provider.(storage.StorageDirCleaner); ok && result.DeletedObjects > 0 {
+		prefixes := collectDirPrefixes(candidates)
+		for _, prefix := range prefixes {
+			if err := dirCleaner.RemoveEmptyDirs(ctx, prefix); err != nil {
+				result.Warnings = append(result.Warnings, fmt.Sprintf("cleanup empty dirs for %s: %v", prefix, err))
+			}
+		}
+	}
+
 	return result, nil
 }
 

server/internal/backup/retention/service_test.go

@@ -36,6 +36,9 @@ func (r *fakeRecordRepository) Delete(_ context.Context, id uint) error {
 func (r *fakeRecordRepository) ListRecent(context.Context, int) ([]model.BackupRecord, error) {
 	return nil, nil
 }
+func (r *fakeRecordRepository) ListByTask(_ context.Context, _ uint) ([]model.BackupRecord, error) {
+	return r.records, nil
+}
 func (r *fakeRecordRepository) ListSuccessfulByTask(_ context.Context, _ uint) ([]model.BackupRecord, error) {
 	return r.records, nil
 }

server/internal/http/backup_record_handler.go

@@ -130,7 +130,8 @@ 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))
+	recordAudit(c, h.auditService, "backup_record", "restore", "backup_record", fmt.Sprintf("%d", id), "",
+		fmt.Sprintf("恢复备份记录 (ID: %d)", id))
 	response.Success(c, gin.H{"restored": true})
 }
 
@@ -143,7 +144,8 @@ 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))
+	recordAudit(c, h.auditService, "backup_record", "delete", "backup_record", fmt.Sprintf("%d", id), "",
+		fmt.Sprintf("删除备份记录 (ID: %d)", id))
 	response.Success(c, gin.H{"deleted": true})
 }
 

server/internal/http/backup_task_handler.go

@@ -14,6 +14,19 @@ type BackupTaskHandler struct {
 	auditService *service.AuditService
 }
 
+// describeTaskInput 提取审计日志中通用的调度和存储目标描述。
+func describeTaskInput(input service.BackupTaskUpsertInput) (cronDesc string, storageCount int) {
+	cronDesc = "仅手动执行"
+	if input.CronExpr != "" {
+		cronDesc = input.CronExpr
+	}
+	storageCount = len(input.StorageTargetIDs)
+	if storageCount == 0 && input.StorageTargetID > 0 {
+		storageCount = 1
+	}
+	return
+}
+
 func NewBackupTaskHandler(taskService *service.BackupTaskService, auditService *service.AuditService) *BackupTaskHandler {
 	return &BackupTaskHandler{service: taskService, auditService: auditService}
 }
@@ -51,7 +64,9 @@ 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))
+	cronDesc, storageCount := describeTaskInput(input)
+	recordAudit(c, h.auditService, "backup_task", "create", "backup_task", fmt.Sprintf("%d", item.ID), item.Name,
+		fmt.Sprintf("创建备份任务「%s」，类型: %s, 调度: %s, 存储: %d 个目标", item.Name, input.Type, cronDesc, storageCount))
 	response.Success(c, item)
 }
 
@@ -70,7 +85,9 @@ 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))
+	updCronDesc, updStorageCount := describeTaskInput(input)
+	recordAudit(c, h.auditService, "backup_task", "update", "backup_task", fmt.Sprintf("%d", item.ID), item.Name,
+		fmt.Sprintf("更新备份任务「%s」，类型: %s, 调度: %s, 存储: %d 个目标", item.Name, input.Type, updCronDesc, updStorageCount))
 	response.Success(c, item)
 }
 
@@ -79,11 +96,13 @@ func (h *BackupTaskHandler) Delete(c *gin.Context) {
 	if !ok {
 		return
 	}
-	if err := h.service.Delete(c.Request.Context(), id); err != nil {
+	result, err := h.service.Delete(c.Request.Context(), id)
+	if err != nil {
 		response.Error(c, err)
 		return
 	}
-	recordAudit(c, h.auditService, "backup_task", "delete", "backup_task", fmt.Sprintf("%d", id), "", fmt.Sprintf("删除备份任务 #%d", id))
+	recordAudit(c, h.auditService, "backup_task", "delete", "backup_task", fmt.Sprintf("%d", id), result.TaskName,
+		fmt.Sprintf("删除备份任务「%s」(ID: %d)，关联记录 %d 条，已清理远端文件 %d 个", result.TaskName, id, result.RecordCount, result.CleanedFiles))
 	response.Success(c, gin.H{"deleted": true})
 }
 
@@ -112,9 +131,12 @@ func (h *BackupTaskHandler) Toggle(c *gin.Context) {
 		return
 	}
 	action := "enable"
+	actionLabel := "启用"
 	if !enabled {
 		action = "disable"
+		actionLabel = "停用"
 	}
-	recordAudit(c, h.auditService, "backup_task", action, "backup_task", fmt.Sprintf("%d", id), item.Name, fmt.Sprintf("%s 备份任务", action))
+	recordAudit(c, h.auditService, "backup_task", action, "backup_task", fmt.Sprintf("%d", id), item.Name,
+		fmt.Sprintf("%s备份任务「%s」", actionLabel, item.Name))
 	response.Success(c, item)
 }

server/internal/http/node_handler.go

@@ -1,6 +1,7 @@
 package http
 
 import (
+	"fmt"
 	stdhttp "net/http"
 	"strconv"
 
@@ -10,11 +11,12 @@ import (
 )
 
 type NodeHandler struct {
-	service *service.NodeService
+	service      *service.NodeService
+	auditService *service.AuditService
 }
 
-func NewNodeHandler(service *service.NodeService) *NodeHandler {
+func NewNodeHandler(service *service.NodeService, auditService *service.AuditService) *NodeHandler {
-	return &NodeHandler{service: service}
+	return &NodeHandler{service: service, auditService: auditService}
 }
 
 func (h *NodeHandler) List(c *gin.Context) {
@@ -51,6 +53,8 @@ func (h *NodeHandler) Create(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "node", "create", "node", "", input.Name,
+		fmt.Sprintf("创建远程节点「%s」", input.Name))
 	response.Success(c, gin.H{"token": token})
 }
 
@@ -64,6 +68,8 @@ func (h *NodeHandler) Delete(c *gin.Context) {
 		response.Error(c, err)
 		return
 	}
+	recordAudit(c, h.auditService, "node", "delete", "node", fmt.Sprintf("%d", id), "",
+		fmt.Sprintf("删除节点 (ID: %d)", id))
 	response.Success(c, nil)
 }
 
@@ -82,18 +88,41 @@ func (h *NodeHandler) ListDirectory(c *gin.Context) {
 	response.Success(c, entries)
 }
 
+func (h *NodeHandler) Update(c *gin.Context) {
+	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	var input service.NodeUpdateInput
+	if err := c.ShouldBindJSON(&input); err != nil {
+		c.JSON(stdhttp.StatusBadRequest, gin.H{"code": "INVALID_INPUT", "message": err.Error()})
+		return
+	}
+	item, err := h.service.Update(c.Request.Context(), uint(id), input)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	recordAudit(c, h.auditService, "node", "update", "node", fmt.Sprintf("%d", id), item.Name,
+		fmt.Sprintf("更新节点「%s」(ID: %d)", item.Name, id))
+	response.Success(c, item)
+}
+
 func (h *NodeHandler) Heartbeat(c *gin.Context) {
 	var input struct {
 		Token        string `json:"token" binding:"required"`
 		Hostname     string `json:"hostname"`
 		IPAddress    string `json:"ipAddress"`
 		AgentVersion string `json:"agentVersion"`
+		OS           string `json:"os"`
+		Arch         string `json:"arch"`
 	}
 	if err := c.ShouldBindJSON(&input); err != nil {
 		c.JSON(stdhttp.StatusBadRequest, gin.H{"code": "INVALID_INPUT", "message": err.Error()})
 		return
 	}
-	if err := h.service.Heartbeat(c.Request.Context(), input.Token, input.Hostname, input.IPAddress, input.AgentVersion); err != nil {
+	if err := h.service.Heartbeat(c.Request.Context(), input.Token, input.Hostname, input.IPAddress, input.AgentVersion, input.OS, input.Arch); err != nil {
 		response.Error(c, err)
 		return
 	}

server/internal/http/router.go

@@ -140,12 +140,13 @@ func NewRouter(deps RouterDependencies) *gin.Engine {
 			database.POST("/discover", databaseHandler.Discover)
 		}
 
-		nodeHandler := NewNodeHandler(deps.NodeService)
+		nodeHandler := NewNodeHandler(deps.NodeService, deps.AuditService)
 		nodes := api.Group("/nodes")
 		nodes.Use(AuthMiddleware(deps.JWTManager))
 		nodes.GET("", nodeHandler.List)
 		nodes.GET("/:id", nodeHandler.Get)
 		nodes.POST("", nodeHandler.Create)
+		nodes.PUT("/:id", nodeHandler.Update)
 		nodes.DELETE("/:id", nodeHandler.Delete)
 		nodes.GET("/:id/fs/list", nodeHandler.ListDirectory)
 

server/internal/http/storage_target_handler.go

@@ -65,7 +65,8 @@ 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))
+	recordAudit(c, h.auditService, "storage_target", "create", "storage_target", fmt.Sprintf("%d", item.ID), item.Name,
+		fmt.Sprintf("创建存储目标「%s」，类型: %s", item.Name, input.Type))
 	response.Success(c, item)
 }
 
@@ -84,7 +85,8 @@ 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))
+	recordAudit(c, h.auditService, "storage_target", "update", "storage_target", fmt.Sprintf("%d", item.ID), item.Name,
+		fmt.Sprintf("更新存储目标「%s」，类型: %s", item.Name, input.Type))
 	response.Success(c, item)
 }
 
@@ -97,7 +99,8 @@ 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))
+	recordAudit(c, h.auditService, "storage_target", "delete", "storage_target", fmt.Sprintf("%d", id), "",
+		fmt.Sprintf("删除存储目标 (ID: %d)", id))
 	response.Success(c, gin.H{"deleted": true})
 }
 

server/internal/repository/backup_record_repository.go

@@ -37,6 +37,7 @@ type BackupRecordRepository interface {
 	Update(context.Context, *model.BackupRecord) error
 	Delete(context.Context, uint) error
 	ListRecent(context.Context, int) ([]model.BackupRecord, error)
+	ListByTask(context.Context, uint) ([]model.BackupRecord, error)
 	ListSuccessfulByTask(context.Context, uint) ([]model.BackupRecord, error)
 	Count(context.Context) (int64, error)
 	CountSince(context.Context, time.Time) (int64, error)
@@ -115,6 +116,14 @@ func (r *GormBackupRecordRepository) ListRecent(ctx context.Context, limit int)
 	return items, nil
 }
 
+func (r *GormBackupRecordRepository) ListByTask(ctx context.Context, taskID uint) ([]model.BackupRecord, error) {
+	var items []model.BackupRecord
+	if err := r.db.WithContext(ctx).Where("task_id = ?", taskID).Order("id desc").Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
 func (r *GormBackupRecordRepository) ListSuccessfulByTask(ctx context.Context, taskID uint) ([]model.BackupRecord, error) {
 	var items []model.BackupRecord
 	if err := r.db.WithContext(ctx).Where("task_id = ? AND status = ?", taskID, "success").Order("completed_at desc, id desc").Find(&items).Error; err != nil {

server/internal/service/backup_task_service.go

@@ -11,6 +11,7 @@ import (
 	"backupx/server/internal/apperror"
 	"backupx/server/internal/model"
 	"backupx/server/internal/repository"
+	"backupx/server/internal/storage"
 	"backupx/server/internal/storage/codec"
 )
 
@@ -81,10 +82,12 @@ type BackupTaskScheduler interface {
 }
 
 type BackupTaskService struct {
-	tasks     repository.BackupTaskRepository
+	tasks           repository.BackupTaskRepository
-	targets   repository.StorageTargetRepository
+	targets         repository.StorageTargetRepository
-	cipher    *codec.ConfigCipher
+	records         repository.BackupRecordRepository
-	scheduler BackupTaskScheduler
+	storageRegistry *storage.Registry
+	cipher          *codec.ConfigCipher
+	scheduler       BackupTaskScheduler
 }
 
 func NewBackupTaskService(
@@ -95,6 +98,12 @@ func NewBackupTaskService(
 	return &BackupTaskService{tasks: tasks, targets: targets, cipher: cipher}
 }
 
+// SetRecordsAndStorage 注入备份记录仓库和存储注册表，用于任务删除时清理远端文件。
+func (s *BackupTaskService) SetRecordsAndStorage(records repository.BackupRecordRepository, registry *storage.Registry) {
+	s.records = records
+	s.storageRegistry = registry
+}
+
 func (s *BackupTaskService) SetScheduler(scheduler BackupTaskScheduler) {
 	s.scheduler = scheduler
 }
@@ -185,26 +194,80 @@ func (s *BackupTaskService) Update(ctx context.Context, id uint, input BackupTas
 	return s.Get(ctx, item.ID)
 }
 
-func (s *BackupTaskService) Delete(ctx context.Context, id uint) error {
+// DeleteResult 描述任务删除的结果信息，用于审计日志。
+type DeleteResult struct {
+	TaskName     string
+	RecordCount  int
+	CleanedFiles int
+}
+
+func (s *BackupTaskService) Delete(ctx context.Context, id uint) (*DeleteResult, error) {
 	existing, err := s.tasks.FindByID(ctx, id)
 	if err != nil {
-		return apperror.Internal("BACKUP_TASK_GET_FAILED", "无法获取备份任务详情", err)
+		return nil, apperror.Internal("BACKUP_TASK_GET_FAILED", "无法获取备份任务详情", err)
 	}
 	if existing == nil {
-		return apperror.New(http.StatusNotFound, "BACKUP_TASK_NOT_FOUND", "备份任务不存在", fmt.Errorf("backup task %d not found", id))
+		return nil, apperror.New(http.StatusNotFound, "BACKUP_TASK_NOT_FOUND", "备份任务不存在", fmt.Errorf("backup task %d not found", id))
-	}
-	if s.scheduler != nil {
-		if err := s.scheduler.RemoveTask(ctx, id); err != nil {
-			return apperror.Internal("BACKUP_TASK_SCHEDULE_FAILED", "无法移除备份任务调度", err)
-		}
-	}
-	if err := s.tasks.Delete(ctx, id); err != nil {
-		return apperror.Internal("BACKUP_TASK_DELETE_FAILED", "无法删除备份任务", err)
 	}
 	if s.scheduler != nil {
 		_ = s.scheduler.RemoveTask(ctx, id)
 	}
-	return nil
+
+	// 清理远端存储文件（尽力而为，不阻止删除）
+	result := &DeleteResult{TaskName: existing.Name}
+	result.RecordCount, result.CleanedFiles = s.cleanupRemoteFiles(ctx, id)
+
+	if err := s.tasks.Delete(ctx, id); err != nil {
+		return nil, apperror.Internal("BACKUP_TASK_DELETE_FAILED", "无法删除备份任务", err)
+	}
+	return result, nil
+}
+
+// cleanupRemoteFiles 尽力删除任务相关的远端备份文件，返回记录数和成功删除的文件数。
+func (s *BackupTaskService) cleanupRemoteFiles(ctx context.Context, taskID uint) (recordCount int, cleanedFiles int) {
+	if s.records == nil || s.storageRegistry == nil {
+		return 0, 0
+	}
+	records, err := s.records.ListByTask(ctx, taskID)
+	if err != nil {
+		return 0, 0
+	}
+	recordCount = len(records)
+	// 缓存 provider 避免同一存储目标重复创建连接
+	providerCache := make(map[uint]storage.StorageProvider)
+	for _, record := range records {
+		if strings.TrimSpace(record.StoragePath) == "" {
+			continue
+		}
+		provider, ok := providerCache[record.StorageTargetID]
+		if !ok {
+			provider, err = s.resolveStorageProvider(ctx, record.StorageTargetID)
+			if err != nil {
+				continue
+			}
+			providerCache[record.StorageTargetID] = provider
+		}
+		if err := provider.Delete(ctx, record.StoragePath); err == nil {
+			cleanedFiles++
+		}
+	}
+	return recordCount, cleanedFiles
+}
+
+func (s *BackupTaskService) resolveStorageProvider(ctx context.Context, targetID uint) (storage.StorageProvider, error) {
+	target, err := s.targets.FindByID(ctx, targetID)
+	if err != nil || target == nil {
+		return nil, fmt.Errorf("target %d not found", targetID)
+	}
+	configMap := map[string]any{}
+	if err := s.cipher.DecryptJSON(target.ConfigCiphertext, &configMap); err != nil {
+		return nil, err
+	}
+	provider, err := s.storageRegistry.Create(ctx, target.Type, configMap)
+	if err != nil {
+		return nil, err
+	}
+	return provider, nil
 }
 
 func (s *BackupTaskService) Toggle(ctx context.Context, id uint, enabled bool) (*BackupTaskSummary, error) {

server/internal/service/node_service.go

@@ -5,11 +5,13 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"net"
 	"net/http"
 	"os"
 	"path/filepath"
 	"runtime"
 	"sort"
+	"strings"
 	"time"
 
 	"backupx/server/internal/apperror"
@@ -37,13 +39,19 @@ type NodeCreateInput struct {
 	Name string `json:"name" binding:"required"`
 }
 
-// NodeService manages the cluster nodes.
+// NodeUpdateInput 是编辑节点的输入。
-type NodeService struct {
+type NodeUpdateInput struct {
-	repo repository.NodeRepository
+	Name string `json:"name" binding:"required"`
 }
 
-func NewNodeService(repo repository.NodeRepository) *NodeService {
+// NodeService manages the cluster nodes.
-	return &NodeService{repo: repo}
+type NodeService struct {
+	repo    repository.NodeRepository
+	version string
+}
+
+func NewNodeService(repo repository.NodeRepository, version string) *NodeService {
+	return &NodeService{repo: repo, version: version}
 }
 
 // EnsureLocalNode creates the default "local" node if it does not exist.
@@ -57,6 +65,8 @@ func (s *NodeService) EnsureLocalNode(ctx context.Context) error {
 		existing.LastSeen = time.Now().UTC()
 		hostname, _ := os.Hostname()
 		existing.Hostname = hostname
+		existing.IPAddress = detectLocalIP()
+		existing.AgentVer = s.version
 		existing.OS = runtime.GOOS
 		existing.Arch = runtime.GOARCH
 		return s.repo.Update(ctx, existing)
@@ -64,14 +74,16 @@ func (s *NodeService) EnsureLocalNode(ctx context.Context) error {
 	hostname, _ := os.Hostname()
 	token, _ := generateToken()
 	node := &model.Node{
-		Name:     "本机 (Local)",
+		Name:      "本机 (Local)",
-		Hostname: hostname,
+		Hostname:  hostname,
-		Token:    token,
+		IPAddress: detectLocalIP(),
-		Status:   model.NodeStatusOnline,
+		Token:     token,
-		IsLocal:  true,
+		Status:    model.NodeStatusOnline,
-		OS:       runtime.GOOS,
+		IsLocal:   true,
-		Arch:     runtime.GOARCH,
+		OS:        runtime.GOOS,
-		LastSeen: time.Now().UTC(),
+		Arch:      runtime.GOARCH,
+		AgentVer:  s.version,
+		LastSeen:  time.Now().UTC(),
 	}
 	return s.repo.Create(ctx, node)
 }
@@ -199,7 +211,7 @@ func (s *NodeService) ListDirectory(ctx context.Context, nodeID uint, path strin
 }
 
 // Heartbeat updates the node status when an agent reports in.
-func (s *NodeService) Heartbeat(ctx context.Context, token string, hostname string, ip string, agentVer string) error {
+func (s *NodeService) Heartbeat(ctx context.Context, token string, hostname string, ip string, agentVer string, osName string, archName string) error {
 	node, err := s.repo.FindByToken(ctx, token)
 	if err != nil {
 		return err
@@ -211,12 +223,36 @@ func (s *NodeService) Heartbeat(ctx context.Context, token string, hostname stri
 	node.Hostname = hostname
 	node.IPAddress = ip
 	node.AgentVer = agentVer
-	node.OS = runtime.GOOS
+	if strings.TrimSpace(osName) != "" {
-	node.Arch = runtime.GOARCH
+		node.OS = osName
+	} else {
+		node.OS = runtime.GOOS
+	}
+	if strings.TrimSpace(archName) != "" {
+		node.Arch = archName
+	} else {
+		node.Arch = runtime.GOARCH
+	}
 	node.LastSeen = time.Now().UTC()
 	return s.repo.Update(ctx, node)
 }
 
+// Update 编辑节点名称。
+func (s *NodeService) Update(ctx context.Context, id uint, input NodeUpdateInput) (*NodeSummary, error) {
+	node, err := s.repo.FindByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if node == nil {
+		return nil, apperror.New(http.StatusNotFound, "NODE_NOT_FOUND", "节点不存在", nil)
+	}
+	node.Name = strings.TrimSpace(input.Name)
+	if err := s.repo.Update(ctx, node); err != nil {
+		return nil, err
+	}
+	return s.Get(ctx, id)
+}
+
 // DirEntry represents a file or directory in a node's file system.
 type DirEntry struct {
 	Name  string `json:"name"`
@@ -225,6 +261,22 @@ type DirEntry struct {
 	Size  int64  `json:"size"`
 }
 
+// detectLocalIP 获取本机第一个非回环 IPv4 地址。
+func detectLocalIP() string {
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return ""
+	}
+	for _, addr := range addrs {
+		if ipNet, ok := addr.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
+			if ipNet.IP.To4() != nil {
+				return ipNet.IP.String()
+			}
+		}
+	}
+	return ""
+}
+
 func generateToken() (string, error) {
 	b := make([]byte, 32)
 	if _, err := rand.Read(b); err != nil {

server/internal/service/system_service.go

@@ -132,3 +132,4 @@ func (s *SystemService) GetInfo(_ context.Context) *SystemInfo {
 	}
 	return info
 }
+

server/internal/storage/rclone/provider.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"sort"
 	"strings"
 	"time"
 
@@ -124,6 +125,36 @@ func (p *Provider) About(ctx context.Context) (*storage.StorageUsageInfo, error)
 	}, nil
 }
 
+// RemoveEmptyDirs 递归删除 prefix 下的空目录，从最深层开始。
+// 非空目录删除会失败（安全忽略），仅清理真正的空目录。
+func (p *Provider) RemoveEmptyDirs(ctx context.Context, prefix string) error {
+	var dirs []string
+	err := walk.ListR(ctx, p.rfs, prefix, true, -1, walk.ListDirs, func(entries fs.DirEntries) error {
+		for _, entry := range entries {
+			if _, ok := entry.(fs.Directory); ok {
+				dirs = append(dirs, entry.Remote())
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		// 列目录失败（比如目录不存在）静默返回
+		return nil
+	}
+	// 按路径长度倒序（深目录优先删除），同长度保持稳定顺序
+	sort.SliceStable(dirs, func(i, j int) bool {
+		return len(dirs[i]) > len(dirs[j])
+	})
+	for _, dir := range dirs {
+		_ = p.rfs.Rmdir(ctx, dir)
+	}
+	// 尝试清理 prefix 本身
+	if prefix != "" {
+		_ = p.rfs.Rmdir(ctx, prefix)
+	}
+	return nil
+}
+
 // pathDir 返回 objectKey 的目录部分（正斜杠分隔）。
 func pathDir(objectKey string) string {
 	idx := strings.LastIndex(objectKey, "/")

server/internal/storage/types.go

@@ -145,3 +145,10 @@ type FTPConfig struct {
 	UseTLS   bool   `json:"useTLS"`
 }
 
+// StorageDirCleaner 是可选能力接口，支持清理空目录。
+// 主要用于本地磁盘等文件系统类存储，对象存储通常不需要。
+// 通过 type assertion 检测 provider 是否实现该接口。
+type StorageDirCleaner interface {
+	RemoveEmptyDirs(ctx context.Context, prefix string) error
+}
+

web/src/components/common/DirectoryPicker.tsx

@@ -1,5 +1,5 @@
-import { Button, Input, Message, Modal, Space, Spin, Tree, Typography } from '@arco-design/web-react'
+import { Button, Input, Message, Modal, Space, Spin, Tree, Typography, Empty } from '@arco-design/web-react'
-import { IconFolder, IconFile } from '@arco-design/web-react/icon'
+import { IconFolder, IconFile, IconFolderAdd } from '@arco-design/web-react/icon'
 import { useCallback, useState } from 'react'
 import { listNodeDirectory } from '../../services/nodes'
 import type { DirEntry } from '../../types/nodes'
@@ -27,7 +27,7 @@ function entriesToTreeNodes(entries: DirEntry[], mode: 'directory' | 'file'): Tr
     .map((entry) => ({
       key: entry.path,
       title: entry.name,
-      icon: entry.isDir ? <IconFolder /> : <IconFile />,
+      icon: entry.isDir ? <IconFolder style={{ color: 'var(--color-warning-6)' }} /> : <IconFile />,
       isLeaf: !entry.isDir,
     }))
 }
@@ -94,46 +94,83 @@ export function DirectoryPicker({ value, onChange, placeholder, mode = 'director
     setModalVisible(false)
   }
 
+  function handleInputKeyDown(e: React.KeyboardEvent) {
+    if (e.key === 'Enter') {
+      e.preventDefault()
+      const trimmed = value?.trim()
+      if (trimmed) {
+        onChange(trimmed)
+      }
+    }
+  }
+
   // 没有 nodeId 时退化为普通输入框
   if (nodeId === undefined) {
-    return <Input value={value} placeholder={placeholder} onChange={onChange} />
+    return <Input value={value} placeholder={placeholder} onChange={onChange} onKeyDown={handleInputKeyDown} />
   }
 
   return (
     <>
-      <Space style={{ width: '100%' }}>
+      <div style={{ display: 'flex', gap: 8, width: '100%' }}>
-        <Input style={{ flex: 1 }} value={value} placeholder={placeholder} onChange={onChange} />
+        <Input
-        <Button type="outline" size="small" onClick={handleOpen}>
+          style={{ flex: 1 }}
+          value={value}
+          placeholder={placeholder}
+          onChange={onChange}
+          onKeyDown={handleInputKeyDown}
+          allowClear
+        />
+        <Button type="outline" size="default" onClick={handleOpen} icon={<IconFolderAdd />}>
           浏览
         </Button>
-      </Space>
+      </div>
 
       <Modal
         title={mode === 'directory' ? '选择目录' : '选择文件'}
         visible={modalVisible}
         onCancel={() => setModalVisible(false)}
         onOk={handleConfirm}
-        okText="选择"
+        okText="确认选择"
         cancelText="取消"
-        style={{ width: 560 }}
+        style={{ width: 640 }}
         okButtonProps={{ disabled: !selectedPath }}
         unmountOnExit
       >
-        {selectedPath && (
+        {/* 当前选中路径 */}
-          <div style={{ padding: '8px 12px', marginBottom: 12, background: 'var(--color-fill-2)', borderRadius: 4 }}>
+        <div style={{
-            <Typography.Text copyable style={{ fontSize: 13 }}>
+          padding: '10px 14px',
+          marginBottom: 16,
+          background: selectedPath ? 'var(--color-primary-light-1)' : 'var(--color-fill-2)',
+          borderRadius: 6,
+          border: selectedPath ? '1px solid var(--color-primary-light-3)' : '1px solid var(--color-border)',
+          display: 'flex',
+          alignItems: 'center',
+          gap: 8,
+          minHeight: 40,
+        }}>
+          <IconFolder style={{ color: selectedPath ? 'var(--color-primary-6)' : 'var(--color-text-4)', fontSize: 16, flexShrink: 0 }} />
+          {selectedPath ? (
+            <Typography.Text copyable style={{ fontSize: 13, fontFamily: 'monospace', wordBreak: 'break-all' }}>
               {selectedPath}
             </Typography.Text>
-          </div>
+          ) : (
-        )}
+            <Typography.Text type="secondary" style={{ fontSize: 13 }}>请在下方目录树中选择路径</Typography.Text>
+          )}
+        </div>
+
+        {/* 目录树 */}
         {loading ? (
-          <Spin style={{ display: 'block', textAlign: 'center', padding: 40 }} />
+          <Spin style={{ display: 'block', textAlign: 'center', padding: 48 }} tip="加载目录中..." />
         ) : treeData.length === 0 ? (
-          <Typography.Text type="secondary" style={{ display: 'block', textAlign: 'center', padding: 40 }}>
+          <Empty style={{ padding: 48 }} description="目录为空" />
-            目录为空
-          </Typography.Text>
         ) : (
-          <div style={{ maxHeight: 420, overflow: 'auto', border: '1px solid var(--color-border)', borderRadius: 4, padding: '4px 0' }}>
+          <div style={{
+            maxHeight: 400,
+            overflow: 'auto',
+            border: '1px solid var(--color-border)',
+            borderRadius: 6,
+            padding: '6px 0',
+          }}>
             <Tree
               blockNode
               showLine

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

@@ -1,8 +1,8 @@
-import { Alert, Button, Divider, Drawer, Input, Select, Space, Switch, Typography } from '@arco-design/web-react'
+import { Alert, Button, Collapse, Divider, Drawer, Input, Select, Space, Switch, Typography } from '@arco-design/web-react'
 import { useEffect, useMemo, useState } from 'react'
-import { getStorageTargetFieldConfigs, getStorageTargetTypeLabel, isBuiltinType, builtinTypeOptions } from './field-config'
+import { getStorageTargetFieldConfigs, getStorageTargetTypeLabel, isBuiltinType, buildAllTypeOptions } from './field-config'
 import type { StorageConnectionTestResult, StorageTargetDetail, StorageTargetPayload, StorageTargetType } from '../../types/storage-targets'
-import { listRcloneBackends, type RcloneBackendInfo } from '../../services/rclone'
+import { listRcloneBackends, type RcloneBackendInfo, type RcloneBackendOption } from '../../services/rclone'
 
 interface StorageTargetFormDrawerProps {
   visible: boolean
@@ -56,17 +56,18 @@ export function StorageTargetFormDrawer({
     setTestResult(null)
   }, [initialValue, visible])
 
-  // 合并类型选项：内置 + 全部 rclone 后端
+  // 构建分类的类型选项（去重、中文标注）
-  const allTypeOptions = useMemo(() => {
+  const allTypeOptions = useMemo(() => buildAllTypeOptions(rcloneBackends), [rcloneBackends])
-    const builtinValues = new Set(builtinTypeOptions.map((o) => o.value))
+
-    const rcloneOptions = rcloneBackends
+  // 按分组聚合，用于 Select 的 OptGroup 渲染
-      .filter((b) => !builtinValues.has(b.name) && b.name !== 'local' && b.name !== 'rclone')
+  const groupedOptions = useMemo(() => {
-      .map((b) => ({ label: `${b.name.toUpperCase()} — ${b.description}`, value: b.name }))
+    const groups: Record<string, { label: string; value: string }[]> = {}
-    return [
+    for (const opt of allTypeOptions) {
-      ...builtinTypeOptions.map((o) => ({ ...o, label: o.label, value: o.value as string })),
+      if (!groups[opt.group]) groups[opt.group] = []
-      ...rcloneOptions,
+      groups[opt.group].push({ label: opt.label, value: opt.value })
-    ]
+    }
-  }, [rcloneBackends])
+    return groups
+  }, [allTypeOptions])
 
   // 当前类型是否为非内置（rclone 动态后端）
   const isDynamicType = !isBuiltinType(draft.type)
@@ -137,8 +138,28 @@ export function StorageTargetFormDrawer({
     })
   }
 
-  // 渲染动态字段（rclone 后端）
+  // 渲染单个动态字段
+  function renderDynamicOption(opt: RcloneBackendOption) {
+    return (
+      <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>
+    )
+  }
+
+  // 渲染动态字段（rclone 后端）— 必填优先，可选折叠
   function renderDynamicFields() {
+    const requiredOptions = dynamicBackend?.options.filter((opt) => opt.required) ?? []
+    const optionalOptions = dynamicBackend?.options.filter((opt) => !opt.required) ?? []
+
     return (
       <>
         <div>
@@ -146,19 +167,19 @@ export function StorageTargetFormDrawer({
           <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) => (
+        {requiredOptions.map(renderDynamicOption)}
-          <div key={opt.key}>
+        {optionalOptions.length > 0 && (
-            <Typography.Text>{opt.key}{opt.required ? ' *' : ''}</Typography.Text>
+          <Collapse bordered={false} style={{ background: 'transparent' }}>
-            {opt.isPassword ? (
+            <Collapse.Item
-              <Input.Password value={(draft.config[opt.key] as string) || ''} placeholder={opt.label} onChange={(v) => updateConfig(opt.key, v)} />
+              header={<Typography.Text type="secondary">高级配置（{optionalOptions.length} 个可选项）</Typography.Text>}
-            ) : (
+              name="advanced"
-              <Input value={(draft.config[opt.key] as string) || ''} placeholder={opt.label} onChange={(v) => updateConfig(opt.key, v)} />
+            >
-            )}
+              <Space direction="vertical" size="large" style={{ width: '100%' }}>
-            {opt.label && (
+                {optionalOptions.map(renderDynamicOption)}
-              <Typography.Paragraph type="secondary" style={{ marginBottom: 0, marginTop: 2, fontSize: 12 }} ellipsis={{ rows: 2, expandable: true }}>{opt.label}</Typography.Paragraph>
+              </Space>
-            )}
+            </Collapse.Item>
-          </div>
+          </Collapse>
-        ))}
+        )}
       </>
     )
   }
@@ -179,17 +200,24 @@ export function StorageTargetFormDrawer({
           <Select
             showSearch
             value={draft.type || undefined}
-            placeholder="搜索存储类型（如 SFTP、Azure Blob、Dropbox...）"
+            placeholder="搜索存储类型..."
-            options={allTypeOptions}
             filterOption={(input, option) => {
-              const label = (option?.props?.children ?? option?.props?.label ?? '') as string
+              const label = String(option?.props?.children ?? option?.props?.label ?? '')
               return label.toLowerCase().includes(input.toLowerCase())
             }}
             onChange={(value) => {
               setDraft((c) => ({ ...c, type: value as string, config: {} }))
               setTestResult(null)
             }}
-          />
+          >
+            {Object.entries(groupedOptions).map(([group, options]) => (
+              <Select.OptGroup key={group} label={group}>
+                {options.map((opt) => (
+                  <Select.Option key={opt.value} value={opt.value}>{opt.label}</Select.Option>
+                ))}
+              </Select.OptGroup>
+            ))}
+          </Select>
         </div>
 
         <div>

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

@@ -1,6 +1,9 @@
 import type { StorageTargetFieldConfig, StorageTargetType } from '../../types/storage-targets'
 
-// 内置类型的静态字段配置（定制化配置结构）
+// ---------------------------------------------------------------------------
+// 内置类型的静态字段配置
+// ---------------------------------------------------------------------------
+
 const BUILTIN_FIELD_CONFIG: Record<string, StorageTargetFieldConfig[]> = {
   local_disk: [
     { key: 'basePath', label: '基础目录', type: 'input', required: true, placeholder: '/data/backups', description: 'BackupX 将在该目录下创建和管理备份文件。' },
@@ -55,34 +58,117 @@ const BUILTIN_FIELD_CONFIG: Record<string, StorageTargetFieldConfig[]> = {
 
 const BUILTIN_TYPES = new Set(Object.keys(BUILTIN_FIELD_CONFIG))
 
-/** 是否为内置类型 */
 export function isBuiltinType(type: StorageTargetType): boolean {
   return BUILTIN_TYPES.has(type)
 }
 
-/** 获取静态字段配置 */
 export function getStorageTargetFieldConfigs(type: StorageTargetType): StorageTargetFieldConfig[] {
   return BUILTIN_FIELD_CONFIG[type] ?? []
 }
 
-const BUILTIN_LABELS: Record<string, string> = {
+// ---------------------------------------------------------------------------
+// 存储类型完整列表（分类、中文标注、去重）
+// ---------------------------------------------------------------------------
+
+export interface TypeOption {
+  label: string
+  value: string
+  group: string
+}
+
+// rclone 后端中不适合做存储目标的（工具类/代理类/只读类）
+const EXCLUDED_BACKENDS = new Set([
+  'alias', 'cache', 'http', 'archive', 'memory', 'tardigrade', // tardigrade = storj 别名
+  'union', 'crypt', 'chunker', 'compress', 'hasher', 'combine',
+  'local', // 用内置 local_disk 替代
+  'drive', // 用内置 google_drive 替代（避免和 rclone 的 drive 重复）
+])
+
+// 内置类型（带中文标签的定制化类型，优先展示）
+const BUILTIN_OPTIONS: TypeOption[] = [
+  { label: '本地磁盘', value: 'local_disk', group: '常用' },
+  { label: 'S3 兼容存储（AWS / MinIO / 阿里云 / 腾讯云等）', value: 's3', group: '常用' },
+  { label: '阿里云 OSS', value: 'aliyun_oss', group: '常用' },
+  { label: '腾讯云 COS', value: 'tencent_cos', group: '常用' },
+  { label: '七牛云 Kodo', value: 'qiniu_kodo', group: '常用' },
+  { label: 'Google Drive', value: 'google_drive', group: '常用' },
+  { label: 'WebDAV（Nextcloud / 坚果云等）', value: 'webdav', group: '常用' },
+  { label: 'FTP / FTPS', value: 'ftp', group: '常用' },
+]
+
+// rclone 后端的中文标注（仅标注常见的，其余用原始描述）
+const RCLONE_LABELS: Record<string, { label: string; group: string }> = {
+  sftp:                { label: 'SFTP（SSH 文件传输）', group: '文件传输' },
+  smb:                 { label: 'SMB / CIFS（Windows 共享）', group: '文件传输' },
+  azureblob:           { label: 'Azure Blob 存储', group: '云存储' },
+  azurefiles:          { label: 'Azure Files 存储', group: '云存储' },
+  'google cloud storage': { label: 'Google Cloud Storage（GCS）', group: '云存储' },
+  b2:                  { label: 'Backblaze B2', group: '云存储' },
+  swift:               { label: 'OpenStack Swift', group: '云存储' },
+  dropbox:             { label: 'Dropbox', group: '网盘' },
+  onedrive:            { label: 'Microsoft OneDrive', group: '网盘' },
+  box:                 { label: 'Box', group: '网盘' },
+  pcloud:              { label: 'pCloud', group: '网盘' },
+  mega:                { label: 'MEGA', group: '网盘' },
+  'google photos':     { label: 'Google Photos', group: '网盘' },
+  yandex:              { label: 'Yandex Disk', group: '网盘' },
+  pikpak:              { label: 'PikPak', group: '网盘' },
+  iclouddrive:         { label: 'iCloud Drive', group: '网盘' },
+  jottacloud:          { label: 'Jottacloud', group: '网盘' },
+  hidrive:             { label: 'HiDrive', group: '网盘' },
+  protondrive:         { label: 'Proton Drive', group: '网盘' },
+  mailru:              { label: 'Mail.ru Cloud', group: '网盘' },
+  sugarsync:           { label: 'SugarSync', group: '网盘' },
+  putio:               { label: 'Put.io', group: '网盘' },
+  zoho:                { label: 'Zoho WorkDrive', group: '网盘' },
+  internxt:            { label: 'Internxt Drive', group: '网盘' },
+  seafile:             { label: 'Seafile', group: '自建存储' },
+  storj:               { label: 'Storj 去中心化存储', group: '云存储' },
+  hdfs:                { label: 'Hadoop HDFS', group: '企业存储' },
+  oracleobjectstorage: { label: 'Oracle 对象存储', group: '云存储' },
+  qingstor:            { label: '青云 QingStor', group: '云存储' },
+  sharefile:           { label: 'Citrix ShareFile', group: '企业存储' },
+  filefabric:          { label: 'Enterprise File Fabric', group: '企业存储' },
+  netstorage:          { label: 'Akamai NetStorage', group: '企业存储' },
+  sia:                 { label: 'Sia 去中心化存储', group: '云存储' },
+  koofr:               { label: 'Koofr / Digi Storage', group: '网盘' },
+  opendrive:           { label: 'OpenDrive', group: '网盘' },
+}
+
+/** 构建完整类型选项列表（内置 + rclone，去重+分类） */
+export function buildAllTypeOptions(rcloneBackends: { name: string; description: string }[]): TypeOption[] {
+  const result = [...BUILTIN_OPTIONS]
+  const existingValues = new Set(BUILTIN_OPTIONS.map((o) => o.value))
+
+  for (const backend of rcloneBackends) {
+    if (EXCLUDED_BACKENDS.has(backend.name) || existingValues.has(backend.name)) continue
+    // 也排除和内置类型实际是同一后端的（如 rclone 的 s3, ftp, webdav 已被内置覆盖）
+    existingValues.add(backend.name)
+
+    const meta = RCLONE_LABELS[backend.name]
+    result.push({
+      label: meta?.label ?? `${backend.name} — ${backend.description}`,
+      value: backend.name,
+      group: meta?.group ?? '其他',
+    })
+  }
+
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// 类型标签
+// ---------------------------------------------------------------------------
+
+const TYPE_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',
+  qiniu_kodo: '七牛云 Kodo', ftp: 'FTP',
+  sftp: 'SFTP', smb: 'SMB', azureblob: 'Azure Blob', dropbox: 'Dropbox',
+  onedrive: 'OneDrive', b2: 'Backblaze B2', mega: 'MEGA', pcloud: 'pCloud',
+  box: 'Box', swift: 'Swift', pikpak: 'PikPak',
 }
 
 export function getStorageTargetTypeLabel(type: StorageTargetType): string {
-  return BUILTIN_LABELS[type] || type.toUpperCase()
+  return TYPE_LABELS[type] || type.toUpperCase()
 }
-
-/** 内置类型选项（下拉框"常用"分组） */
-export const builtinTypeOptions = [
-  { label: '本地磁盘', value: 'local_disk' },
-  { label: '阿里云 OSS', value: 'aliyun_oss' },
-  { label: '腾讯云 COS', value: 'tencent_cos' },
-  { label: '七牛云 Kodo', value: 'qiniu_kodo' },
-  { label: 'S3 Compatible', value: 's3' },
-  { label: 'Google Drive', value: 'google_drive' },
-  { label: 'WebDAV', value: 'webdav' },
-  { label: 'FTP', value: 'ftp' },
-]

web/src/pages/nodes/NodesPage.tsx

@@ -3,10 +3,10 @@ import {
   Table, Button, Space, Tag, Typography, PageHeader, Modal, Input, Message, Badge, Popconfirm, Card, Descriptions, Empty
 } from '@arco-design/web-react'
 import {
-  IconPlus, IconDelete, IconDesktop, IconCloudDownload
+  IconPlus, IconDelete, IconDesktop, IconCloudDownload, IconEdit
 } from '@arco-design/web-react/icon'
 import type { NodeSummary } from '../../types/nodes'
-import { listNodes, createNode, deleteNode } from '../../services/nodes'
+import { listNodes, createNode, deleteNode, updateNode } from '../../services/nodes'
 
 const { Title, Text } = Typography
 
@@ -17,6 +17,11 @@ export default function NodesPage() {
   const [newNodeName, setNewNodeName] = useState('')
   const [newToken, setNewToken] = useState('')
 
+  // 编辑状态
+  const [editVisible, setEditVisible] = useState(false)
+  const [editNode, setEditNode] = useState<NodeSummary | null>(null)
+  const [editName, setEditName] = useState('')
+
   const fetchNodes = useCallback(async () => {
     setLoading(true)
     try {
@@ -56,6 +61,21 @@ export default function NodesPage() {
     }
   }
 
+  const handleEdit = async () => {
+    if (!editNode || !editName.trim()) {
+      Message.warning('请输入节点名称')
+      return
+    }
+    try {
+      await updateNode(editNode.id, { name: editName.trim() })
+      Message.success('节点更新成功')
+      setEditVisible(false)
+      fetchNodes()
+    } catch {
+      Message.error('更新节点失败')
+    }
+  }
+
   const columns = [
     {
       title: '节点名称',
@@ -110,15 +130,22 @@ export default function NodesPage() {
     },
     {
       title: '操作',
-      width: 80,
+      width: 120,
-      render: (_: unknown, record: NodeSummary) => {
+      render: (_: unknown, record: NodeSummary) => (
-        if (record.isLocal) return <Text type="secondary">-</Text>
+        <Space>
-        return (
+          <Button
-          <Popconfirm title="确定删除该节点？" onOk={() => handleDelete(record.id)}>
+            type="text"
-            <Button type="text" status="danger" icon={<IconDelete />} size="small" />
+            icon={<IconEdit />}
-          </Popconfirm>
+            size="small"
-        )
+            onClick={() => { setEditNode(record); setEditName(record.name); setEditVisible(true) }}
-      },
+          />
+          {!record.isLocal && (
+            <Popconfirm title="确定删除该节点？" onOk={() => handleDelete(record.id)}>
+              <Button type="text" status="danger" icon={<IconDelete />} size="small" />
+            </Popconfirm>
+          )}
+        </Space>
+      ),
     },
   ]
 
@@ -145,6 +172,7 @@ export default function NodesPage() {
         />
       </Card>
 
+      {/* 添加节点弹窗 */}
       <Modal
         title="添加远程节点"
         visible={createVisible}
@@ -175,6 +203,25 @@ export default function NodesPage() {
           </div>
         )}
       </Modal>
+
+      {/* 编辑节点弹窗 */}
+      <Modal
+        title="编辑节点"
+        visible={editVisible}
+        onCancel={() => setEditVisible(false)}
+        onOk={handleEdit}
+        okText="保存"
+        cancelText="取消"
+      >
+        <div style={{ marginBottom: 8 }}>
+          <Text type="secondary">节点名称</Text>
+        </div>
+        <Input
+          placeholder="输入节点名称"
+          value={editName}
+          onChange={setEditName}
+        />
+      </Modal>
     </div>
   )
 }

web/src/pages/settings/SettingsPage.tsx

@@ -1,4 +1,4 @@
-import { Badge, Button, Card, Descriptions, Grid, Link, PageHeader, Space, Tag, 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, checkUpdate, type SystemInfo, type UpdateCheckResult } from '../../services/system'
 import { resolveErrorMessage } from '../../utils/error'
@@ -107,22 +107,15 @@ export function SettingsPage() {
               <Space>
                 {updateResult.downloadUrl && (
                   <Link href={updateResult.downloadUrl} target="_blank">
-                    <Button type="primary">下载二进制包</Button>
+                    <Button type="outline">下载二进制包</Button>
                   </Link>
                 )}
                 {updateResult.releaseUrl && (
                   <Link href={updateResult.releaseUrl} target="_blank">
-                    <Button type="outline">查看 Release 详情</Button>
+                    <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>

web/src/services/nodes.ts

@@ -16,6 +16,11 @@ export async function createNode(name: string) {
   return unwrapApiEnvelope(response.data)
 }
 
+export async function updateNode(id: number, data: { name: string }) {
+  const response = await http.put<ApiEnvelope<NodeSummary>>(`/nodes/${id}`, data)
+  return unwrapApiEnvelope(response.data)
+}
+
 export async function deleteNode(id: number) {
   const response = await http.delete<ApiEnvelope<null>>(`/nodes/${id}`)
   return unwrapApiEnvelope(response.data)