feat: The certificate list supports sorting by expiration date. (#10372)

Refs https://github.com/1Panel-dev/1Panel/issues/10371

.github/workflows/build-publish-to-oss.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: '20.2'
+          node-version: '22.19.0'
       - name: Build Web
         run: |
           cd frontend && npm install && npm run build:pro

.github/workflows/build-publish-to-r2.yml

@@ -12,7 +12,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: '20.2'
+          node-version: '22.19.0'
       - name: Build Web
         run: |
           cd frontend && npm install && npm run build:pro

.goreleaser.yaml

@@ -32,6 +32,7 @@ builds:
       - arm
       - ppc64le
       - s390x
+      - riscv64
     hooks:
       post:
         - ./ci/script.sh compress_binary {{ .Path }} {{ .Arch }}
@@ -57,6 +58,7 @@ builds:
       - arm
       - ppc64le
       - s390x
+      - riscv64
     hooks:
       post:
         - ./ci/script.sh compress_binary {{ .Path }} {{ .Arch }}

agent/app/api/v2/ai.go

@@ -60,7 +60,7 @@ func (b *BaseApi) RecreateOllamaModel(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /ai/ollama/model/close [post]
+// @Router /ai/ollama/close [post]
 // @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"关闭 Ollama 模型连接 [name]","formatEN":"close conn for Ollama model [name]"}
 func (b *BaseApi) CloseOllamaModel(c *gin.Context) {
 	var req dto.OllamaModelName

agent/app/api/v2/app_install.go

@@ -109,7 +109,7 @@ func (b *BaseApi) LoadPort(c *gin.Context) {
 // @Success 200 {object} response.DatabaseConn
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /apps/installed/conninfo/:key [get]
+// @Router /apps/installed/conninfo [POST]
 func (b *BaseApi) LoadConnInfo(c *gin.Context) {
 	var req dto.OperationWithNameAndType
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

agent/app/api/v2/backup.go

@@ -74,7 +74,7 @@ func (b *BaseApi) RefreshToken(c *gin.Context) {
 // @Success 200 {array} object
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /buckets [post]
+// @Router /backups/buckets [post]
 func (b *BaseApi) ListBuckets(c *gin.Context) {
 	var req dto.ForBuckets
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -133,6 +133,28 @@ func (b *BaseApi) UpdateBackup(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags Backup Account
+// @Summary Upload file for recover
+// @Accept json
+// @Param request body dto.UploadForRecover true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /backups/upload [post]
+// @x-panel-log {"bodyKeys":["filePath"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"上传备份文件 [filePath]","formatEN":"upload backup file [filePath]"}
+func (b *BaseApi) UploadForRecover(c *gin.Context) {
+	var req dto.UploadForRecover
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := backupService.UploadForRecover(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags Backup Account
 // @Summary Load backup account options
 // @Accept json
@@ -273,7 +295,7 @@ func (b *BaseApi) SearchBackupRecordsByCronjob(c *gin.Context) {
 // @Success 200 {string} filePath
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /backup/record/download [post]
+// @Router /backups/record/download [post]
 // @x-panel-log {"bodyKeys":["source","fileName"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"下载备份记录 [source][fileName]","formatEN":"download backup records [source][fileName]"}
 func (b *BaseApi) DownloadRecord(c *gin.Context) {
 	var req dto.DownloadRecord
@@ -296,7 +318,7 @@ func (b *BaseApi) DownloadRecord(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /backup/record/description/update [post]
+// @Router /backups/record/description/update [post]
 func (b *BaseApi) UpdateRecordDescription(c *gin.Context) {
 	var req dto.UpdateDescription
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -317,7 +339,7 @@ func (b *BaseApi) UpdateRecordDescription(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /record/del [post]
+// @Router /backups/record/del [post]
 // @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"backup_records","output_column":"file_name","output_value":"files"}],"formatZH":"删除备份记录 [files]","formatEN":"delete backup records [files]"}
 func (b *BaseApi) DeleteBackupRecord(c *gin.Context) {
 	var req dto.BatchDeleteReq

agent/app/api/v2/clam.go

@@ -104,7 +104,7 @@ func (b *BaseApi) SearchClam(c *gin.Context) {
 // @Success 200 {object} dto.ClamBaseInfo
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /toolbox/clam/base [get]
+// @Router /toolbox/clam/base [post]
 func (b *BaseApi) LoadClamBaseInfo(c *gin.Context) {
 	info, err := clamService.LoadBaseInfo()
 	if err != nil {
@@ -152,7 +152,7 @@ func (b *BaseApi) CleanClamRecord(c *gin.Context) {
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
-	if err := clamService.CleanRecord(req); err != nil {
+	if err := clamService.CleanRecord(req.ID); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
@@ -174,7 +174,7 @@ func (b *BaseApi) SearchClamRecord(c *gin.Context) {
 		return
 	}
 
-	total, list, err := clamService.LoadRecords(req)
+	total, list, err := clamService.SearchRecords(req)
 	if err != nil {
 		helper.InternalServer(c, err)
 		return
@@ -186,29 +186,6 @@ func (b *BaseApi) SearchClamRecord(c *gin.Context) {
 	})
 }
 
-// @Tags Clam
-// @Summary Load clam record detail
-// @Accept json
-// @Param request body dto.ClamLogReq true "request"
-// @Success 200 {string} content
-// @Security ApiKeyAuth
-// @Security Timestamp
-// @Router /toolbox/clam/record/log [post]
-func (b *BaseApi) LoadClamRecordLog(c *gin.Context) {
-	var req dto.ClamLogReq
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	content, err := clamService.LoadRecordLog(req)
-	if err != nil {
-		helper.InternalServer(c, err)
-		return
-	}
-
-	helper.SuccessWithData(c, content)
-}
-
 // @Tags Clam
 // @Summary Load clam file
 // @Accept json
@@ -289,7 +266,7 @@ func (b *BaseApi) HandleClamScan(c *gin.Context) {
 		return
 	}
 
-	if err := clamService.HandleOnce(req); err != nil {
+	if err := clamService.HandleOnce(req.ID); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}

agent/app/api/v2/container.go

@@ -57,7 +57,7 @@ func (b *BaseApi) LoadContainerUsers(c *gin.Context) {
 // @Summary List containers
 // @Accept json
 // @Produce json
-// @Success 200 {array} string
+// @Success 200 {array} dto.ContainerOptions
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /containers/list [post]
@@ -65,6 +65,23 @@ func (b *BaseApi) ListContainer(c *gin.Context) {
 	helper.SuccessWithData(c, containerService.List())
 }
 
+// @Tags Container
+// @Summary List containers by image
+// @Accept json
+// @Produce json
+// @Success 200 {array} dto.ContainerOptions
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /containers/list/byimage [post]
+func (b *BaseApi) ListContainerByImage(c *gin.Context) {
+	var req dto.OperationWithName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	helper.SuccessWithData(c, containerService.ListByImage(req.Name))
+}
+
 // @Tags Container
 // @Summary Load containers status
 // @Accept json
@@ -315,7 +332,7 @@ func (b *BaseApi) ContainerUpgrade(c *gin.Context) {
 // @Summary Clean container
 // @Accept json
 // @Param request body dto.ContainerPrune true "request"
-// @Success 200 {object} dto.ContainerPruneReport
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /containers/prune [post]
@@ -326,12 +343,11 @@ func (b *BaseApi) ContainerPrune(c *gin.Context) {
 		return
 	}
 
-	report, err := containerService.Prune(req)
-	if err != nil {
+	if err := containerService.Prune(req); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
-	helper.SuccessWithData(c, report)
+	helper.Success(c)
 }
 
 // @Tags Container
@@ -681,7 +697,7 @@ func (b *BaseApi) ComposeUpdate(c *gin.Context) {
 // @Param tail query string false "显示行号"
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /containers/search/log [post]
+// @Router /containers/search/log [get]
 func (b *BaseApi) ContainerStreamLogs(c *gin.Context) {
 	c.Header("Content-Type", "text/event-stream")
 	c.Header("Cache-Control", "no-cache")

agent/app/api/v2/cronjob.go

@@ -270,6 +270,28 @@ func (b *BaseApi) UpdateCronjob(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags Cronjob
+// @Summary Update cronjob group
+// @Accept json
+// @Param request body dto.ChangeGroup true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /cronjobs/group/update [post]
+// @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"cronjobs","output_column":"name","output_value":"name"}],"formatZH":"更新计划任务分组 [name]","formatEN":"update cronjob group [name]"}
+func (b *BaseApi) UpdateCronjobGroup(c *gin.Context) {
+	var req dto.ChangeGroup
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := cronjobService.UpdateGroup(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags Cronjob
 // @Summary Update cronjob status
 // @Accept json
@@ -292,30 +314,6 @@ func (b *BaseApi) UpdateCronjobStatus(c *gin.Context) {
 	helper.Success(c)
 }
 
-// @Tags Cronjob
-// @Summary Download cronjob records
-// @Accept json
-// @Param request body dto.CronjobDownload true "request"
-// @Success 200
-// @Security ApiKeyAuth
-// @Security Timestamp
-// @Router /cronjobs/download [post]
-// @x-panel-log {"bodyKeys":["recordID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"recordID","isList":false,"db":"job_records","output_column":"file","output_value":"file"}],"formatZH":"下载计划任务记录 [file]","formatEN":"download the cronjob record [file]"}
-func (b *BaseApi) TargetDownload(c *gin.Context) {
-	var req dto.CronjobDownload
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-
-	filePath, err := cronjobService.Download(req)
-	if err != nil {
-		helper.InternalServer(c, err)
-		return
-	}
-
-	c.File(filePath)
-}
-
 // @Tags Cronjob
 // @Summary Handle cronjob once
 // @Accept json

agent/app/api/v2/dashboard.go

@@ -83,6 +83,38 @@ func (b *BaseApi) UpdateAppLauncher(c *gin.Context) {
 	helper.Success(c)
 }
 
+// @Tags Dashboard
+// @Summary Load quick jump options
+// @Success 200 {Array} dto.QuickJump
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /dashboard/quick/option [get]
+func (b *BaseApi) LoadQuickOption(c *gin.Context) {
+	helper.SuccessWithData(c, dashboardService.LoadQuickOptions())
+}
+
+// @Tags Dashboard
+// @Summary Update quick jump
+// @Accept json
+// @Param request body dto.ChangeQuicks true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /dashboard/quick/change [post]
+// @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"切换快速跳转","formatEN":"change quick jump"}
+func (b *BaseApi) UpdateQuickJump(c *gin.Context) {
+	var req dto.ChangeQuicks
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := dashboardService.ChangeQuick(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
 // @Tags Dashboard
 // @Summary Load dashboard base info
 // @Accept json

agent/app/api/v2/database.go

@@ -160,7 +160,7 @@ func (b *BaseApi) GetDatabase(c *gin.Context) {
 // @Success 200 {array} string
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /db/remote/del/check [post]
+// @Router /databases/db/del/check [post]
 func (b *BaseApi) DeleteCheckDatabase(c *gin.Context) {
 	var req dto.OperateByID
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

agent/app/api/v2/disk.go

@@ -0,0 +1,99 @@
+package v2
+
+import (
+	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
+	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
+	"github.com/gin-gonic/gin"
+)
+
+// @Tags Disk Management
+// @Summary Get complete disk information
+// @Description Get information about all disks including partitioned and unpartitioned disks
+// @Produce json
+// @Success 200 {object} response.CompleteDiskInfo
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/disks [get]
+func (b *BaseApi) GetCompleteDiskInfo(c *gin.Context) {
+	diskInfo, err := diskService.GetCompleteDiskInfo()
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, diskInfo)
+}
+
+// @Tags Disk Management
+// @Summary Partition disk
+// @Description Create partition and format disk with specified filesystem
+// @Accept json
+// @Param request body request.DiskPartitionRequest true "partition request"
+// @Success 200 {string} string "Partition created successfully"
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/disks/partition [post]
+// @x-panel-log {"bodyKeys":["device", "filesystem", "mountPoint"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"对磁盘 [device] 进行分区，文件系统 [filesystem]，挂载点 [mountPoint]","formatEN":"Partition disk [device] with filesystem [filesystem], mount point [mountPoint]"}
+func (b *BaseApi) PartitionDisk(c *gin.Context) {
+	var req request.DiskPartitionRequest
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	result, err := diskService.PartitionDisk(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
+	helper.SuccessWithData(c, result)
+}
+
+// @Tags Disk Management
+// @Summary Mount disk
+// @Description Mount partition to specified mount point
+// @Accept json
+// @Param request body request.DiskMountRequest true "mount request"
+// @Success 200 {string} string "Disk mounted successfully"
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/disks/mount [post]
+// @x-panel-log {"bodyKeys":["device", "mountPoint"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"挂载磁盘 [device] 到 [mountPoint]","formatEN":"Mount disk [device] to [mountPoint]"}
+func (b *BaseApi) MountDisk(c *gin.Context) {
+	var req request.DiskMountRequest
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	err := diskService.MountDisk(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
+	helper.Success(c)
+}
+
+// @Tags Disk Management
+// @Summary Unmount disk
+// @Description Unmount partition from mount point
+// @Accept json
+// @Param request body request.DiskUnmountRequest true "unmount request"
+// @Success 200 {string} string "Disk unmounted successfully"
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/disks/unmount [post]
+// @x-panel-log {"bodyKeys":["device", "mountPoint"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"卸载磁盘 [device] 从 [mountPoint]","formatEN":"Unmount disk [device] from [mountPoint]"}
+func (b *BaseApi) UnmountDisk(c *gin.Context) {
+	var req request.DiskUnmountRequest
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	err := diskService.UnmountDisk(req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+
+	helper.Success(c)
+}

agent/app/api/v2/entry.go

@@ -38,6 +38,7 @@ var (
 	sshService      = service.NewISSHService()
 	firewallService = service.NewIFirewallService()
 	monitorService  = service.NewIMonitorService()
+	systemService   = service.NewISystemService()
 
 	deviceService   = service.NewIDeviceService()
 	fail2banService = service.NewIFail2BanService()
@@ -71,4 +72,6 @@ var (
 	taskService      = service.NewITaskService()
 	groupService     = service.NewIGroupService()
 	alertService     = service.NewIAlertService()
+
+	diskService = service.NewIDiskService()
 )

agent/app/api/v2/file.go

@@ -880,7 +880,7 @@ func (b *BaseApi) GetPathByType(c *gin.Context) {
 // @Success 200 {object} dto.DiskInfo
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mount [post]
+// @Router /files/mount [post]
 func (b *BaseApi) GetHostMount(c *gin.Context) {
 	disks := fileService.GetHostMount()
 	helper.SuccessWithData(c, disks)
@@ -892,7 +892,7 @@ func (b *BaseApi) GetHostMount(c *gin.Context) {
 // @Success 200 {object} response.UserGroupResponse
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /user/group [post]
+// @Router /files/user/group [post]
 func (b *BaseApi) GetUsersAndGroups(c *gin.Context) {
 	res, err := fileService.GetUsersAndGroups()
 	if err != nil {

agent/app/api/v2/firewall.go

@@ -63,7 +63,7 @@ func (b *BaseApi) OperateFirewall(c *gin.Context) {
 		return
 	}
 
-	if err := firewallService.OperateFirewall(req.Operation); err != nil {
+	if err := firewallService.OperateFirewall(req); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}

agent/app/api/v2/group.go

@@ -13,7 +13,7 @@ import (
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /agent/groups [post]
+// @Router /groups [post]
 // @x-panel-log {"bodyKeys":["name","type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建组 [name][type]","formatEN":"create group [name][type]"}
 func (b *BaseApi) CreateGroup(c *gin.Context) {
 	var req dto.GroupCreate
@@ -35,7 +35,7 @@ func (b *BaseApi) CreateGroup(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /agent/groups/del [post]
+// @Router /groups/del [post]
 // @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"groups","output_column":"name","output_value":"name"},{"input_column":"id","input_value":"id","isList":false,"db":"groups","output_column":"type","output_value":"type"}],"formatZH":"删除组 [type][name]","formatEN":"delete group [type][name]"}
 func (b *BaseApi) DeleteGroup(c *gin.Context) {
 	var req dto.OperateByID
@@ -57,7 +57,7 @@ func (b *BaseApi) DeleteGroup(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /agent/groups/update [post]
+// @Router /groups/update [post]
 // @x-panel-log {"bodyKeys":["name","type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新组 [name][type]","formatEN":"update group [name][type]"}
 func (b *BaseApi) UpdateGroup(c *gin.Context) {
 	var req dto.GroupUpdate
@@ -79,7 +79,7 @@ func (b *BaseApi) UpdateGroup(c *gin.Context) {
 // @Success 200 {array} dto.OperateByType
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /agent/groups/search [post]
+// @Router /groups/search [post]
 func (b *BaseApi) ListGroup(c *gin.Context) {
 	var req dto.OperateByType
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

agent/app/api/v2/helper/helper.go

@@ -116,7 +116,11 @@ func CheckBind(req interface{}, c *gin.Context) error {
 	return nil
 }
 
-func ErrResponse(ctx *gin.Context, code int) {
-	ctx.JSON(code, nil)
-	ctx.Abort()
+func GetParamInt32(paramName string, c *gin.Context) (int32, error) {
+	idParam, ok := c.Params.Get(paramName)
+	if !ok {
+		return 0, errors.New("error id in path")
+	}
+	intNum, _ := strconv.Atoi(idParam)
+	return int32(intNum), nil
 }

agent/app/api/v2/host_tool.go

@@ -35,7 +35,7 @@ func (b *BaseApi) GetToolStatus(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /hosts/tool/create [post]
+// @Router /hosts/tool/init [post]
 // @x-panel-log {"bodyKeys":["type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"创建 [type] 配置","formatEN":"create [type] config"}
 func (b *BaseApi) InitToolConfig(c *gin.Context) {
 	var req request.HostToolCreate

agent/app/api/v2/image.go

@@ -9,14 +9,14 @@ import (
 // @Tags Container Image
 // @Summary Page images
 // @Accept json
-// @Param request body dto.SearchWithPage true "request"
+// @Param request body dto.PageImage true "request"
 // @Produce json
 // @Success 200 {object} dto.PageResult
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /containers/image/search [post]
 func (b *BaseApi) SearchImage(c *gin.Context) {
-	var req dto.SearchWithPage
+	var req dto.PageImage
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
@@ -138,7 +138,7 @@ func (b *BaseApi) ImagePush(c *gin.Context) {
 // @Summary Delete image
 // @Accept json
 // @Param request body dto.BatchDelete true "request"
-// @Success 200 {object} dto.ContainerPruneReport
+// @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /containers/image/remove [post]
@@ -149,13 +149,12 @@ func (b *BaseApi) ImageRemove(c *gin.Context) {
 		return
 	}
 
-	data, err := imageService.ImageRemove(req)
-	if err != nil {
+	if err := imageService.ImageRemove(req); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
 
-	helper.SuccessWithData(c, data)
+	helper.Success(c)
 }
 
 // @Tags Container Image

agent/app/api/v2/image_repo.go

@@ -58,7 +58,7 @@ func (b *BaseApi) ListRepo(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /containers/repo/status [get]
+// @Router /containers/repo/status [post]
 func (b *BaseApi) CheckRepoStatus(c *gin.Context) {
 	var req dto.OperateByID
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {

agent/app/api/v2/mcp_server.go

@@ -13,7 +13,7 @@ import (
 // @Success 200 {object} response.McpServersRes
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/search [post]
+// @Router /ai/mcp/search [post]
 func (b *BaseApi) PageMcpServers(c *gin.Context) {
 	var req request.McpServerSearch
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -30,7 +30,7 @@ func (b *BaseApi) PageMcpServers(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/server [post]
+// @Router /ai/mcp/server [post]
 func (b *BaseApi) CreateMcpServer(c *gin.Context) {
 	var req request.McpServerCreate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -51,7 +51,7 @@ func (b *BaseApi) CreateMcpServer(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/server/update [post]
+// @Router /ai/mcp/server/update [post]
 func (b *BaseApi) UpdateMcpServer(c *gin.Context) {
 	var req request.McpServerUpdate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -72,7 +72,7 @@ func (b *BaseApi) UpdateMcpServer(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/server/del [post]
+// @Router /ai/mcp/server/del [post]
 func (b *BaseApi) DeleteMcpServer(c *gin.Context) {
 	var req request.McpServerDelete
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -93,7 +93,7 @@ func (b *BaseApi) DeleteMcpServer(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/server/op [post]
+// @Router /ai/mcp/server/op [post]
 func (b *BaseApi) OperateMcpServer(c *gin.Context) {
 	var req request.McpServerOperate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -114,7 +114,7 @@ func (b *BaseApi) OperateMcpServer(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/domain/bind [post]
+// @Router /ai/mcp/domain/bind [post]
 func (b *BaseApi) BindMcpDomain(c *gin.Context) {
 	var req request.McpBindDomain
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -135,7 +135,7 @@ func (b *BaseApi) BindMcpDomain(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/domain/update [post]
+// @Router /ai/mcp/domain/update [post]
 func (b *BaseApi) UpdateMcpBindDomain(c *gin.Context) {
 	var req request.McpBindDomainUpdate
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -155,7 +155,7 @@ func (b *BaseApi) UpdateMcpBindDomain(c *gin.Context) {
 // @Success 200 {object} response.McpBindDomainRes
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /mcp/domain/get [get]
+// @Router /ai/mcp/domain/get [get]
 func (b *BaseApi) GetMcpBindDomain(c *gin.Context) {
 	res, err := mcpServerService.GetBindDomain()
 	if err != nil {

agent/app/api/v2/monitor.go

@@ -6,8 +6,8 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/gin-gonic/gin"
-	"github.com/shirou/gopsutil/v3/disk"
-	"github.com/shirou/gopsutil/v3/net"
+	"github.com/shirou/gopsutil/v4/disk"
+	"github.com/shirou/gopsutil/v4/net"
 )
 
 // @Tags Monitor

agent/app/api/v2/nginx.go

@@ -129,7 +129,7 @@ func (b *BaseApi) BuildNginx(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /openresty/module/update [post]
+// @Router /openresty/modules/update [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 OpenResty 模块","formatEN":"Update OpenResty module"}
 func (b *BaseApi) UpdateNginxModule(c *gin.Context) {
 	var req request.NginxModuleUpdate
@@ -157,3 +157,39 @@ func (b *BaseApi) GetNginxModules(c *gin.Context) {
 	}
 	helper.SuccessWithData(c, modules)
 }
+
+// @Tags OpenResty
+// @Summary Operate default HTTPs
+// @Accept json
+// @Param request body request.NginxOperateReq true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /openresty/https [post]
+func (b *BaseApi) OperateDefaultHTTPs(c *gin.Context) {
+	var req request.NginxOperateReq
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := nginxService.OperateDefaultHTTPs(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+// @Tags OpenResty
+// @Summary Get default HTTPs status
+// @Success 200 {object} response.NginxConfigRes
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /openresty/https [get]
+func (b *BaseApi) GetDefaultHTTPsStatus(c *gin.Context) {
+	res, err := nginxService.GetDefaultHttpsStatus()
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, res)
+}

agent/app/api/v2/process.go

@@ -36,3 +36,24 @@ func (b *BaseApi) StopProcess(c *gin.Context) {
 	}
 	helper.Success(c)
 }
+
+// @Tags Process
+// @Summary Get Process Info By PID
+// @Param pid path int true "PID"
+// @Success 200 {object} websocket.PsProcessData
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /process/{pid} [get]
+func (b *BaseApi) GetProcessInfoByPID(c *gin.Context) {
+	pid, err := helper.GetParamInt32("pid", c)
+	if err != nil {
+		helper.BadRequest(c, err)
+		return
+	}
+	data, err := processService.GetProcessInfoByPID(pid)
+	if err != nil {
+		helper.BadRequest(c, err)
+		return
+	}
+	helper.SuccessWithData(c, data)
+}

agent/app/api/v2/runtime.go

@@ -81,7 +81,7 @@ func (b *BaseApi) DeleteRuntime(c *gin.Context) {
 // @Success 200 {array} dto.AppResource
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /installed/delete/check/:id [get]
+// @Router /runtimes/installed/delete/check/:id [get]
 func (b *BaseApi) DeleteRuntimeCheck(c *gin.Context) {
 	runTimeId, err := helper.GetIntParamByKey(c, "id")
 	if err != nil {
@@ -459,7 +459,7 @@ func (b *BaseApi) GetSupervisorProcess(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /runtimes/supervisor/process/operate [post]
+// @Router /runtimes/supervisor/process [post]
 func (b *BaseApi) OperateSupervisorProcess(c *gin.Context) {
 	var req request.PHPSupervisorProcessConfig
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -480,7 +480,7 @@ func (b *BaseApi) OperateSupervisorProcess(c *gin.Context) {
 // @Success 200 {string} content
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /runtimes/supervisor/process/file/operate [post]
+// @Router /runtimes/supervisor/process/file [post]
 func (b *BaseApi) OperateSupervisorProcessFile(c *gin.Context) {
 	var req request.PHPSupervisorProcessFileReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -497,7 +497,7 @@ func (b *BaseApi) OperateSupervisorProcessFile(c *gin.Context) {
 // @Tags Runtime
 // @Summary Update PHP container config
 // @Accept json
-// @Param request body request.PHPContainerUpdate true "request"
+// @Param request body request.PHPContainerConfig true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
@@ -518,7 +518,7 @@ func (b *BaseApi) UpdatePHPContainer(c *gin.Context) {
 // @Summary Get PHP container config
 // @Accept json
 // @Param id path integer true "request"
-// @Success 200 {object} response.PHPContainerConfig
+// @Success 200 {object} request.PHPContainerConfig
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /runtimes/php/container/:id [get]
@@ -539,7 +539,7 @@ func (b *BaseApi) GetPHPContainerConfig(c *gin.Context) {
 // @Tags Runtime
 // @Summary Update runtime remark
 // @Accept json
-// @Param request body request.RuntimeRemarkUpdate true "request"
+// @Param request body request.RuntimeRemark true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
@@ -555,3 +555,25 @@ func (b *BaseApi) UpdateRuntimeRemark(c *gin.Context) {
 	}
 	helper.Success(c)
 }
+
+// @Tags Runtime
+// @Summary Get PHP runtime status
+// @Accept json
+// @Param id path integer true "request"
+// @Success 200 {object} map[string]interface{}
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /runtimes/php/fpm/status/:id [get]
+func (b *BaseApi) GetFPMStatus(c *gin.Context) {
+	id, err := helper.GetParamID(c)
+	if err != nil {
+		helper.BadRequest(c, err)
+		return
+	}
+	data, err := runtimeService.GetFPMStatus(id)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, data)
+}

agent/app/api/v2/setting.go

@@ -1,13 +1,12 @@
 package v2
 
 import (
+	"encoding/base64"
 	"encoding/json"
-	"os"
-	"os/user"
-	"path"
 
 	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/utils/ssh"
 	"github.com/gin-gonic/gin"
@@ -71,6 +70,35 @@ func (b *BaseApi) LoadBaseDir(c *gin.Context) {
 	helper.SuccessWithData(c, global.Dir.DataDir)
 }
 
+// @Tags System Setting
+// @Summary Load local conn
+// @Success 200 {object} dto.SSHConnData
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /settings/ssh/conn [get]
+func (b *BaseApi) LoadLocalConn(c *gin.Context) {
+	connInfoInDB := settingService.GetSettingByKey("LocalSSHConn")
+	if len(connInfoInDB) == 0 {
+		helper.Success(c)
+		return
+	}
+	var data dto.SSHConnData
+	if err := json.Unmarshal([]byte(connInfoInDB), &data); err != nil {
+		helper.Success(c)
+		return
+	}
+	if len(data.Password) != 0 {
+		data.Password = base64.StdEncoding.EncodeToString([]byte(data.Password))
+	}
+	if len(data.PrivateKey) != 0 {
+		data.PrivateKey = base64.StdEncoding.EncodeToString([]byte(data.PrivateKey))
+	}
+	if len(data.PassPhrase) != 0 {
+		data.PassPhrase = base64.StdEncoding.EncodeToString([]byte(data.PassPhrase))
+	}
+	helper.SuccessWithData(c, data)
+}
+
 func (b *BaseApi) CheckLocalConn(c *gin.Context) {
 	_, err := loadLocalConn()
 	helper.SuccessWithData(c, err == nil)
@@ -87,6 +115,7 @@ func (b *BaseApi) CheckLocalConnByInfo(c *gin.Context) {
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
+
 	helper.SuccessWithData(c, settingService.TestConnByInfo(req))
 }
 
@@ -96,51 +125,38 @@ func (b *BaseApi) CheckLocalConnByInfo(c *gin.Context) {
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /settings/ssh [post]
-func (b *BaseApi) SaveLocalConnInfo(c *gin.Context) {
+func (b *BaseApi) SaveLocalConn(c *gin.Context) {
 	var req dto.SSHConnData
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
-	helper.SuccessWithData(c, settingService.SaveConnInfo(req))
+
+	if err := settingService.SaveConnInfo(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
 }
 
 func loadLocalConn() (*ssh.SSHClient, error) {
-	itemPath := ""
-	currentInfo, _ := user.Current()
-	if len(currentInfo.HomeDir) == 0 {
-		itemPath = "/root/.ssh/id_ed25519_1panel"
-	} else {
-		itemPath = path.Join(currentInfo.HomeDir, ".ssh/id_ed25519_1panel")
-	}
-	if _, err := os.Stat(itemPath); err != nil {
-		_ = sshService.GenerateSSH(dto.GenerateSSH{EncryptionMode: "ed25519", Name: "_1panel"})
-	}
-
-	privateKey, _ := os.ReadFile(itemPath)
-	connWithKey := ssh.ConnInfo{
-		Addr:       "127.0.0.1",
-		User:       "root",
-		Port:       22,
-		AuthMode:   "key",
-		PrivateKey: privateKey,
-	}
-	client, err := ssh.NewClient(connWithKey)
-	if err == nil {
-		return client, nil
-	}
-
-	connInfoInDB, err := settingService.GetSSHInfo()
-	if err != nil {
-		return nil, err
-	}
+	connInfoInDB := settingService.GetSettingByKey("LocalSSHConn")
 	if len(connInfoInDB) == 0 {
 		return nil, errors.New("no such ssh conn info in db!")
 	}
-	var connInDB ssh.ConnInfo
+	var connInDB model.LocalConnInfo
 	if err := json.Unmarshal([]byte(connInfoInDB), &connInDB); err != nil {
 		return nil, err
 	}
-	return ssh.NewClient(connInDB)
+	sshInfo := ssh.ConnInfo{
+		Addr:       connInDB.Addr,
+		Port:       int(connInDB.Port),
+		User:       connInDB.User,
+		AuthMode:   connInDB.AuthMode,
+		Password:   connInDB.Password,
+		PrivateKey: []byte(connInDB.PrivateKey),
+		PassPhrase: []byte(connInDB.PassPhrase),
+	}
+	return ssh.NewClient(sshInfo)
 }
 
 // @Tags System Setting

agent/app/api/v2/snapshot.go

@@ -36,7 +36,7 @@ func (b *BaseApi) CreateSnapshot(c *gin.Context) {
 		return
 	}
 
-	if err := snapshotService.SnapshotCreate(nil, req, 0, 0, 0); err != nil {
+	if err := snapshotService.SnapshotCreate(nil, req, 0, 3); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
@@ -50,7 +50,7 @@ func (b *BaseApi) CreateSnapshot(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /settings/snapshot/recrete [post]
+// @Router /settings/snapshot/recreate [post]
 // @x-panel-log {"bodyKeys":["id"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"id","isList":false,"db":"snapshots","output_column":"name","output_value":"name"}],"formatZH":"重试创建快照 [name]","formatEN":"recrete the snapshot [name]"}
 func (b *BaseApi) RecreateSnapshot(c *gin.Context) {
 	var req dto.OperateByID

agent/app/api/v2/ssh.go

@@ -1,6 +1,8 @@
 package v2
 
 import (
+	"encoding/base64"
+
 	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/gin-gonic/gin"
@@ -72,7 +74,7 @@ func (b *BaseApi) UpdateSSH(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /hosts/conffile/update [post]
+// @Router /hosts/ssh/conffile/update [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置文件","formatEN":"update SSH conf"}
 func (b *BaseApi) UpdateSSHByfile(c *gin.Context) {
 	var req dto.SSHConf
@@ -90,19 +92,58 @@ func (b *BaseApi) UpdateSSHByfile(c *gin.Context) {
 // @Tags SSH
 // @Summary Generate host SSH secret
 // @Accept json
-// @Param request body dto.GenerateSSH true "request"
+// @Param request body dto.CreateRootCert true "request"
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /hosts/ssh/generate [post]
+// @Router /hosts/ssh/cert [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"生成 SSH 密钥 ","formatEN":"generate SSH secret"}
-func (b *BaseApi) GenerateSSH(c *gin.Context) {
-	var req dto.GenerateSSH
+func (b *BaseApi) CreateRootCert(c *gin.Context) {
+	var req dto.CreateRootCert
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
+	if len(req.PassPhrase) != 0 {
+		passPhrase, err := base64.StdEncoding.DecodeString(req.PassPhrase)
+		if err != nil {
+			helper.BadRequest(c, err)
+			return
+		}
+		req.PassPhrase = string(passPhrase)
+	}
+	if len(req.PrivateKey) != 0 {
+		privateKey, err := base64.StdEncoding.DecodeString(req.PrivateKey)
+		if err != nil {
+			helper.BadRequest(c, err)
+			return
+		}
+		req.PrivateKey = string(privateKey)
+	}
+	if len(req.PublicKey) != 0 {
+		publicKey, err := base64.StdEncoding.DecodeString(req.PublicKey)
+		if err != nil {
+			helper.BadRequest(c, err)
+			return
+		}
+		req.PublicKey = string(publicKey)
+	}
 
-	if err := sshService.GenerateSSH(req); err != nil {
+	if err := sshService.CreateRootCert(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}
+
+// @Tags SSH
+// @Summary Sycn host SSH secret
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/ssh/cert/sync [post]
+// @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"同步 SSH 密钥 ","formatEN":"sync SSH secret"}
+func (b *BaseApi) SyncRootCert(c *gin.Context) {
+	if err := sshService.SyncRootCert(); err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
@@ -112,30 +153,55 @@ func (b *BaseApi) GenerateSSH(c *gin.Context) {
 // @Tags SSH
 // @Summary Load host SSH secret
 // @Accept json
-// @Param request body dto.GenerateLoad true "request"
-// @Success 200 {string} secret
+// @Param request body dto.SearchWithPage true "request"
+// @Success 200 {object} dto.PageResult
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /hosts/ssh/secret [post]
-func (b *BaseApi) LoadSSHSecret(c *gin.Context) {
-	var req dto.GenerateLoad
+// @Router /hosts/ssh/cert/search [post]
+func (b *BaseApi) SearchRootCert(c *gin.Context) {
+	var req dto.SearchWithPage
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
 
-	data, err := sshService.LoadSSHSecret(req.EncryptionMode)
+	total, data, err := sshService.SearchRootCerts(req)
 	if err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
-	helper.SuccessWithData(c, data)
+	helper.SuccessWithData(c, dto.PageResult{
+		Total: total,
+		Items: data,
+	})
+}
+
+// @Tags SSH
+// @Summary Delete host SSH secret
+// @Accept json
+// @Param request body dto.ForceDelete true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/ssh/cert/delete [post]
+// @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"删除 SSH 密钥 ","formatEN":"delete SSH secret"}
+func (b *BaseApi) DeleteRootCert(c *gin.Context) {
+	var req dto.ForceDelete
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := sshService.DeleteRootCerts(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
 }
 
 // @Tags SSH
 // @Summary Load host SSH logs
 // @Accept json
 // @Param request body dto.SearchSSHLog true "request"
-// @Success 200 {object} dto.SSHLog
+// @Success 200 {object} dto.PageResult
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /hosts/ssh/log [post]
@@ -145,12 +211,37 @@ func (b *BaseApi) LoadSSHLogs(c *gin.Context) {
 		return
 	}
 
-	data, err := sshService.LoadLog(c, req)
+	total, data, err := sshService.LoadLog(c, req)
 	if err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
-	helper.SuccessWithData(c, data)
+
+	helper.SuccessWithData(c, dto.PageResult{
+		Total: total,
+		Items: data,
+	})
+}
+
+// @Tags SSH
+// @Summary Export host SSH logs
+// @Accept json
+// @Param request body dto.SearchSSHLog true "request"
+// @Success 200 {string} path
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/ssh/log/export [post]
+func (b *BaseApi) ExportSSHLogs(c *gin.Context) {
+	var req dto.SearchSSHLog
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	tmpFile, err := sshService.ExportLog(c, req)
+	if err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.SuccessWithData(c, tmpFile)
 }
 
 // @Tags SSH

agent/app/api/v2/system.go

@@ -0,0 +1,26 @@
+package v2
+
+import (
+	"errors"
+	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
+	"github.com/gin-gonic/gin"
+)
+
+// @Tags Host
+// @Summary Check if a system component exists
+// @Accept json
+// @Param name query string true "Component name to check (e.g., rsync, docker)"
+// @Success 200 {object} response.ComponentInfo
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /hosts/components/{name} [get]
+func (b *BaseApi) CheckComponentExistence(c *gin.Context) {
+	name := c.Param("name")
+	if name == "" {
+		helper.BadRequest(c, errors.New("empty component name"))
+		return
+	}
+
+	info := systemService.IsComponentExist(name)
+	helper.SuccessWithData(c, info)
+}

agent/app/api/v2/website.go

@@ -527,7 +527,7 @@ func (b *BaseApi) UpdateProxyConfig(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /websites/proxy/file [post]
+// @Router /websites/proxies/file [post]
 // @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"更新反向代理文件 [domain]","formatEN":"Nginx conf proxy file update [domain]"}
 func (b *BaseApi) UpdateProxyConfigFile(c *gin.Context) {
 	var req request.NginxProxyUpdate
@@ -840,7 +840,7 @@ func (b *BaseApi) CreateLoadBalance(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /websites/lbs/delete [post]
+// @Router /websites/lbs/del [post]
 func (b *BaseApi) DeleteLoadBalance(c *gin.Context) {
 	var req request.WebsiteLBDelete
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -953,7 +953,7 @@ func (b *BaseApi) GetProxyCache(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /websites/realip [post]
+// @Router /websites/realip/config [post]
 // @x-panel-log {"bodyKeys":["websiteID"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"websiteID","isList":false,"db":"websites","output_column":"primary_domain","output_value":"domain"}],"formatZH":"修改 [domain] 网站真实IP配置 ","formatEN":"Modify the real IP configuration of [domain] website"}
 func (b *BaseApi) SetRealIPConfig(c *gin.Context) {
 	var req request.WebsiteRealIP
@@ -1121,3 +1121,23 @@ func (b *BaseApi) OperateCrossSiteAccess(c *gin.Context) {
 	}
 	helper.Success(c)
 }
+
+// @Tags Website
+// @Summary Exec Composer
+// @Accept json
+// @Param request body request.ExecComposerReq true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /websites/exec/composer [post]
+func (b *BaseApi) ExecComposer(c *gin.Context) {
+	var req request.ExecComposerReq
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := websiteService.ExecComposer(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}

agent/app/api/v2/website_ssl.go

@@ -1,6 +1,7 @@
 package v2
 
 import (
+	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"net/http"
 	"net/url"
 	"reflect"
@@ -245,3 +246,15 @@ func (b *BaseApi) DownloadWebsiteSSL(c *gin.Context) {
 	c.Header("Content-Disposition", "attachment; filename*=utf-8''"+url.PathEscape(info.Name()))
 	http.ServeContent(c.Writer, c.Request, info.Name(), info.ModTime(), file)
 }
+
+func (b *BaseApi) ImportMasterSSL(c *gin.Context) {
+	var req model.WebsiteSSL
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := websiteSSLService.ImportMasterSSL(req); err != nil {
+		helper.InternalServer(c, err)
+		return
+	}
+	helper.Success(c)
+}

agent/app/dto/alert.go

@@ -36,40 +36,43 @@ type AlertSearch struct {
 }
 
 type AlertDTO struct {
-	ID        uint      `json:"id"`
-	Type      string    `json:"type"`
-	Cycle     uint      `json:"cycle"`
-	Count     uint      `json:"count"`
-	Method    string    `json:"method"`
-	Title     string    `json:"title"`
-	Project   string    `json:"project"`
-	Status    string    `json:"status"`
-	SendCount uint      `json:"sendCount"`
-	CreatedAt time.Time `json:"createdAt"`
-	UpdatedAt time.Time `json:"updatedAt"`
+	ID             uint      `json:"id"`
+	Type           string    `json:"type"`
+	Cycle          uint      `json:"cycle"`
+	Count          uint      `json:"count"`
+	Method         string    `json:"method"`
+	Title          string    `json:"title"`
+	Project        string    `json:"project"`
+	Status         string    `json:"status"`
+	SendCount      uint      `json:"sendCount"`
+	AdvancedParams string    `json:"advancedParams"`
+	CreatedAt      time.Time `json:"createdAt"`
+	UpdatedAt      time.Time `json:"updatedAt"`
 }
 
 type AlertCreate struct {
-	Type      string `json:"type" validate:"required"`
-	Cycle     uint   `json:"cycle"`
-	Count     uint   `json:"count"`
-	Method    string `json:"method" validate:"required"`
-	Title     string `json:"title"`
-	Project   string `json:"project"`
-	Status    string `json:"status"`
-	SendCount uint   `json:"sendCount"`
+	Type           string `json:"type" validate:"required"`
+	Cycle          uint   `json:"cycle"`
+	Count          uint   `json:"count"`
+	Method         string `json:"method" validate:"required"`
+	Title          string `json:"title"`
+	Project        string `json:"project"`
+	Status         string `json:"status"`
+	SendCount      uint   `json:"sendCount"`
+	AdvancedParams string `json:"advancedParams"`
 }
 
 type AlertUpdate struct {
-	ID        uint   `json:"id" validate:"required"`
-	Type      string `json:"type"`
-	Cycle     uint   `json:"cycle"`
-	Count     uint   `json:"count"`
-	Method    string `json:"method"`
-	Title     string `json:"title"`
-	Project   string `json:"project"`
-	Status    string `json:"status"`
-	SendCount uint   `json:"sendCount"`
+	ID             uint   `json:"id" validate:"required"`
+	Type           string `json:"type"`
+	Cycle          uint   `json:"cycle"`
+	Count          uint   `json:"count"`
+	Method         string `json:"method"`
+	Title          string `json:"title"`
+	Project        string `json:"project"`
+	Status         string `json:"status"`
+	SendCount      uint   `json:"sendCount"`
+	AdvancedParams string `json:"advancedParams"`
 }
 
 type DeleteRequest struct {

agent/app/dto/backup.go

@@ -53,6 +53,11 @@ type BackupOption struct {
 	IsPublic bool   `json:"isPublic"`
 }
 
+type UploadForRecover struct {
+	FilePath  string `json:"filePath"`
+	TargetDir string `json:"targetDir"`
+}
+
 type CommonBackup struct {
 	Type       string `json:"type" validate:"required,oneof=app mysql mariadb redis website postgresql mysql-cluster postgresql-cluster redis-cluster"`
 	Name       string `json:"name"`

agent/app/dto/clam.go

@@ -30,7 +30,8 @@ type ClamInfo struct {
 	Path             string `json:"path"`
 	InfectedStrategy string `json:"infectedStrategy"`
 	InfectedDir      string `json:"infectedDir"`
-	LastHandleDate   string `json:"lastHandleDate"`
+	LastRecordStatus string `json:"lastRecordStatus"`
+	LastRecordTime   string `json:"lastRecordTime"`
 	Spec             string `json:"spec"`
 	Description      string `json:"description"`
 	AlertCount       uint   `json:"alertCount"`
@@ -41,6 +42,7 @@ type ClamLogSearch struct {
 	PageInfo
 
 	ClamID    uint      `json:"clamID"`
+	Status    string    `json:"status"`
 	StartTime time.Time `json:"startTime"`
 	EndTime   time.Time `json:"endTime"`
 }
@@ -56,13 +58,16 @@ type ClamFileReq struct {
 	Name string `json:"name" validate:"required"`
 }
 
-type ClamLog struct {
-	Name          string `json:"name"`
-	ScanDate      string `json:"scanDate"`
-	ScanTime      string `json:"scanTime"`
-	InfectedFiles string `json:"infectedFiles"`
-	TotalError    string `json:"totalError"`
-	Status        string `json:"status"`
+type ClamRecord struct {
+	ID            uint      `json:"id"`
+	TaskID        string    `json:"taskID"`
+	StartTime     time.Time `json:"startTime"`
+	ScanTime      string    `json:"scanTime"`
+	InfectedFiles string    `json:"infectedFiles"`
+	TotalError    string    `json:"totalError"`
+
+	Status  string `json:"status"`
+	Message string `json:"message"`
 }
 
 type ClamCreate struct {
@@ -98,7 +103,6 @@ type ClamUpdateStatus struct {
 }
 
 type ClamDelete struct {
-	RemoveRecord   bool   `json:"removeRecord"`
 	RemoveInfected bool   `json:"removeInfected"`
 	Ids            []uint `json:"ids" validate:"required"`
 }

agent/app/dto/common_req.go

@@ -79,3 +79,8 @@ type ForceDelete struct {
 	IDs         []uint `json:"ids"`
 	ForceDelete bool   `json:"forceDelete"`
 }
+
+type ChangeGroup struct {
+	ID      uint `json:"id" validate:"required"`
+	GroupID uint `json:"groupID" validate:"required"`
+}

agent/app/dto/container.go

@@ -107,10 +107,10 @@ type ContainerCreateByCommand struct {
 }
 
 type ContainerUpgrade struct {
-	TaskID    string `json:"taskID"`
-	Name      string `json:"name" validate:"required"`
-	Image     string `json:"image" validate:"required"`
-	ForcePull bool   `json:"forcePull"`
+	TaskID    string   `json:"taskID"`
+	Names     []string `json:"names" validate:"required"`
+	Image     string   `json:"image" validate:"required"`
+	ForcePull bool     `json:"forcePull"`
 }
 
 type ContainerListStats struct {
@@ -174,15 +174,11 @@ type ContainerCommit struct {
 }
 
 type ContainerPrune struct {
+	TaskID     string `json:"taskID"`
 	PruneType  string `json:"pruneType" validate:"required,oneof=container image volume network buildcache"`
 	WithTagAll bool   `json:"withTagAll"`
 }
 
-type ContainerPruneReport struct {
-	DeletedNumber  int `json:"deletedNumber"`
-	SpaceReclaimed int `json:"spaceReclaimed"`
-}
-
 type Network struct {
 	ID         string    `json:"id"`
 	Name       string    `json:"name"`
@@ -213,11 +209,12 @@ type NetworkCreate struct {
 }
 
 type Volume struct {
-	Name       string    `json:"name"`
-	Labels     []string  `json:"labels"`
-	Driver     string    `json:"driver"`
-	Mountpoint string    `json:"mountpoint"`
-	CreatedAt  time.Time `json:"createdAt"`
+	Name       string         `json:"name"`
+	Labels     []VolumeOption `json:"labels"`
+	Driver     string         `json:"driver"`
+	Mountpoint string         `json:"mountpoint"`
+	CreatedAt  time.Time      `json:"createdAt"`
+	Options    []VolumeOption `json:"options"`
 }
 type VolumeCreate struct {
 	Name    string   `json:"name" validate:"required"`
@@ -225,22 +222,27 @@ type VolumeCreate struct {
 	Options []string `json:"options"`
 	Labels  []string `json:"labels"`
 }
-
+type VolumeOption struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
 type BatchDelete struct {
-	Force bool     `json:"force"`
-	Names []string `json:"names" validate:"required"`
+	TaskID string   `json:"taskID"`
+	Force  bool     `json:"force"`
+	Names  []string `json:"names" validate:"required"`
 }
 
 type ComposeInfo struct {
-	Name            string             `json:"name"`
-	CreatedAt       string             `json:"createdAt"`
-	CreatedBy       string             `json:"createdBy"`
-	ContainerNumber int                `json:"containerNumber"`
-	ConfigFile      string             `json:"configFile"`
-	Workdir         string             `json:"workdir"`
-	Path            string             `json:"path"`
-	Containers      []ComposeContainer `json:"containers"`
-	Env             []string           `json:"env"`
+	Name           string             `json:"name"`
+	CreatedAt      string             `json:"createdAt"`
+	CreatedBy      string             `json:"createdBy"`
+	ContainerCount int                `json:"containerCount"`
+	RunningCount   int                `json:"runningCount"`
+	ConfigFile     string             `json:"configFile"`
+	Workdir        string             `json:"workdir"`
+	Path           string             `json:"path"`
+	Containers     []ComposeContainer `json:"containers"`
+	Env            []string           `json:"env"`
 }
 type ComposeContainer struct {
 	ContainerID string `json:"containerID"`
@@ -260,8 +262,9 @@ type ComposeCreate struct {
 type ComposeOperation struct {
 	Name      string `json:"name" validate:"required"`
 	Path      string `json:"path"`
-	Operation string `json:"operation" validate:"required,oneof=up start stop down delete"`
+	Operation string `json:"operation" validate:"required,oneof=up start restart stop down delete"`
 	WithFile  bool   `json:"withFile"`
+	Force     bool   `josn:"force"`
 }
 type ComposeUpdate struct {
 	Name    string   `json:"name" validate:"required"`

agent/app/dto/cronjob.go

@@ -6,9 +6,10 @@ import (
 
 type PageCronjob struct {
 	PageInfo
-	Info    string `json:"info"`
-	OrderBy string `json:"orderBy" validate:"required,oneof=name status createdAt"`
-	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
+	Info     string `json:"info"`
+	GroupIDs []uint `json:"groupIDs"`
+	OrderBy  string `json:"orderBy" validate:"required,oneof=name status createdAt"`
+	Order    string `json:"order" validate:"required,oneof=null ascending descending"`
 }
 
 type CronjobSpec struct {
@@ -19,6 +20,7 @@ type CronjobOperate struct {
 	ID         uint   `json:"id"`
 	Name       string `json:"name" validate:"required"`
 	Type       string `json:"type" validate:"required"`
+	GroupID    uint   `json:"groupID"`
 	SpecCustom bool   `json:"specCustom"`
 	Spec       string `json:"spec" validate:"required"`
 
@@ -63,11 +65,6 @@ type CronjobUpdateStatus struct {
 	Status string `json:"status" validate:"required"`
 }
 
-type CronjobDownload struct {
-	RecordID        uint `json:"recordID" validate:"required"`
-	BackupAccountID uint `json:"backupAccountID" validate:"required"`
-}
-
 type CronjobClean struct {
 	IsDelete        bool `json:"isDelete"`
 	CleanData       bool `json:"cleanData"`
@@ -85,6 +82,7 @@ type CronjobInfo struct {
 	ID         uint   `json:"id"`
 	Name       string `json:"name"`
 	Type       string `json:"type"`
+	GroupID    uint   `json:"groupID"`
 	SpecCustom bool   `json:"specCustom"`
 	Spec       string `json:"spec"`
 
@@ -129,6 +127,7 @@ type CronjobImport struct {
 type CronjobTrans struct {
 	Name       string `json:"name"`
 	Type       string `json:"type"`
+	GroupID    uint   `json:"groupID"`
 	SpecCustom bool   `json:"specCustom"`
 	Spec       string `json:"spec"`
 

agent/app/dto/dashboard.go

@@ -23,9 +23,24 @@ type DashboardBase struct {
 	CPULogicalCores int    `json:"cpuLogicalCores"`
 	CPUModelName    string `json:"cpuModelName"`
 
+	QuickJumps  []QuickJump      `json:"quickJump"`
 	CurrentInfo DashboardCurrent `json:"currentInfo"`
 }
 
+type ChangeQuicks struct {
+	Quicks []QuickJump `json:"quicks"`
+}
+
+type QuickJump struct {
+	ID        uint   `json:"id"`
+	Name      string `json:"name"`
+	Title     string `json:"title"`
+	Detail    string `json:"detail"`
+	Recommend int    `json:"recommend"`
+	IsShow    bool   `json:"isShow"`
+	Router    string `json:"router"`
+}
+
 type OsInfo struct {
 	OS             string `json:"os"`
 	Platform       string `json:"platform"`

agent/app/dto/database.go

@@ -4,14 +4,14 @@ import "time"
 
 // common
 type DBConfUpdateByFile struct {
-	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql redis mysql-cluster postgresql-cluster"`
+	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql redis mysql-cluster postgresql-cluster redis-cluster"`
 	Database string `json:"database" validate:"required"`
 	File     string `json:"file"`
 }
 type ChangeDBInfo struct {
 	ID       uint   `json:"id"`
 	From     string `json:"from" validate:"required,oneof=local remote"`
-	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql mysql-cluster postgresql-cluster"`
+	Type     string `json:"type" validate:"required,oneof=mysql mariadb postgresql redis mysql-cluster postgresql-cluster redis-cluster"`
 	Database string `json:"database" validate:"required"`
 	Value    string `json:"value" validate:"required"`
 }
@@ -260,6 +260,7 @@ type DatabaseInfo struct {
 	ClientCert string `json:"clientCert"`
 	SkipVerify bool   `json:"skipVerify"`
 
+	Timeout     uint   `json:"timeout"`
 	Description string `json:"description"`
 }
 
@@ -295,6 +296,7 @@ type DatabaseCreate struct {
 	ClientCert string `json:"clientCert"`
 	SkipVerify bool   `json:"skipVerify"`
 
+	Timeout     uint   `json:"timeout"`
 	Description string `json:"description"`
 }
 
@@ -313,6 +315,7 @@ type DatabaseUpdate struct {
 	ClientCert string `json:"clientCert"`
 	SkipVerify bool   `json:"skipVerify"`
 
+	Timeout     uint   `json:"timeout"`
 	Description string `json:"description"`
 }
 
@@ -326,3 +329,8 @@ type LoadRedisStatus struct {
 	Name string `json:"name" validate:"required"`
 	Type string `json:"type" validate:"required"`
 }
+
+type DBResource struct {
+	Type string `json:"type"`
+	Name string `json:"name"`
+}

agent/app/dto/database_postgresql.go

@@ -60,26 +60,20 @@ type PostgresqlPrivileges struct {
 
 type PostgresqlLoadDB struct {
 	From     string `json:"from" validate:"required,oneof=local remote"`
-	Type     string `json:"type" validate:"required,oneof=postgresql"`
+	Type     string `json:"type" validate:"required,oneof=postgresql postgresql-cluster"`
 	Database string `json:"database" validate:"required"`
 }
 
 type PostgresqlDBDeleteCheck struct {
 	ID       uint   `json:"id" validate:"required"`
-	Type     string `json:"type" validate:"required,oneof=postgresql"`
+	Type     string `json:"type" validate:"required,oneof=postgresql postgresql-cluster"`
 	Database string `json:"database" validate:"required"`
 }
 
 type PostgresqlDBDelete struct {
 	ID           uint   `json:"id" validate:"required"`
-	Type         string `json:"type" validate:"required,oneof=postgresql"`
+	Type         string `json:"type" validate:"required,oneof=postgresql postgresql-cluster"`
 	Database     string `json:"database" validate:"required"`
 	ForceDelete  bool   `json:"forceDelete"`
 	DeleteBackup bool   `json:"deleteBackup"`
 }
-
-type PostgresqlConfUpdateByFile struct {
-	Type     string `json:"type" validate:"required,oneof=postgresql mariadb"`
-	Database string `json:"database" validate:"required"`
-	File     string `json:"file"`
-}

agent/app/dto/disk.go

@@ -0,0 +1,25 @@
+package dto
+
+type LsblkDevice struct {
+	Name       string        `json:"name"`
+	Size       string        `json:"size"`
+	Type       string        `json:"type"`
+	MountPoint *string       `json:"mountpoint"`
+	FsType     *string       `json:"fstype"`
+	Model      *string       `json:"model"`
+	Serial     string        `json:"serial"`
+	Tran       string        `json:"tran"`
+	Rota       bool          `json:"rota"`
+	Children   []LsblkDevice `json:"children,omitempty"`
+}
+
+type LsblkOutput struct {
+	BlockDevices []LsblkDevice `json:"blockdevices"`
+}
+
+type DiskFormatRequest struct {
+	Device      string `json:"device" `
+	Filesystem  string `json:"filesystem" `
+	Label       string `json:"label,omitempty" `
+	QuickFormat bool   `json:"quickFormat,omitempty"`
+}

agent/app/dto/file.go

@@ -0,0 +1,8 @@
+package dto
+
+type LogFileRes struct {
+	Lines       []string `json:"lines"`
+	IsEndOfFile bool     `json:"isEndOfFile"`
+	TotalPages  int      `json:"totalPages"`
+	TotalLines  int      `json:"totalLines"`
+}

agent/app/dto/firewall.go

@@ -17,7 +17,8 @@ type RuleSearch struct {
 }
 
 type FirewallOperation struct {
-	Operation string `json:"operation" validate:"required,oneof=start stop restart disablePing enablePing"`
+	Operation         string `json:"operation" validate:"required,oneof=start stop restart disablePing enablePing"`
+	WithDockerRestart bool   `json:"withDockerRestart"`
 }
 
 type PortRuleOperate struct {

agent/app/dto/image.go

@@ -2,12 +2,19 @@ package dto
 
 import "time"
 
+type PageImage struct {
+	PageInfo
+	Name    string `json:"name"`
+	OrderBy string `json:"orderBy" validate:"required,oneof=size tags createdAt isUsed"`
+	Order   string `json:"order" validate:"required,oneof=null ascending descending"`
+}
+
 type ImageInfo struct {
 	ID        string    `json:"id"`
 	CreatedAt time.Time `json:"createdAt"`
 	IsUsed    bool      `json:"isUsed"`
 	Tags      []string  `json:"tags"`
-	Size      string    `json:"size"`
+	Size      int64     `json:"size"`
 }
 
 type ImageLoad struct {

agent/app/dto/request/app.go

@@ -40,6 +40,7 @@ type AppContainerConfig struct {
 	WebUI         string  `json:"webUI"`
 	Type          string  `json:"type"`
 	SpecifyIP     string  `json:"specifyIP"`
+	RestartPolicy string  `json:"restartPolicy" validate:"omitempty,oneof=always unless-stopped no on-failure"`
 }
 
 type AppInstalledSearch struct {

agent/app/dto/request/disk.go

@@ -0,0 +1,20 @@
+package request
+
+type DiskPartitionRequest struct {
+	Device     string `json:"device" validate:"required"`
+	Filesystem string `json:"filesystem" validate:"required,oneof=ext4 xfs"`
+	Label      string `json:"label"`
+	AutoMount  bool   `json:"autoMount"`
+	MountPoint string `json:"mountPoint" validate:"required"`
+}
+
+type DiskMountRequest struct {
+	Device     string `json:"device" validate:"required"`
+	MountPoint string `json:"mountPoint" validate:"required"`
+	Filesystem string `json:"filesystem" validate:"required,oneof=ext4 xfs"`
+	AutoMount  bool   `json:"autoMount"`
+}
+
+type DiskUnmountRequest struct {
+	MountPoint string `json:"mountPoint" validate:"required"`
+}

agent/app/dto/request/host_tool.go

@@ -33,6 +33,7 @@ type SupervisorProcessConfig struct {
 	Dir         string `json:"dir"`
 	Numprocs    string `json:"numprocs"`
 	AutoRestart string `json:"autoRestart"`
+	AutoStart   string `json:"autoStart"`
 }
 
 type SupervisorProcessFileReq struct {

agent/app/dto/request/mcp_server.go

@@ -9,15 +9,18 @@ type McpServerSearch struct {
 }
 
 type McpServerCreate struct {
-	Name          string        `json:"name" validate:"required"`
-	Command       string        `json:"command" validate:"required"`
-	Environments  []Environment `json:"environments"`
-	Volumes       []Volume      `json:"volumes"`
-	Port          int           `json:"port" validate:"required"`
-	ContainerName string        `json:"containerName"`
-	BaseURL       string        `json:"baseUrl"`
-	SsePath       string        `json:"ssePath"`
-	HostIP        string        `json:"hostIP"`
+	Name               string        `json:"name" validate:"required"`
+	Command            string        `json:"command" validate:"required"`
+	Environments       []Environment `json:"environments"`
+	Volumes            []Volume      `json:"volumes"`
+	Port               int           `json:"port" validate:"required"`
+	ContainerName      string        `json:"containerName"`
+	BaseURL            string        `json:"baseUrl"`
+	SsePath            string        `json:"ssePath"`
+	HostIP             string        `json:"hostIP"`
+	StreamableHttpPath string        `json:"streamableHttpPath"`
+	OutputTransport    string        `json:"outputTransport" validate:"required"`
+	Type               string        `json:"type" validate:"required"`
 }
 
 type McpServerUpdate struct {

agent/app/dto/request/nginx.go

@@ -81,8 +81,8 @@ type NginxCommonReq struct {
 
 type NginxAntiLeechUpdate struct {
 	WebsiteID   uint     `json:"websiteID" validate:"required"`
-	Extends     string   `json:"extends" validate:"required"`
-	Return      string   `json:"return" validate:"required"`
+	Extends     string   `json:"extends"`
+	Return      string   `json:"return"`
 	Enable      bool     `json:"enable" `
 	ServerNames []string `json:"serverNames"`
 	Cache       bool     `json:"cache"`
@@ -126,3 +126,7 @@ type NginxModuleUpdate struct {
 	Enable   bool   `json:"enable"`
 	Params   string `json:"params"`
 }
+
+type NginxOperateReq struct {
+	Operate string `json:"operate" validate:"required,oneof=enable disable"`
+}

agent/app/dto/request/website.go

@@ -152,21 +152,22 @@ type WebsiteDomainDelete struct {
 }
 
 type WebsiteHTTPSOp struct {
-	WebsiteID       uint     `json:"websiteId" validate:"required"`
-	Enable          bool     `json:"enable"`
-	WebsiteSSLID    uint     `json:"websiteSSLId"`
-	Type            string   `json:"type"  validate:"oneof=existed auto manual"`
-	PrivateKey      string   `json:"privateKey"`
-	Certificate     string   `json:"certificate"`
-	PrivateKeyPath  string   `json:"privateKeyPath"`
-	CertificatePath string   `json:"certificatePath"`
-	ImportType      string   `json:"importType"`
-	HttpConfig      string   `json:"httpConfig"  validate:"oneof=HTTPSOnly HTTPAlso HTTPToHTTPS"`
-	SSLProtocol     []string `json:"SSLProtocol"`
-	Algorithm       string   `json:"algorithm"`
-	Hsts            bool     `json:"hsts"`
-	HttpsPorts      []int    `json:"httpsPorts"`
-	Http3           bool     `json:"http3"`
+	WebsiteID             uint     `json:"websiteId" validate:"required"`
+	Enable                bool     `json:"enable"`
+	WebsiteSSLID          uint     `json:"websiteSSLId"`
+	Type                  string   `json:"type"  validate:"oneof=existed auto manual"`
+	PrivateKey            string   `json:"privateKey"`
+	Certificate           string   `json:"certificate"`
+	PrivateKeyPath        string   `json:"privateKeyPath"`
+	CertificatePath       string   `json:"certificatePath"`
+	ImportType            string   `json:"importType"`
+	HttpConfig            string   `json:"httpConfig"  validate:"oneof=HTTPSOnly HTTPAlso HTTPToHTTPS"`
+	SSLProtocol           []string `json:"SSLProtocol"`
+	Algorithm             string   `json:"algorithm"`
+	Hsts                  bool     `json:"hsts"`
+	HstsIncludeSubDomains bool     `json:"hstsIncludeSubDomains"`
+	HttpsPorts            []int    `json:"httpsPorts"`
+	Http3                 bool     `json:"http3"`
 }
 
 type WebsiteNginxUpdate struct {
@@ -203,22 +204,24 @@ type WebsiteUpdateDirPermission struct {
 }
 
 type WebsiteProxyConfig struct {
-	ID           uint              `json:"id" validate:"required"`
-	Operate      string            `json:"operate" validate:"required"`
-	Enable       bool              `json:"enable" `
-	Cache        bool              `json:"cache" `
-	CacheTime    int               `json:"cacheTime"  `
-	CacheUnit    string            `json:"cacheUnit"`
-	Name         string            `json:"name" validate:"required"`
-	Modifier     string            `json:"modifier"`
-	Match        string            `json:"match" validate:"required"`
-	ProxyPass    string            `json:"proxyPass" validate:"required"`
-	ProxyHost    string            `json:"proxyHost" validate:"required"`
-	Content      string            `json:"content"`
-	FilePath     string            `json:"filePath"`
-	Replaces     map[string]string `json:"replaces"`
-	SNI          bool              `json:"sni"`
-	ProxySSLName string            `json:"proxySSLName"`
+	ID              uint              `json:"id" validate:"required"`
+	Operate         string            `json:"operate" validate:"required"`
+	Enable          bool              `json:"enable" `
+	Cache           bool              `json:"cache" `
+	CacheTime       int               `json:"cacheTime"`
+	CacheUnit       string            `json:"cacheUnit"`
+	ServerCacheTime int               `json:"serverCacheTime"`
+	ServerCacheUnit string            `json:"serverCacheUnit"`
+	Name            string            `json:"name" validate:"required"`
+	Modifier        string            `json:"modifier"`
+	Match           string            `json:"match" validate:"required"`
+	ProxyPass       string            `json:"proxyPass" validate:"required"`
+	ProxyHost       string            `json:"proxyHost" validate:"required"`
+	Content         string            `json:"content"`
+	FilePath        string            `json:"filePath"`
+	Replaces        map[string]string `json:"replaces"`
+	SNI             bool              `json:"sni"`
+	ProxySSLName    string            `json:"proxySSLName"`
 }
 
 type WebsiteProxyReq struct {
@@ -283,8 +286,8 @@ type WebsiteRealIP struct {
 
 type ChangeDatabase struct {
 	WebsiteID    uint   `json:"websiteID" validate:"required"`
-	DatabaseID   uint   `json:"databaseID" validate:"required"`
-	DatabaseType string `json:"databaseType" validate:"required"`
+	DatabaseID   uint   `json:"databaseID" `
+	DatabaseType string `json:"databaseType" `
 }
 
 type WebsiteProxyDel struct {
@@ -296,3 +299,13 @@ type CrossSiteAccessOp struct {
 	WebsiteID uint   `json:"websiteID" validate:"required"`
 	Operation string `json:"operation" validate:"required,oneof=Enable Disable"`
 }
+
+type ExecComposerReq struct {
+	Command    string `json:"command" validate:"required"`
+	ExtCommand string `json:"extCommand"`
+	Mirror     string `json:"mirror" validate:"required"`
+	Dir        string `json:"dir" validate:"required"`
+	User       string `json:"user" validate:"required"`
+	WebsiteID  uint   `json:"websiteID" validate:"required"`
+	TaskID     string `json:"taskID" validate:"required"`
+}

agent/app/dto/request/website_ssl.go

@@ -6,6 +6,8 @@ type WebsiteSSLSearch struct {
 	dto.PageInfo
 	AcmeAccountID string `json:"acmeAccountID"`
 	Domain        string `json:"domain"`
+	OrderBy       string `json:"orderBy" validate:"required,oneof=expire_date"`
+	Order         string `json:"order" validate:"required,oneof=null ascending descending"`
 }
 
 type WebsiteSSLCreate struct {
@@ -27,6 +29,8 @@ type WebsiteSSLCreate struct {
 	Nameserver2   string `json:"nameserver2"`
 	ExecShell     bool   `json:"execShell"`
 	Shell         string `json:"shell"`
+	PushNode      bool   `json:"pushNode"`
+	Nodes         string `json:"nodes"`
 }
 
 type WebsiteDNSReq struct {
@@ -105,6 +109,8 @@ type WebsiteSSLUpdate struct {
 	Nameserver2   string `json:"nameserver2"`
 	ExecShell     bool   `json:"execShell"`
 	Shell         string `json:"shell"`
+	PushNode      bool   `json:"pushNode"`
+	Nodes         string `json:"nodes"`
 }
 
 type WebsiteSSLUpload struct {

agent/app/dto/response/app.go

@@ -66,6 +66,7 @@ type AppInstalledCheck struct {
 	InstallPath   string    `json:"installPath"`
 	HttpPort      int       `json:"httpPort"`
 	HttpsPort     int       `json:"httpsPort"`
+	WebsiteDir    string    `json:"websiteDir"`
 }
 
 type AppDetailDTO struct {

agent/app/dto/response/app_ignore_upgrade.go

@@ -6,5 +6,5 @@ type AppIgnoreUpgradeDTO struct {
 	AppDetailID uint   `json:"appDetailID"`
 	Scope       string `json:"scope"`
 	Version     string `json:"version"`
-	Icon        string `json:"icon"`
+	Name        string `json:"name"`
 }

agent/app/dto/response/disk.go

@@ -0,0 +1,37 @@
+package response
+
+type DiskInfo struct {
+	DiskBasicInfo
+	Partitions []DiskBasicInfo `json:"partitions"`
+}
+
+type DiskBasicInfo struct {
+	Device      string `json:"device"`
+	Size        string `json:"size"`
+	Model       string `json:"model"`
+	DiskType    string `json:"diskType"`
+	IsRemovable bool   `json:"isRemovable"`
+	IsSystem    bool   `json:"isSystem"`
+	Filesystem  string `json:"filesystem"`
+	Used        string `json:"used"`
+	Avail       string `json:"avail"`
+	UsePercent  int    `json:"usePercent"`
+	MountPoint  string `json:"mountPoint"`
+	IsMounted   bool   `json:"isMounted"`
+	Serial      string `json:"serial"`
+}
+
+type CompleteDiskInfo struct {
+	Disks              []DiskInfo      `json:"disks"`
+	UnpartitionedDisks []DiskBasicInfo `json:"unpartitionedDisks"`
+	SystemDisk         *DiskInfo       `json:"systemDisk"`
+	TotalDisks         int             `json:"totalDisks"`
+	TotalCapacity      int64           `json:"totalCapacity"`
+}
+
+type MountInfo struct {
+	Device     string `json:"device"`
+	MountPoint string `json:"mountPoint"`
+	Filesystem string `json:"filesystem"`
+	Options    string `json:"options"`
+}

agent/app/dto/response/file.go

@@ -38,12 +38,13 @@ type FileWgetRes struct {
 }
 
 type FileLineContent struct {
-	Content    string   `json:"content"`
 	End        bool     `json:"end"`
 	Path       string   `json:"path"`
 	Total      int      `json:"total"`
 	TaskStatus string   `json:"taskStatus"`
 	Lines      []string `json:"lines"`
+	Scope      string   `json:"scope"`
+	TotalLines int      `json:"totalLines"`
 }
 
 type FileExist struct {

agent/app/dto/response/host_tool.go

@@ -31,6 +31,7 @@ type SupervisorProcessConfig struct {
 	Msg         string          `json:"msg"`
 	Status      []ProcessStatus `json:"status"`
 	AutoRestart string          `json:"autoRestart"`
+	AutoStart   string          `json:"autoStart"`
 }
 
 type ProcessStatus struct {

agent/app/dto/response/nginx.go

@@ -80,3 +80,7 @@ type NginxBuildConfig struct {
 	Mirror  string        `json:"mirror"`
 	Modules []NginxModule `json:"modules"`
 }
+
+type NginxConfigRes struct {
+	Https bool `json:"https"`
+}

agent/app/dto/response/runtime.go

@@ -78,3 +78,8 @@ type PHPExtensionRes struct {
 	Extensions        []string           `json:"extensions"`
 	SupportExtensions []SupportExtension `json:"supportExtensions"`
 }
+
+type FpmStatusItem struct {
+	Key   string      `json:"key"`
+	Value interface{} `json:"value"`
+}

agent/app/dto/response/system.go

@@ -0,0 +1,8 @@
+package response
+
+type ComponentInfo struct {
+	Exists  bool   `json:"exists"`
+	Version string `json:"version"`
+	Path    string `json:"path"`
+	Error   string `json:"error"`
+}

agent/app/dto/response/website.go

@@ -37,6 +37,7 @@ type WebsiteRes struct {
 	ChildSites    []string  `json:"childSites"`
 	RuntimeType   string    `json:"runtimeType"`
 	Favorite      bool      `json:"favorite"`
+	IPV6          bool      `json:"IPV6"`
 }
 
 type WebsiteOption struct {
@@ -64,6 +65,7 @@ type WebsiteHTTPS struct {
 	SSLProtocol []string         `json:"SSLProtocol"`
 	Algorithm   string           `json:"algorithm"`
 	Hsts        bool             `json:"hsts"`
+	HstsIncludeSubDomains         bool             `json:"hstsIncludeSubDomains"`
 	HttpsPorts  []int            `json:"httpsPorts"`
 	HttpsPort   string           `json:"httpsPort"`
 	Http3       bool             `json:"http3"`

agent/app/dto/ssh.go

@@ -19,12 +19,27 @@ type SSHInfo struct {
 	PubkeyAuthentication   string `json:"pubkeyAuthentication"`
 	PermitRootLogin        string `json:"permitRootLogin"`
 	UseDNS                 string `json:"useDNS"`
+	CurrentUser            string `json:"currentUser"`
 }
 
-type GenerateSSH struct {
-	EncryptionMode string `json:"encryptionMode" validate:"required,oneof=rsa ed25519 ecdsa dsa"`
-	Password       string `json:"password"`
+type CreateRootCert struct {
 	Name           string `json:"name"`
+	Mode           string `json:"mode"`
+	EncryptionMode string `json:"encryptionMode" validate:"required,oneof=rsa ed25519 ecdsa dsa"`
+	PassPhrase     string `json:"passPhrase"`
+	PublicKey      string `json:"publicKey"`
+	PrivateKey     string `json:"privateKey"`
+	Description    string `json:"description"`
+}
+type RootCert struct {
+	ID             uint      `json:"id"`
+	CreatedAt      time.Time `json:"createdAt"`
+	Name           string    `json:"name"`
+	EncryptionMode string    `json:"encryptionMode"`
+	PassPhrase     string    `json:"passPhrase"`
+	PublicKey      string    `json:"publicKey"`
+	PrivateKey     string    `json:"privateKey"`
+	Description    string    `json:"description"`
 }
 
 type GenerateLoad struct {
@@ -39,12 +54,6 @@ type SearchSSHLog struct {
 	Info   string `json:"info"`
 	Status string `json:"Status" validate:"required,oneof=Success Failed All"`
 }
-type SSHLog struct {
-	Logs            []SSHHistory `json:"logs"`
-	TotalCount      int          `json:"totalCount"`
-	SuccessfulCount int          `json:"successfulCount"`
-	FailedCount     int          `json:"failedCount"`
-}
 
 type SSHHistory struct {
 	Date     time.Time `json:"date"`

agent/app/model/alert.go

@@ -3,14 +3,15 @@ package model
 type Alert struct {
 	BaseModel
 
-	Title     string `gorm:"type:varchar(256);not null" json:"title"`
-	Type      string `gorm:"type:varchar(64);not null" json:"type"`
-	Cycle     uint   `gorm:"type:integer;not null" json:"cycle"`
-	Count     uint   `gorm:"type:integer;not null" json:"count"`
-	Project   string `gorm:"type:varchar(64)" json:"project"`
-	Status    string `gorm:"type:varchar(64);not null" json:"status"`
-	Method    string `gorm:"type:varchar(64);not null" json:"method"`
-	SendCount uint   `gorm:"type:integer" json:"sendCount"`
+	Title          string `gorm:"type:varchar(256);not null" json:"title"`
+	Type           string `gorm:"type:varchar(64);not null" json:"type"`
+	Cycle          uint   `gorm:"type:integer;not null" json:"cycle"`
+	Count          uint   `gorm:"type:integer;not null" json:"count"`
+	Project        string `gorm:"type:varchar(64)" json:"project"`
+	Status         string `gorm:"type:varchar(64);not null" json:"status"`
+	Method         string `gorm:"type:varchar(64);not null" json:"method"`
+	SendCount      uint   `gorm:"type:integer" json:"sendCount"`
+	AdvancedParams string `gorm:"type:longText" json:"advancedParam"`
 }
 
 type AlertTask struct {
@@ -18,7 +19,7 @@ type AlertTask struct {
 	Type      string `gorm:"type:varchar(64);not null" json:"type"`
 	Quota     string `gorm:"type:varchar(64)" json:"quota"`
 	QuotaType string `gorm:"type:varchar(64)" json:"quotaType"`
-	Method    string `gorm:"type:varchar(64);not null;default:'sms" json:"method"`
+	Method    string `gorm:"type:varchar(64);not null;default:'sms'" json:"method"`
 }
 
 type AlertLog struct {
@@ -33,7 +34,7 @@ type AlertLog struct {
 	Message     string `gorm:"type:varchar(256);" json:"message"`
 	RecordId    uint   `gorm:"type:integer;" json:"recordId"`
 	LicenseId   string `gorm:"type:varchar(256);not null;" json:"licenseId" `
-	Method      string `gorm:"type:varchar(64);not null;default:'sms" json:"method"`
+	Method      string `gorm:"type:varchar(64);not null;default:'sms'" json:"method"`
 }
 
 type AlertConfig struct {
@@ -43,3 +44,12 @@ type AlertConfig struct {
 	Status string `gorm:"type:varchar(64);not null" json:"status"`
 	Config string `gorm:"type:varchar(256);not null" json:"config"`
 }
+
+type LoginLog struct {
+	BaseModel
+	IP      string `json:"ip"`
+	Address string `json:"address"`
+	Agent   string `json:"agent"`
+	Status  string `json:"status"`
+	Message string `json:"message"`
+}

agent/app/model/app_launcher.go

@@ -4,3 +4,13 @@ type AppLauncher struct {
 	BaseModel
 	Key string `json:"key"`
 }
+
+type QuickJump struct {
+	BaseModel
+	Name      string `json:"name"`
+	Title     string `json:"title"`
+	Detail    string `json:"detail"`
+	Recommend int    `json:"recommend"`
+	IsShow    bool   `json:"isShow"`
+	Router    string `json:"router"`
+}

agent/app/model/clam.go

@@ -1,14 +1,31 @@
 package model
 
+import "time"
+
 type Clam struct {
 	BaseModel
 
 	Name             string `gorm:"not null" json:"name"`
-	Status           string `json:"status"`
 	Path             string `gorm:"not null" json:"path"`
 	InfectedStrategy string `json:"infectedStrategy"`
 	InfectedDir      string `json:"infectedDir"`
 	Spec             string `json:"spec"`
 	EntryID          int    `json:"entryID"`
 	Description      string `json:"description"`
+
+	Status      string `json:"status"`
+	IsExecuting bool   `json:"isExecuting"`
+}
+
+type ClamRecord struct {
+	BaseModel
+
+	ClamID        uint      `json:"clamID"`
+	TaskID        string    `json:"taskID"`
+	StartTime     time.Time `json:"startTime"`
+	ScanTime      string    `json:"scanTime"`
+	InfectedFiles string    `json:"infectedFiles"`
+	TotalError    string    `json:"totalError"`
+	Status        string    `json:"status"`
+	Message       string    `json:"message"`
 }

agent/app/model/cronjob.go

@@ -4,13 +4,12 @@ import (
 	"time"
 )
 
-// BackupAccounts ---> SourceAccountIDs
-// BackupAccounts ---> DownloadAccountID
 type Cronjob struct {
 	BaseModel
 
 	Name       string `gorm:"not null" json:"name"`
 	Type       string `gorm:"not null" json:"type"`
+	GroupID    uint   `json:"groupID"`
 	SpecCustom bool   `json:"specCustom"`
 	Spec       string `gorm:"not null" json:"spec"`
 
@@ -39,10 +38,11 @@ type Cronjob struct {
 	IgnoreErr         bool   `json:"ignoreErr"`
 	RetainCopies      uint64 `json:"retainCopies"`
 
-	Status   string       `json:"status"`
-	EntryIDs string       `json:"entryIDs"`
-	Records  []JobRecords `json:"records"`
-	Secret   string       `json:"secret"`
+	IsExecuting bool         `json:"isExecuting"`
+	Status      string       `json:"status"`
+	EntryIDs    string       `json:"entryIDs"`
+	Records     []JobRecords `json:"records"`
+	Secret      string       `json:"secret"`
 }
 
 type JobRecords struct {

agent/app/model/database.go

@@ -18,5 +18,6 @@ type Database struct {
 	ClientCert string `json:"clientCert"`
 	SkipVerify bool   `json:"skipVerify"`
 
+	Timeout     uint   `json:"timeout"`
 	Description string `json:"description"`
 }

agent/app/model/mcp_server.go

@@ -2,17 +2,20 @@ package model
 
 type McpServer struct {
 	BaseModel
-	Name          string `json:"name"`
-	DockerCompose string `json:"dockerCompose"`
-	Command       string `json:"command"`
-	ContainerName string `json:"containerName"`
-	Message       string `json:"message"`
-	Port          int    `json:"port"`
-	Status        string `json:"status"`
-	Env           string `json:"env"`
-	BaseURL       string `json:"baseUrl"`
-	SsePath       string `json:"ssePath"`
-	WebsiteID     int    `json:"websiteID"`
-	Dir           string `json:"dir"`
-	HostIP        string `json:"hostIP"`
+	Name               string `json:"name"`
+	DockerCompose      string `json:"dockerCompose"`
+	Command            string `json:"command"`
+	ContainerName      string `json:"containerName"`
+	Message            string `json:"message"`
+	Port               int    `json:"port"`
+	Status             string `json:"status"`
+	Env                string `json:"env"`
+	BaseURL            string `json:"baseUrl"`
+	SsePath            string `json:"ssePath"`
+	WebsiteID          int    `json:"websiteID"`
+	Dir                string `json:"dir"`
+	HostIP             string `json:"hostIP"`
+	StreamableHttpPath string `json:"streamableHttpPath"`
+	OutputTransport    string `json:"outputTransport"`
+	Type               string `json:"type"`
 }

agent/app/model/setting.go

@@ -15,3 +15,13 @@ type NodeInfo struct {
 	ServerCrt string `json:"serverCrt"`
 	ServerKey string `json:"serverKey"`
 }
+
+type LocalConnInfo struct {
+	Addr       string `json:"addr"`
+	Port       uint   `json:"port"`
+	User       string `json:"user"`
+	AuthMode   string `json:"authMode"`
+	Password   string `json:"password"`
+	PrivateKey string `json:"privateKey"`
+	PassPhrase string `json:"passPhrase"`
+}

agent/app/model/ssh.go

@@ -0,0 +1,11 @@
+package model
+
+type RootCert struct {
+	BaseModel
+	Name           string `json:"name" gorm:"not null;"`
+	EncryptionMode string `json:"encryptionMode"`
+	PassPhrase     string `json:"passPhrase"`
+	PublicKeyPath  string `json:"publicKeyPath"`
+	PrivateKeyPath string `json:"privateKeyPath"`
+	Description    string `json:"description"`
+}

agent/app/model/website_ssl.go

@@ -36,6 +36,9 @@ type WebsiteSSL struct {
 	DisableCNAME  bool      `json:"disableCNAME"`
 	ExecShell     bool      `json:"execShell"`
 	Shell         string    `json:"shell"`
+	MasterSSLID   uint      `json:"masterSslId"`
+	Nodes         string    `json:"nodes"`
+	PushNode      bool      `json:"pushNode"`
 
 	AcmeAccount WebsiteAcmeAccount `json:"acmeAccount" gorm:"-:migration"`
 	DnsAccount  WebsiteDnsAccount  `json:"dnsAccount" gorm:"-:migration"`

agent/app/repo/app.go

@@ -33,6 +33,8 @@ type IAppRepo interface {
 	BatchDelete(ctx context.Context, apps []model.App) error
 	DeleteByIDs(ctx context.Context, ids []uint) error
 	DeleteBy(opts ...DBOption) error
+
+	GetTopRecomment() ([]string, error)
 }
 
 func NewIAppRepo() IAppRepo {
@@ -44,7 +46,7 @@ func (a AppRepo) WithByLikeName(name string) DBOption {
 		if len(name) == 0 {
 			return g
 		}
-		return g.Where("name like ? or short_desc_zh like ? or short_desc_en like ?", "%"+name+"%", "%"+name+"%", "%"+name+"%")
+		return g.Where("name like ? or  description like ? or short_desc_zh like ? or short_desc_en like ?", "%"+name+"%", "%"+name+"%", "%"+name+"%", "%"+name+"%")
 	}
 }
 
@@ -123,6 +125,21 @@ func (a AppRepo) GetBy(opts ...DBOption) ([]model.App, error) {
 	return apps, nil
 }
 
+func (a AppRepo) GetTopRecomment() ([]string, error) {
+	var (
+		apps  []model.App
+		names []string
+	)
+	db := getDb().Model(&model.App{})
+	if err := db.Order("recommend asc").Limit(6).Find(&apps).Error; err != nil {
+		return names, err
+	}
+	for _, item := range apps {
+		names = append(names, item.Key)
+	}
+	return names, nil
+}
+
 func (a AppRepo) BatchCreate(ctx context.Context, apps []model.App) error {
 	return getTx(ctx).Omit(clause.Associations).Create(&apps).Error
 }

agent/app/repo/app_ignore_upgrade.go

@@ -11,6 +11,7 @@ type AppIgnoreUpgradeRepo struct {
 
 type IAppIgnoreUpgradeRepo interface {
 	WithScope(scope string) DBOption
+	WithAppID(appID uint) DBOption
 	List(opts ...DBOption) ([]model.AppIgnoreUpgrade, error)
 	Create(appIgnoreUpgrade *model.AppIgnoreUpgrade) error
 	Delete(opts ...DBOption) error
@@ -26,6 +27,12 @@ func (a AppIgnoreUpgradeRepo) WithScope(scope string) DBOption {
 	}
 }
 
+func (a AppIgnoreUpgradeRepo) WithAppID(appID uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("app_id = ?", appID)
+	}
+}
+
 func (a AppIgnoreUpgradeRepo) List(opts ...DBOption) ([]model.AppIgnoreUpgrade, error) {
 	var appIgnoreUpgradeList []model.AppIgnoreUpgrade
 	err := getDb(opts...).Find(&appIgnoreUpgradeList).Error

agent/app/repo/app_launcher.go

@@ -13,6 +13,10 @@ type ILauncherRepo interface {
 	Create(launcher *model.AppLauncher) error
 	Save(launcher *model.AppLauncher) error
 	Delete(opts ...DBOption) error
+
+	GetQuickJump(opts ...DBOption) (model.QuickJump, error)
+	ListQuickJump(withAll bool) []model.QuickJump
+	UpdateQuicks(quicks []model.QuickJump) error
 }
 
 func NewILauncherRepo() ILauncherRepo {
@@ -57,3 +61,45 @@ func (u *LauncherRepo) Delete(opts ...DBOption) error {
 	}
 	return db.Delete(&model.AppLauncher{}).Error
 }
+
+func (u *LauncherRepo) GetQuickJump(opts ...DBOption) (model.QuickJump, error) {
+	var launcher model.QuickJump
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.First(&launcher).Error
+	return launcher, err
+}
+func (u *LauncherRepo) ListQuickJump(withAll bool) []model.QuickJump {
+	var quicks []model.QuickJump
+	if withAll {
+		_ = global.DB.Find(&quicks).Error
+	} else {
+		_ = global.DB.Where("is_show = ?", true).Find(&quicks).Error
+	}
+	if !withAll && len(quicks) == 0 {
+		return []model.QuickJump{
+			{Name: "Website", Title: "menu.website", Recommend: 10, IsShow: true, Router: "/websites"},
+			{Name: "Database", Title: "menu.database", Recommend: 30, IsShow: true, Router: "/databases"},
+			{Name: "Cronjob", Title: "menu.cronjob", Recommend: 50, IsShow: true, Router: "/cronjobs"},
+			{Name: "AppInstalled", Title: "home.appInstalled", Recommend: 70, IsShow: true, Router: "/apps/installed"},
+		}
+	}
+
+	return quicks
+}
+func (u *LauncherRepo) UpdateQuicks(quicks []model.QuickJump) error {
+	tx := global.DB.Begin()
+	for _, item := range quicks {
+		if err := tx.Model(&model.QuickJump{}).Where("id = ?", item.ID).Updates(map[string]interface{}{
+			"is_show": item.IsShow,
+			"detail":  item.Detail,
+		}).Error; err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+	tx.Commit()
+	return nil
+}

agent/app/repo/app_tag.go

@@ -17,8 +17,10 @@ type IAppTagRepo interface {
 	GetByAppId(appId uint) ([]model.AppTag, error)
 	GetByTagIds(tagIds []uint) ([]model.AppTag, error)
 	DeleteBy(ctx context.Context, opts ...DBOption) error
+	GetFirst(ctx context.Context, opts ...DBOption) (*model.AppTag, error)
 
 	WithByTagID(tagID uint) DBOption
+	WithByAppID(appId uint) DBOption
 }
 
 func NewIAppTagRepo() IAppTagRepo {
@@ -31,6 +33,12 @@ func (a AppTagRepo) WithByTagID(tagID uint) DBOption {
 	}
 }
 
+func (a AppTagRepo) WithByAppID(appId uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("app_id = ?", appId)
+	}
+}
+
 func (a AppTagRepo) BatchCreate(ctx context.Context, tags []*model.AppTag) error {
 	return getTx(ctx).Create(&tags).Error
 }
@@ -62,3 +70,12 @@ func (a AppTagRepo) GetByTagIds(tagIds []uint) ([]model.AppTag, error) {
 func (a AppTagRepo) DeleteBy(ctx context.Context, opts ...DBOption) error {
 	return getTx(ctx, opts...).Delete(&model.AppTag{}).Error
 }
+
+func (a AppTagRepo) GetFirst(ctx context.Context, opts ...DBOption) (*model.AppTag, error) {
+	var appTag model.AppTag
+	if err := getTx(ctx, opts...).First(&appTag).Error; err != nil {
+		return nil, err
+	}
+	return &appTag, nil
+
+}

agent/app/repo/clam.go

@@ -1,8 +1,13 @@
 package repo
 
 import (
+	"time"
+
 	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/google/uuid"
+	"gorm.io/gorm"
 )
 
 type ClamRepo struct{}
@@ -14,6 +19,14 @@ type IClamRepo interface {
 	Delete(opts ...DBOption) error
 	Get(opts ...DBOption) (model.Clam, error)
 	List(opts ...DBOption) ([]model.Clam, error)
+
+	WithByClamID(id uint) DBOption
+	ListRecord(opts ...DBOption) ([]model.ClamRecord, error)
+	RecordFirst(id uint) (model.ClamRecord, error)
+	DeleteRecord(opts ...DBOption) error
+	StartRecords(clamID uint) model.ClamRecord
+	EndRecords(record model.ClamRecord, status, message string)
+	PageRecords(page, size int, opts ...DBOption) (int64, []model.ClamRecord, error)
 }
 
 func NewIClamRepo() IClamRepo {
@@ -67,3 +80,69 @@ func (u *ClamRepo) Delete(opts ...DBOption) error {
 	}
 	return db.Delete(&model.Clam{}).Error
 }
+
+func (c *ClamRepo) WithByClamID(id uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("clam_id = ?", id)
+	}
+}
+
+func (u *ClamRepo) ListRecord(opts ...DBOption) ([]model.ClamRecord, error) {
+	var record []model.ClamRecord
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.Find(&record).Error
+	return record, err
+}
+
+func (u *ClamRepo) RecordFirst(id uint) (model.ClamRecord, error) {
+	var record model.ClamRecord
+	err := global.DB.Where("clam_id = ?", id).Order("created_at desc").First(&record).Error
+	return record, err
+}
+
+func (u *ClamRepo) PageRecords(page, size int, opts ...DBOption) (int64, []model.ClamRecord, error) {
+	var records []model.ClamRecord
+	db := global.DB.Model(&model.ClamRecord{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	count := int64(0)
+	db = db.Count(&count)
+	err := db.Order("created_at desc").Limit(size).Offset(size * (page - 1)).Find(&records).Error
+	return count, records, err
+}
+func (u *ClamRepo) StartRecords(clamID uint) model.ClamRecord {
+	var record model.ClamRecord
+	record.StartTime = time.Now()
+	record.ClamID = clamID
+	record.TaskID = uuid.New().String()
+	record.Status = constant.StatusWaiting
+	if err := global.DB.Create(&record).Error; err != nil {
+		global.LOG.Errorf("create record status failed, err: %v", err)
+	}
+	_ = u.Update(clamID, map[string]interface{}{"is_executing": true})
+	return record
+}
+func (u *ClamRepo) EndRecords(record model.ClamRecord, status, message string) {
+	upMap := make(map[string]interface{})
+	upMap["status"] = status
+	upMap["message"] = message
+	upMap["task_id"] = record.TaskID
+	upMap["scan_time"] = record.ScanTime
+	upMap["infected_files"] = record.InfectedFiles
+	upMap["total_error"] = record.TotalError
+	if err := global.DB.Model(&model.ClamRecord{}).Where("id = ?", record.ID).Updates(upMap).Error; err != nil {
+		global.LOG.Errorf("update record status failed, err: %v", err)
+	}
+	_ = u.Update(record.ClamID, map[string]interface{}{"is_executing": false})
+}
+func (u *ClamRepo) DeleteRecord(opts ...DBOption) error {
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	return db.Delete(&model.ClamRecord{}).Error
+}

agent/app/repo/common.go

@@ -104,6 +104,15 @@ func WithByDate(startTime, endTime time.Time) DBOption {
 	}
 }
 
+func WithByGroups(groupIDs []uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		if len(groupIDs) == 0 {
+			return g
+		}
+		return g.Where("group_id in (?)", groupIDs)
+	}
+}
+
 func WithByCreatedAt(startTime, endTime time.Time) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("created_at > ? AND created_at < ?", startTime, endTime)

agent/app/repo/cronjob.go

@@ -29,9 +29,10 @@ type ICronjobRepo interface {
 	Update(id uint, vars map[string]interface{}) error
 	Delete(opts ...DBOption) error
 	DeleteRecord(opts ...DBOption) error
-	StartRecords(cronjobID uint, targetPath, cronjobType string) model.JobRecords
+	StartRecords(cronjobID uint) model.JobRecords
 	UpdateRecords(id uint, vars map[string]interface{}) error
 	EndRecords(record model.JobRecords, status, message, records string)
+	AddFailedRecord(cronjobID uint, message string)
 	PageRecords(page, size int, opts ...DBOption) (int64, []model.JobRecords, error)
 }
 
@@ -143,7 +144,7 @@ func (c *CronjobRepo) WithByRecordDropID(id int) DBOption {
 	}
 }
 
-func (u *CronjobRepo) StartRecords(cronjobID uint, targetPath, cronjobType string) model.JobRecords {
+func (u *CronjobRepo) StartRecords(cronjobID uint) model.JobRecords {
 	var record model.JobRecords
 	record.StartTime = time.Now()
 	record.CronjobID = cronjobID
@@ -152,6 +153,7 @@ func (u *CronjobRepo) StartRecords(cronjobID uint, targetPath, cronjobType strin
 	if err := global.DB.Create(&record).Error; err != nil {
 		global.LOG.Errorf("create record status failed, err: %v", err)
 	}
+	_ = u.Update(cronjobID, map[string]interface{}{"is_executing": true})
 	return record
 }
 func (u *CronjobRepo) EndRecords(record model.JobRecords, status, message, records string) {
@@ -165,6 +167,17 @@ func (u *CronjobRepo) EndRecords(record model.JobRecords, status, message, recor
 	if err := global.DB.Model(&model.JobRecords{}).Where("id = ?", record.ID).Updates(errMap).Error; err != nil {
 		global.LOG.Errorf("update record status failed, err: %v", err)
 	}
+	_ = u.Update(record.CronjobID, map[string]interface{}{"is_executing": false})
+}
+func (u *CronjobRepo) AddFailedRecord(cronjobID uint, message string) {
+	var record model.JobRecords
+	record.StartTime = time.Now()
+	record.CronjobID = cronjobID
+	record.Status = constant.StatusFailed
+	record.Message = message
+	if err := global.DB.Create(&record).Error; err != nil {
+		global.LOG.Errorf("create record status failed, err: %v", err)
+	}
 }
 
 func (u *CronjobRepo) Save(id uint, cronjob model.Cronjob) error {

agent/app/repo/host.go

@@ -3,6 +3,7 @@ package repo
 import (
 	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/encrypt"
 )
 
 type HostRepo struct{}
@@ -13,6 +14,14 @@ type IHostRepo interface {
 	SaveFirewallRecord(firewall *model.Firewall) error
 	DeleteFirewallRecordByID(id uint) error
 	DeleteFirewallRecord(fType, port, protocol, address, strategy string) error
+
+	SyncCert(data []model.RootCert) error
+	GetCert(opts ...DBOption) (model.RootCert, error)
+	PageCert(limit, offset int, opts ...DBOption) (int64, []model.RootCert, error)
+	ListCert(opts ...DBOption) ([]model.RootCert, error)
+	CreateCert(cert *model.RootCert) error
+	UpdateCert(id uint, vars map[string]interface{}) error
+	DeleteCert(opts ...DBOption) error
 }
 
 func NewIHostRepo() IHostRepo {
@@ -63,3 +72,82 @@ func (h *HostRepo) DeleteFirewallRecordByID(id uint) error {
 func (h *HostRepo) DeleteFirewallRecord(fType, port, protocol, address, strategy string) error {
 	return global.DB.Where("type = ? AND port = ? AND protocol = ? AND address = ? AND strategy = ?", fType, port, protocol, address, strategy).Delete(&model.Firewall{}).Error
 }
+
+func (u *HostRepo) GetCert(opts ...DBOption) (model.RootCert, error) {
+	var cert model.RootCert
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.First(&cert).Error
+	return cert, err
+}
+
+func (u *HostRepo) PageCert(page, size int, opts ...DBOption) (int64, []model.RootCert, error) {
+	var ops []model.RootCert
+	db := global.DB.Model(&model.RootCert{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	count := int64(0)
+	db = db.Count(&count)
+	err := db.Limit(size).Offset(size * (page - 1)).Find(&ops).Error
+	return count, ops, err
+}
+
+func (u *HostRepo) ListCert(opts ...DBOption) ([]model.RootCert, error) {
+	var ops []model.RootCert
+	db := global.DB.Model(&model.RootCert{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	count := int64(0)
+	db = db.Count(&count)
+	err := db.Find(&ops).Error
+	return ops, err
+}
+
+func (u *HostRepo) CreateCert(cert *model.RootCert) error {
+	return global.DB.Create(cert).Error
+}
+
+func (u *HostRepo) UpdateCert(id uint, vars map[string]interface{}) error {
+	return global.DB.Model(&model.RootCert{}).Where("id = ?", id).Updates(vars).Error
+}
+
+func (u *HostRepo) DeleteCert(opts ...DBOption) error {
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	return db.Delete(&model.RootCert{}).Error
+}
+
+func (u *HostRepo) SyncCert(data []model.RootCert) error {
+	tx := global.DB.Begin()
+	var oldCerts []model.RootCert
+	_ = tx.Where("1 = ?", 1).Find(&oldCerts).Error
+	oldCertsMap := make(map[string]uint)
+	for _, item := range oldCerts {
+		oldCertsMap[item.Name] = item.ID
+	}
+	for _, item := range data {
+		if _, ok := oldCertsMap[item.Name]; ok {
+			delete(oldCertsMap, item.Name)
+			continue
+		}
+		item.PassPhrase, _ = encrypt.StringEncrypt("<UN-SET>")
+		if err := tx.Model(model.RootCert{}).Create(&item).Error; err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+	for _, val := range oldCertsMap {
+		if err := tx.Where("id = ?", val).Delete(&model.RootCert{}).Error; err != nil {
+			tx.Rollback()
+			return err
+		}
+	}
+	tx.Commit()
+	return nil
+}

agent/app/repo/runtime.go

@@ -17,6 +17,7 @@ type IRuntimeRepo interface {
 	WithNotId(id uint) DBOption
 	WithStatus(status string) DBOption
 	WithDetailId(id uint) DBOption
+	WithDetailIdsIn(ids []uint) DBOption
 	WithPort(port int) DBOption
 	WithNormalStatus(status string) DBOption
 	Page(page, size int, opts ...DBOption) (int64, []model.Runtime, error)
@@ -55,6 +56,12 @@ func (r *RuntimeRepo) WithDetailId(id uint) DBOption {
 	}
 }
 
+func (r *RuntimeRepo) WithDetailIdsIn(ids []uint) DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("app_detail_id in(?) ", ids)
+	}
+}
+
 func (r *RuntimeRepo) WithNotId(id uint) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		return g.Where("id != ?", id)

agent/app/repo/tag.go

@@ -19,6 +19,7 @@ type ITagRepo interface {
 	DeleteByID(ctx context.Context, id uint) error
 	Create(ctx context.Context, tag *model.Tag) error
 	Save(ctx context.Context, tag *model.Tag) error
+	GetByKey(key string) (*model.Tag, error)
 }
 
 func NewITagRepo() ITagRepo {
@@ -41,6 +42,14 @@ func (t TagRepo) All() ([]model.Tag, error) {
 	return tags, nil
 }
 
+func (t TagRepo) GetByKey(key string) (*model.Tag, error) {
+	var tag model.Tag
+	if err := getDb().Where("key = ?", key).First(&tag).Error; err != nil {
+		return nil, err
+	}
+	return &tag, nil
+}
+
 func (t TagRepo) GetByIds(ids []uint) ([]model.Tag, error) {
 	var tags []model.Tag
 	if err := getDb().Where("id in (?)", ids).Find(&tags).Error; err != nil {

agent/app/repo/website.go

@@ -19,6 +19,8 @@ type IWebsiteRepo interface {
 	WithRuntimeID(runtimeID uint) DBOption
 	WithParentID(websiteID uint) DBOption
 	WithType(websiteType string) DBOption
+	WithDBType(dbType string) DBOption
+	WithDBID(dbID uint) DBOption
 
 	Page(page, size int, opts ...DBOption) (int64, []model.Website, error)
 	List(opts ...DBOption) ([]model.Website, error)
@@ -100,6 +102,18 @@ func (w *WebsiteRepo) WithType(websiteType string) DBOption {
 	}
 }
 
+func (w *WebsiteRepo) WithDBType(dbType string) DBOption {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where("db_type = ?", dbType)
+	}
+}
+
+func (w *WebsiteRepo) WithDBID(dbID uint) DBOption {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where("db_id = ?", dbID)
+	}
+}
+
 func (w *WebsiteRepo) Page(page, size int, opts ...DBOption) (int64, []model.Website, error) {
 	var websites []model.Website
 	db := getDb(opts...).Model(&model.Website{})

agent/app/repo/website_ssl.go

@@ -17,6 +17,7 @@ type ISSLRepo interface {
 	WithByDnsAccountId(dnsAccountId uint) DBOption
 	WithByCAID(caID uint) DBOption
 	WithByDomain(domain string) DBOption
+	WithByMasterSSLID(sslID uint) DBOption
 	Page(page, size int, opts ...DBOption) (int64, []model.WebsiteSSL, error)
 	GetFirst(opts ...DBOption) (*model.WebsiteSSL, error)
 	List(opts ...DBOption) ([]model.WebsiteSSL, error)
@@ -52,12 +53,19 @@ func (w WebsiteSSLRepo) WithByCAID(caID uint) DBOption {
 		return db.Where("ca_id = ?", caID)
 	}
 }
+
 func (w WebsiteSSLRepo) WithByDomain(domain string) DBOption {
 	return func(db *gorm.DB) *gorm.DB {
 		return db.Where("primary_domain Like ? or domains Like ?", "%"+domain+"%", "%"+domain+"%")
 	}
 }
 
+func (w WebsiteSSLRepo) WithByMasterSSLID(sslID uint) DBOption {
+	return func(db *gorm.DB) *gorm.DB {
+		return db.Where("master_ssl_id = ?", sslID)
+	}
+}
+
 func (w WebsiteSSLRepo) Page(page, size int, opts ...DBOption) (int64, []model.WebsiteSSL, error) {
 	var sslList []model.WebsiteSSL
 	db := getDb(opts...).Model(&model.WebsiteSSL{})

agent/app/service/alert.go

@@ -14,7 +14,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/copier"
 	"github.com/1Panel-dev/1Panel/agent/utils/email"
 	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
-	"github.com/shirou/gopsutil/v3/disk"
+	"github.com/shirou/gopsutil/v4/disk"
 	"sort"
 	"strings"
 	"sync"
@@ -70,17 +70,18 @@ func (a AlertService) PageAlert(search dto.AlertSearch) (int64, []dto.AlertDTO,
 	for _, item := range alerts {
 
 		result = append(result, dto.AlertDTO{
-			ID:        item.ID,
-			Type:      item.Type,
-			Cycle:     item.Cycle,
-			Count:     item.Count,
-			Method:    item.Method,
-			Title:     item.Title,
-			Project:   item.Project,
-			Status:    item.Status,
-			SendCount: item.SendCount,
-			CreatedAt: item.CreatedAt,
-			UpdatedAt: item.UpdatedAt,
+			ID:             item.ID,
+			Type:           item.Type,
+			Cycle:          item.Cycle,
+			Count:          item.Count,
+			Method:         item.Method,
+			Title:          item.Title,
+			Project:        item.Project,
+			Status:         item.Status,
+			SendCount:      item.SendCount,
+			AdvancedParams: item.AdvancedParams,
+			CreatedAt:      item.CreatedAt,
+			UpdatedAt:      item.UpdatedAt,
 		})
 	}
 
@@ -100,17 +101,18 @@ func (a AlertService) GetAlerts() ([]dto.AlertDTO, error) {
 	for _, item := range alerts {
 
 		result = append(result, dto.AlertDTO{
-			ID:        item.ID,
-			Type:      item.Type,
-			Cycle:     item.Cycle,
-			Count:     item.Count,
-			Method:    item.Method,
-			Title:     item.Title,
-			Project:   item.Project,
-			Status:    item.Status,
-			SendCount: item.SendCount,
-			CreatedAt: item.CreatedAt,
-			UpdatedAt: item.UpdatedAt,
+			ID:             item.ID,
+			Type:           item.Type,
+			Cycle:          item.Cycle,
+			Count:          item.Count,
+			Method:         item.Method,
+			Title:          item.Title,
+			Project:        item.Project,
+			Status:         item.Status,
+			SendCount:      item.SendCount,
+			AdvancedParams: item.AdvancedParams,
+			CreatedAt:      item.CreatedAt,
+			UpdatedAt:      item.UpdatedAt,
 		})
 	}
 
@@ -165,6 +167,7 @@ func (a AlertService) UpdateAlert(req dto.AlertUpdate) error {
 	upMap["project"] = req.Project
 	upMap["status"] = req.Status
 	upMap["send_count"] = req.SendCount
+	upMap["advanced_params"] = req.AdvancedParams
 
 	if err := alertRepo.Update(upMap, repo.WithByID(req.ID)); err != nil {
 		return err
@@ -174,7 +177,24 @@ func (a AlertService) UpdateAlert(req dto.AlertUpdate) error {
 }
 
 func (a AlertService) DeleteAlert(id uint) error {
-	return alertRepo.Delete(repo.WithByID(id))
+	alertInfo, _ := alertRepo.Get(repo.WithByID(id))
+	if alertInfo.ID == 0 {
+		return buserr.New("ErrRecordNotFound")
+	}
+	err := alertRepo.Delete(repo.WithByID(id))
+	if err != nil {
+		return err
+	}
+	alerts, err := a.GetAlerts()
+	if err != nil {
+		return err
+	}
+	if len(alerts) > 0 {
+		NewIAlertTaskHelper().InitTask(alertInfo.Type)
+	} else {
+		NewIAlertTaskHelper().StopTask()
+	}
+	return nil
 }
 
 func (a AlertService) GetAlert(id uint) (dto.AlertDTO, error) {
@@ -483,23 +503,51 @@ func (a AlertService) TestAlertConfig(req dto.AlertConfigTest) (bool, error) {
 
 func (a AlertService) ExternalUpdateAlert(updateAlert dto.AlertCreate) error {
 	upMap := make(map[string]interface{})
+	var newStatus string
 	if updateAlert.SendCount == 0 {
-		upMap["status"] = constant.AlertDisable
+		newStatus = constant.AlertDisable
 	} else {
-		upMap["status"] = constant.AlertEnable
+		newStatus = constant.AlertEnable
 		upMap["send_count"] = updateAlert.SendCount
+		if updateAlert.Method != "" {
+			upMap["method"] = updateAlert.Method
+		}
 	}
-	upMap["method"] = updateAlert.Method
-	alertInfo, _ := alertRepo.Get(alertRepo.WithByType(updateAlert.Type), alertRepo.WithByProject(updateAlert.Project))
+	upMap["status"] = newStatus
+
+	alertInfo, _ := alertRepo.Get(
+		alertRepo.WithByType(updateAlert.Type),
+		alertRepo.WithByProject(updateAlert.Project),
+	)
+
 	if alertInfo.ID > 0 {
-		if err := alertRepo.Update(upMap, alertRepo.WithByProject(updateAlert.Project), alertRepo.WithByType(updateAlert.Type)); err != nil {
-			return err
+		shouldUpdate := false
+
+		if alertInfo.Status != newStatus {
+			shouldUpdate = true
+		}
+		if val, ok := upMap["send_count"]; ok && val != alertInfo.SendCount {
+			shouldUpdate = true
+		}
+		if val, ok := upMap["method"]; ok && val != "" && val != alertInfo.Method {
+			shouldUpdate = true
+		}
+
+		if shouldUpdate {
+			if err := alertRepo.Update(
+				upMap,
+				alertRepo.WithByProject(updateAlert.Project),
+				alertRepo.WithByType(updateAlert.Type),
+			); err != nil {
+				return err
+			}
 		}
 	} else {
-		updateAlert.Status = constant.AlertEnable
-		err := a.CreateAlert(updateAlert)
-		if err != nil {
-			return err
+		if updateAlert.Method != "" && updateAlert.Title != "" {
+			updateAlert.Status = newStatus
+			if err := a.CreateAlert(updateAlert); err != nil {
+				return err
+			}
 		}
 	}
 

agent/app/service/alert_sender.go

@@ -0,0 +1,165 @@
+package service
+
+import (
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	alertUtil "github.com/1Panel-dev/1Panel/agent/utils/alert"
+	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
+	"strings"
+)
+
+type AlertSender struct {
+	alert     dto.AlertDTO
+	quotaType string
+}
+
+func NewAlertSender(alert dto.AlertDTO, quotaType string) *AlertSender {
+	return &AlertSender{
+		alert:     alert,
+		quotaType: quotaType,
+	}
+}
+
+func (s *AlertSender) Send(quota string, params []dto.Param) {
+	methods := strings.Split(s.alert.Method, ",")
+	for _, method := range methods {
+		method = strings.TrimSpace(method)
+		switch method {
+		case constant.SMS:
+			s.sendSMS(quota, params)
+		case constant.Email:
+			s.sendEmail(quota, params)
+		}
+	}
+}
+
+func (s *AlertSender) ResourceSend(quota string, params []dto.Param) {
+	methods := strings.Split(s.alert.Method, ",")
+	for _, method := range methods {
+		method = strings.TrimSpace(method)
+		switch method {
+		case constant.SMS:
+			s.sendResourceSMS(quota, params)
+		case constant.Email:
+			s.sendResourceEmail(quota, params)
+		}
+	}
+}
+
+func (s *AlertSender) sendSMS(quota string, params []dto.Param) {
+	if !alertUtil.CheckSMSSendLimit(constant.SMS) {
+		return
+	}
+
+	totalCount, isValid := s.canSendAlert(constant.SMS)
+	if !isValid {
+		return
+	}
+
+	create := dto.AlertLogCreate{
+		Status:  constant.AlertSuccess,
+		Count:   totalCount + 1,
+		AlertId: s.alert.ID,
+		Type:    s.alert.Type,
+	}
+
+	_ = xpack.CreateSMSAlertLog(s.alert.Type, s.alert, create, quota, params, constant.SMS)
+	alertUtil.CreateNewAlertTask(quota, s.alert.Type, s.quotaType, constant.SMS)
+	global.LOG.Infof("%s alert sms push successful", s.alert.Type)
+}
+
+func (s *AlertSender) sendEmail(quota string, params []dto.Param) {
+	totalCount, isValid := s.canSendAlert(constant.Email)
+	if !isValid {
+		return
+	}
+
+	create := dto.AlertLogCreate{
+		Status:      constant.AlertSuccess,
+		Count:       totalCount + 1,
+		AlertId:     s.alert.ID,
+		Type:        s.alert.Type,
+		AlertRule:   alertUtil.ProcessAlertRule(s.alert),
+		AlertDetail: alertUtil.ProcessAlertDetail(s.alert, quota, params, constant.Email),
+	}
+
+	transport := xpack.LoadRequestTransport()
+	_ = alertUtil.CreateEmailAlertLog(create, s.alert, params, transport)
+	alertUtil.CreateNewAlertTask(quota, s.alert.Type, s.quotaType, constant.Email)
+	global.LOG.Infof("%s alert email push successful", s.alert.Type)
+}
+
+func (s *AlertSender) sendResourceSMS(quota string, params []dto.Param) {
+	if !alertUtil.CheckSMSSendLimit(constant.SMS) {
+		return
+	}
+
+	todayCount, isValid := s.canResourceSendAlert(constant.SMS)
+	if !isValid {
+		return
+	}
+
+	create := dto.AlertLogCreate{
+		Status:  constant.AlertSuccess,
+		Count:   todayCount + 1,
+		AlertId: s.alert.ID,
+		Type:    s.alert.Type,
+	}
+
+	if err := xpack.CreateSMSAlertLog(s.alert.Type, s.alert, create, quota, params, constant.SMS); err != nil {
+		global.LOG.Errorf("failed to send SMS alert: %v", err)
+		return
+	}
+	alertUtil.CreateNewAlertTask(quota, s.alert.Type, s.quotaType, constant.SMS)
+	global.LOG.Infof("%s alert sms push successful", s.alert.Type)
+}
+
+func (s *AlertSender) sendResourceEmail(quota string, params []dto.Param) {
+	todayCount, isValid := s.canResourceSendAlert(constant.Email)
+	if !isValid {
+		return
+	}
+
+	create := dto.AlertLogCreate{
+		Status:      constant.AlertSuccess,
+		Count:       todayCount + 1,
+		AlertId:     s.alert.ID,
+		Type:        s.alert.Type,
+		AlertRule:   alertUtil.ProcessAlertRule(s.alert),
+		AlertDetail: alertUtil.ProcessAlertDetail(s.alert, quota, params, constant.Email),
+	}
+
+	transport := xpack.LoadRequestTransport()
+	if err := alertUtil.CreateEmailAlertLog(create, s.alert, params, transport); err != nil {
+		global.LOG.Errorf("failed to send Email alert: %v", err)
+		return
+	}
+	alertUtil.CreateNewAlertTask(quota, s.alert.Type, s.quotaType, constant.Email)
+	global.LOG.Infof("%s alert email push successful", s.alert.Type)
+}
+
+func (s *AlertSender) canSendAlert(method string) (uint, bool) {
+	todayCount, totalCount, err := alertRepo.LoadTaskCount(s.alert.Type, s.quotaType, method)
+	if err != nil {
+		global.LOG.Errorf("error getting task count: %v", err)
+		return totalCount, false
+	}
+
+	if todayCount >= 1 || s.alert.SendCount <= totalCount {
+		return totalCount, false
+	}
+	return totalCount, true
+}
+
+func (s *AlertSender) canResourceSendAlert(method string) (uint, bool) {
+	todayCount, _, err := alertRepo.LoadTaskCount(s.alert.Type, s.quotaType, method)
+	if err != nil {
+		global.LOG.Errorf("error getting task count: %v", err)
+		return todayCount, false
+	}
+	if s.alert.SendCount <= todayCount {
+		return todayCount, false
+	}
+	return todayCount, true
+}

agent/app/service/app.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"net/http"
 	"os"
-	"path"
 	"path/filepath"
 	"reflect"
 	"strconv"
@@ -56,7 +55,7 @@ func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (interface{
 	var opts []repo.DBOption
 	opts = append(opts, appRepo.OrderByRecommend())
 	if req.Name != "" {
-		opts = append(opts, appRepo.WithByLikeName(req.Name))
+		opts = append(opts, appRepo.WithByLikeName(strings.TrimSpace(req.Name)))
 	}
 	if req.Type != "" {
 		opts = append(opts, appRepo.WithType(req.Type))
@@ -100,7 +99,7 @@ func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (interface{
 	if err != nil {
 		return nil, err
 	}
-	var appDTOs []*response.AppItem
+	appDTOs := make([]*response.AppItem, 0)
 	info := &dto.SettingInfo{}
 	if req.Type == "php" {
 		info, _ = NewISettingService().GetSettingInfo()
@@ -132,8 +131,21 @@ func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (interface{
 			continue
 		}
 		appDTO.Tags = tags
-		installs, _ := appInstallRepo.ListBy(context.Background(), appInstallRepo.WithAppId(ap.ID))
-		appDTO.Installed = len(installs) > 0
+		if ap.Type == constant.RuntimePHP || ap.Type == constant.RuntimeGo || ap.Type == constant.RuntimeNode || ap.Type == constant.RuntimePython || ap.Type == constant.RuntimeJava || ap.Type == constant.RuntimeDotNet {
+			details, _ := appDetailRepo.GetBy(appDetailRepo.WithAppId(ap.ID))
+			var ids []uint
+			if len(details) == 0 {
+				continue
+			}
+			for _, d := range details {
+				ids = append(ids, d.ID)
+			}
+			runtimes, _ := runtimeRepo.List(runtimeRepo.WithDetailIdsIn(ids))
+			appDTO.Installed = len(runtimes) > 0
+		} else {
+			installs, _ := appInstallRepo.ListBy(context.Background(), appInstallRepo.WithAppId(ap.ID))
+			appDTO.Installed = len(installs) > 0
+		}
 	}
 	res.Items = appDTOs
 	res.Total = total
@@ -355,29 +367,6 @@ func (a AppService) Install(req request.AppInstallCreate) (appInstall *model.App
 			}
 		}
 	}
-	if app.Key == "openresty" && (app.Resource == "remote" || app.Resource == "custom") && common.CompareVersion(appDetail.Version, "1.27") {
-		if dir, ok := req.Params["WEBSITE_DIR"]; ok {
-			siteDir := dir.(string)
-			if siteDir == "" || !strings.HasPrefix(siteDir, "/") {
-				siteDir = path.Join(global.Dir.DataDir, dir.(string))
-			}
-			req.Params["WEBSITE_DIR"] = siteDir
-			oldWebStePath, _ := settingRepo.GetValueByKey("WEBSITE_DIR")
-			fileOp := files.NewFileOp()
-			if oldWebStePath != "" && oldWebStePath != siteDir && fileOp.Stat(oldWebStePath) {
-				_ = fileOp.Rename(oldWebStePath, siteDir)
-			}
-			if !fileOp.Stat(siteDir) {
-				_ = fileOp.CreateDir(siteDir, constant.DirPerm)
-				_ = fileOp.CreateDir(path.Join(siteDir, "conf.d"), constant.DirPerm)
-			}
-			err = settingRepo.UpdateOrCreate("WEBSITE_DIR", siteDir)
-			if err != nil {
-				return
-			}
-			go RestartPHPRuntime()
-		}
-	}
 	for key := range req.Params {
 		if !strings.Contains(key, "PANEL_APP_PORT") {
 			continue
@@ -486,6 +475,11 @@ func (a AppService) Install(req request.AppInstallCreate) (appInstall *model.App
 			req.Params["DATABASE_NAME"] = database.Name
 		}
 	}
+	if app.Key == "openresty" {
+		req.Params["CONTAINER_PACKAGE_URL"] = "http://archive.ubuntu.com/ubuntu/"
+		req.Params["RESTY_ADD_PACKAGE_BUILDDEPS"] = ""
+		req.Params["RESTY_CONFIG_OPTIONS_MORE"] = ""
+	}
 	paramByte, err = json.Marshal(req.Params)
 	if err != nil {
 		return
@@ -513,6 +507,9 @@ func (a AppService) Install(req request.AppInstallCreate) (appInstall *model.App
 			return err
 		}
 		if app.Key == "openresty" {
+			if err = handleSiteDir(app, appDetail, req, t); err != nil {
+				return err
+			}
 			if err = handleOpenrestyFile(appInstall); err != nil {
 				return err
 			}
@@ -928,18 +925,11 @@ func (a AppService) SyncAppListFromRemote(taskID string) (err error) {
 			return err
 		}
 		var (
-			tags      []*model.Tag
 			appTags   []*model.AppTag
 			oldAppIds []uint
 		)
-		for _, tag := range list.Extra.Tags {
-			translations, _ := json.Marshal(tag.Locales)
-			tags = append(tags, &model.Tag{
-				Name:         tag.Name,
-				Translations: string(translations),
-				Sort:         tag.Sort,
-				Key:          tag.Key,
-			})
+		if err = SyncTags(list.Extra); err != nil {
+			return err
 		}
 		deleteCustomApp()
 		oldApps, err := appRepo.GetBy(appRepo.WithNotLocal())
@@ -1015,6 +1005,7 @@ func (a AppService) SyncAppListFromRemote(taskID string) (err error) {
 		}
 		t.LogSuccess(i18n.GetMsgByKey("SyncAppDetail"))
 
+		tags, _ := tagRepo.All()
 		var (
 			addAppArray    []model.App
 			updateAppArray []model.App
@@ -1061,16 +1052,8 @@ func (a AppService) SyncAppListFromRemote(taskID string) (err error) {
 				return
 			}
 		}
-		if err = tagRepo.DeleteAll(ctx); err != nil {
-			return
-		}
-		if len(tags) > 0 {
-			if err = tagRepo.BatchCreate(ctx, tags); err != nil {
-				return
-			}
-			for _, tag := range tags {
-				tagMap[tag.Key] = tag.ID
-			}
+		for _, tag := range tags {
+			tagMap[tag.Key] = tag.ID
 		}
 		for _, update := range updateAppArray {
 			if err = appRepo.Save(ctx, &update); err != nil {
@@ -1088,10 +1071,13 @@ func (a AppService) SyncAppListFromRemote(taskID string) (err error) {
 			for _, tag := range app.TagsKey {
 				tagId, ok := tagMap[tag]
 				if ok {
-					appTags = append(appTags, &model.AppTag{
-						AppId: app.ID,
-						TagId: tagId,
-					})
+					exist, _ := appTagRepo.GetFirst(ctx, appTagRepo.WithByTagID(tagId), appTagRepo.WithByAppID(app.ID))
+					if exist == nil {
+						appTags = append(appTags, &model.AppTag{
+							AppId: app.ID,
+							TagId: tagId,
+						})
+					}
 				}
 			}
 			for _, d := range app.Details {
@@ -1134,7 +1120,7 @@ func (a AppService) SyncAppListFromRemote(taskID string) (err error) {
 		}
 
 		if len(oldAppIds) > 0 {
-			if err = appTagRepo.DeleteByAppIds(ctx, oldAppIds); err != nil {
+			if err = appTagRepo.DeleteByAppIds(ctx, deleteIds); err != nil {
 				return
 			}
 		}

agent/app/service/app_ingore_upgrade.go

@@ -40,7 +40,7 @@ func (a AppIgnoreUpgradeService) List() ([]response.AppIgnoreUpgradeDTO, error)
 			_ = appIgnoreUpgradeRepo.Delete(repo.WithByID(ignore.ID))
 			continue
 		}
-		dto.Icon = app.Icon
+		dto.Name = app.Name
 		if ignore.Scope == "version" {
 			appDetail, err := appDetailRepo.GetFirst(repo.WithByID(ignore.AppDetailID))
 			if errors.Is(err, gorm.ErrRecordNotFound) {

agent/app/service/app_install.go

@@ -164,6 +164,11 @@ func (a *AppInstallService) CheckExist(req request.AppInstalledInfo) (*response.
 	res.HttpPort = appInstall.HttpPort
 	res.HttpsPort = appInstall.HttpsPort
 
+	if appInstall.App.Key == "openresty" {
+		websiteDir, _ := settingRepo.GetValueByKey("WEBSITE_DIR")
+		res.WebsiteDir = websiteDir
+	}
+
 	return res, nil
 }
 
@@ -672,7 +677,7 @@ func (a *AppInstallService) GetDefaultConfigByKey(key, name string) (string, err
 	if key == constant.AppMysql || key == constant.AppMariaDB || key == constant.AppMysqlCluster {
 		filePath = path.Join(filePath, "my.cnf")
 	}
-	if key == constant.AppRedis {
+	if key == constant.AppRedis || key == constant.AppRedisCluster {
 		filePath = path.Join(filePath, "redis.conf")
 	}
 	if key == constant.AppOpenresty {
@@ -788,6 +793,7 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 	}
 	res.AppContainerConfig = config
 	res.HostMode = isHostModel(install.DockerCompose)
+	res.RestartPolicy = getRestartPolicy(install.DockerCompose)
 	res.WebUI = install.WebUI
 	res.Type = install.App.Type
 	return &res, nil

agent/app/service/app_utils.go

@@ -1,11 +1,13 @@
 package service
 
 import (
+	"bufio"
 	"context"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"log"
+	"maps"
 	"math"
 	"net/http"
 	"os"
@@ -357,7 +359,7 @@ func deleteAppInstall(deleteReq request.AppInstallDelete) error {
 				if err != nil {
 					return err
 				}
-				images, err := composeV2.GetDockerComposeImagesV2(content, []byte(install.DockerCompose))
+				images, err := composeV2.GetImagesFromDockerCompose(content, []byte(install.DockerCompose))
 				if err != nil {
 					return err
 				}
@@ -440,6 +442,11 @@ func deleteAppInstall(deleteReq request.AppInstallDelete) error {
 			_ = op.DeleteDir(parentDir)
 		}
 		tx.Commit()
+
+		existApps, _ := appInstallRepo.ListBy(context.Background(), appInstallRepo.WithAppId(install.AppId))
+		if len(existApps) == 0 {
+			_ = appIgnoreUpgradeRepo.Delete(appIgnoreUpgradeRepo.WithAppID(install.AppId))
+		}
 		return nil
 	}
 	uninstallTask.AddSubTask(task.GetTaskName(install.Name, task.TaskUninstall, task.TaskScopeApp), uninstall, nil)
@@ -535,6 +542,9 @@ func handleUpgradeCompose(install model.AppInstall, detail model.AppDetail) (map
 	if oldServiceValue["deploy"] != nil {
 		serviceValue["deploy"] = oldServiceValue["deploy"]
 	}
+	if oldServiceValue["restart"] != nil {
+		serviceValue["restart"] = oldServiceValue["restart"]
+	}
 	servicesMap[install.ServiceName] = serviceValue
 	composeMap["services"] = servicesMap
 	return composeMap, nil
@@ -573,6 +583,76 @@ func getUpgradeCompose(install model.AppInstall, detail model.AppDetail) (string
 	return string(composeByte), nil
 }
 
+func buildNginx(parentTask *task.Task) error {
+	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
+	if err != nil {
+		return err
+	}
+	fileOp := files.NewFileOp()
+	buildPath := path.Join(nginxInstall.GetPath(), "build")
+	if !fileOp.Stat(buildPath) {
+		return buserr.New("ErrBuildDirNotFound")
+	}
+	moduleConfigPath := path.Join(buildPath, "module.json")
+	moduleContent, err := fileOp.GetContent(moduleConfigPath)
+	if err != nil {
+		return err
+	}
+	var (
+		modules         []dto.NginxModule
+		addModuleParams []string
+		addPackages     []string
+	)
+	if len(moduleContent) > 0 {
+		_ = json.Unmarshal(moduleContent, &modules)
+		bashFile, err := os.OpenFile(path.Join(buildPath, "tmp", "pre.sh"), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, constant.DirPerm)
+		if err != nil {
+			return err
+		}
+		defer bashFile.Close()
+		bashFileWriter := bufio.NewWriter(bashFile)
+		for _, module := range modules {
+			if !module.Enable {
+				continue
+			}
+			_, err = bashFileWriter.WriteString(module.Script + "\n")
+			if err != nil {
+				return err
+			}
+			addModuleParams = append(addModuleParams, module.Params)
+			addPackages = append(addPackages, module.Packages...)
+		}
+		err = bashFileWriter.Flush()
+		if err != nil {
+			return err
+		}
+	}
+	envs, err := gotenv.Read(nginxInstall.GetEnvPath())
+	if err != nil {
+		return err
+	}
+	envs["RESTY_CONFIG_OPTIONS_MORE"] = ""
+	envs["RESTY_ADD_PACKAGE_BUILDDEPS"] = ""
+	if len(addModuleParams) > 0 {
+		envs["RESTY_CONFIG_OPTIONS_MORE"] = strings.Join(addModuleParams, " ")
+	}
+	if len(addPackages) > 0 {
+		envs["RESTY_ADD_PACKAGE_BUILDDEPS"] = strings.Join(addPackages, " ")
+	}
+	_ = gotenv.Write(envs, nginxInstall.GetEnvPath())
+	if len(addModuleParams) == 0 && len(addPackages) == 0 {
+		return nil
+	}
+	logStr := fmt.Sprintf("%s %s", i18n.GetMsgByKey("TaskBuild"), i18n.GetMsgByKey("Image"))
+	parentTask.LogStart(logStr)
+	cmdMgr := cmd.NewCommandMgr(cmd.WithTask(*parentTask), cmd.WithTimeout(60*time.Minute))
+	if err = cmdMgr.RunBashCf("docker compose -f %s build", nginxInstall.GetComposePath()); err != nil {
+		return err
+	}
+	parentTask.LogSuccess(logStr)
+	return nil
+}
+
 func upgradeInstall(req request.AppInstallUpgrade) error {
 	install, err := appInstallRepo.GetFirst(repo.WithByID(req.InstallID))
 	if err != nil {
@@ -650,7 +730,11 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 		}
 		dockerCLi, _ := docker.NewClient()
 		if req.PullImage {
-			images, err := composeV2.GetDockerComposeImagesV2(content, []byte(detail.DockerCompose))
+			composeContent := []byte(detail.DockerCompose)
+			if req.DockerCompose != "" {
+				composeContent = []byte(req.DockerCompose)
+			}
+			images, err := composeV2.GetImagesFromDockerCompose(content, composeContent)
 			if err != nil {
 				return err
 			}
@@ -701,6 +785,14 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 			return err
 		}
 		envParams := make(map[string]string, len(envs))
+		if install.App.Key == constant.AppOpenresty {
+			packageUrl, _ := env.GetEnvValueByKey(install.GetEnvPath(), "CONTAINER_PACKAGE_URL")
+			addPackage, _ := env.GetEnvValueByKey(install.GetEnvPath(), "RESTY_ADD_PACKAGE_BUILDDEPS")
+			options, _ := env.GetEnvValueByKey(install.GetEnvPath(), "RESTY_CONFIG_OPTIONS_MORE")
+			envParams["CONTAINER_PACKAGE_URL"] = packageUrl
+			envParams["RESTY_ADD_PACKAGE_BUILDDEPS"] = addPackage
+			envParams["RESTY_CONFIG_OPTIONS_MORE"] = options
+		}
 		handleMap(envs, envParams)
 		if err = env.Write(envParams, install.GetEnvPath()); err != nil {
 			return err
@@ -714,6 +806,13 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 			return err
 		}
 
+		if install.App.Key == constant.AppOpenresty {
+			if err = buildNginx(t); err != nil {
+				t.Log(err.Error())
+				return err
+			}
+		}
+
 		logStr := fmt.Sprintf("%s %s", i18n.GetMsgByKey("Run"), i18n.GetMsgByKey("App"))
 		t.Log(logStr)
 		if out, err := compose.Up(install.GetComposePath()); err != nil {
@@ -739,7 +838,7 @@ func upgradeInstall(req request.AppInstallUpgrade) error {
 		}
 	}
 
-	upgradeTask.AddSubTask(task.GetTaskName(install.Name, task.TaskScopeApp, task.TaskUpgrade), upgradeApp, rollBackApp)
+	upgradeTask.AddSubTaskWithOps(task.GetTaskName(install.Name, task.TaskScopeApp, task.TaskUpgrade), upgradeApp, rollBackApp, 0, 1*time.Hour)
 
 	go func() {
 		err = upgradeTask.Execute()
@@ -864,9 +963,9 @@ func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.App
 		_ = fileOp.CreateDir(appVersionDir, constant.DirPerm)
 	}
 	if logger == nil {
-		global.LOG.Infof("download app[%s] from %s", app.Name, appDetail.DownloadUrl)
+		global.LOG.Infof("download app [%s] from %s", app.Name, appDetail.DownloadUrl)
 	} else {
-		logger.Printf("download app[%s] from %s", app.Name, appDetail.DownloadUrl)
+		logger.Printf("download app [%s] from %s", app.Name, appDetail.DownloadUrl)
 	}
 
 	filePath := path.Join(appVersionDir, app.Key+"-"+appDetail.Version+".tar.gz")
@@ -882,9 +981,9 @@ func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.App
 
 	if err = files.DownloadFileWithProxy(appDetail.DownloadUrl, filePath); err != nil {
 		if logger == nil {
-			global.LOG.Errorf("download app[%s] error %v", app.Name, err)
+			global.LOG.Errorf("download app [%s] error %v", app.Name, err)
 		} else {
-			logger.Printf("download app[%s] error %v", app.Name, err)
+			logger.Printf("download app [%s] error %v", app.Name, err)
 		}
 		return
 	}
@@ -946,11 +1045,11 @@ func copyData(task *task.Task, app model.App, appDetail model.AppDetail, appInst
 		return
 	}
 	envPath := path.Join(appDir, ".env")
-	envParams := make(map[string]string, len(req.Params))
+	envParams := make(map[string]string)
 	if fileOp.Stat(envPath) {
 		envs, _ := gotenv.Read(envPath)
-		for k, v := range envs {
-			envParams[k] = v
+		if envParams = maps.Clone(envs); envParams == nil {
+			envParams = make(map[string]string)
 		}
 	}
 	handleMap(req.Params, envParams)
@@ -983,7 +1082,7 @@ func runScript(task *task.Task, appInstall *model.AppInstall, operate string) er
 	task.LogStart(logStr)
 
 	cmdMgr := cmd.NewCommandMgr(cmd.WithTimeout(10*time.Minute), cmd.WithWorkDir(workDir))
-	out, err := cmdMgr.RunWithStdoutBashCf(scriptPath)
+	out, err := cmdMgr.RunWithStdoutBashC(scriptPath)
 	if err != nil {
 		if out != "" {
 			err = errors.New(out)
@@ -1028,7 +1127,6 @@ func upApp(task *task.Task, appInstall *model.AppInstall, pullImages bool) error
 			errMsg string
 		)
 		if pullImages && appInstall.App.Type != "php" {
-			//projectName := strings.ToLower(appInstall.Name)
 			envByte, err := files.NewFileOp().GetContent(appInstall.GetEnvPath())
 			if err != nil {
 				return err
@@ -1058,8 +1156,8 @@ func upApp(task *task.Task, appInstall *model.AppInstall, pullImages bool) error
 						if strings.Contains(errOur, "no such host") {
 							errMsg = i18n.GetMsgByKey("ErrNoSuchHost") + ":"
 						}
-						if strings.Contains(errOur, "timeout") {
-							errMsg = i18n.GetMsgByKey("ErrImagePullTimeOut") + ":"
+						if strings.Contains(errOur, "Error response from daemon") {
+							errMsg = i18n.GetMsgByKey("PullImageTimeout") + ":"
 						}
 					}
 					appInstall.Message = errMsg + errOur
@@ -1650,6 +1748,14 @@ func addDockerComposeCommonParam(composeMap map[string]interface{}, serviceName
 	deploy["resources"] = resource
 	serviceValue["deploy"] = deploy
 
+	if req.RestartPolicy != "" {
+		if req.RestartPolicy == "on-failure" {
+			serviceValue["restart"] = "on-failure:5"
+		} else {
+			serviceValue["restart"] = req.RestartPolicy
+		}
+	}
+
 	ports, ok := serviceValue["ports"].([]interface{})
 	if ok {
 		for i, port := range ports {
@@ -1752,6 +1858,17 @@ func isHostModel(dockerCompose string) bool {
 	return false
 }
 
+func getRestartPolicy(yml string) string {
+	var project docker.ComposeProject
+	if err := yaml.Unmarshal([]byte(yml), &project); err != nil {
+		return ""
+	}
+	for _, service := range project.Services {
+		return service.Restart
+	}
+	return ""
+}
+
 func getMajorVersion(version string) string {
 	parts := strings.Split(version, ".")
 	if len(parts) >= 2 {
@@ -1764,6 +1881,10 @@ func ignoreUpdate(installed model.AppInstall) bool {
 	if installed.App.Type == "php" || installed.Status == constant.StatusInstalling {
 		return true
 	}
+	ignores, _ := appIgnoreUpgradeRepo.List(appDetailRepo.WithAppId(installed.AppId), appIgnoreUpgradeRepo.WithScope("all"))
+	if len(ignores) > 0 {
+		return true
+	}
 	if installed.App.Key == constant.AppMysql {
 		majorVersion := getMajorVersion(installed.Version)
 		appDetails, _ := appDetailRepo.GetBy(appDetailRepo.WithAppId(installed.App.ID))
@@ -1774,8 +1895,12 @@ func ignoreUpdate(installed model.AppInstall) bool {
 		}
 		return true
 	}
-	ignores, _ := appIgnoreUpgradeRepo.List(appDetailRepo.WithAppId(installed.AppId), appIgnoreUpgradeRepo.WithScope("all"))
-	return len(ignores) > 0
+	if installed.App.Key == "sqlbot" {
+		if common.CompareVersion("1.1.0", installed.Version) {
+			return true
+		}
+	}
+	return false
 }
 
 func RequestDownloadCallBack(downloadCallBackUrl string) {
@@ -1814,6 +1939,53 @@ func getAppTags(appID uint, lang string) ([]response.TagDTO, error) {
 	return res, nil
 }
 
+func handleSiteDir(app model.App, appDetail model.AppDetail, req request.AppInstallCreate, t *task.Task) error {
+	if app.Key == "openresty" && (app.Resource == "remote" || app.Resource == "custom") && common.CompareVersion(appDetail.Version, "1.27") {
+		if dir, ok := req.Params["WEBSITE_DIR"]; ok {
+			siteDir := dir.(string)
+			if siteDir == "" || !strings.HasPrefix(siteDir, "/") {
+				siteDir = path.Join(global.Dir.DataDir, dir.(string))
+			}
+			req.Params["WEBSITE_DIR"] = siteDir
+			oldWebStePath, _ := settingRepo.GetValueByKey("WEBSITE_DIR")
+			fileOp := files.NewFileOp()
+			if oldWebStePath != "" && oldWebStePath != siteDir && fileOp.Stat(oldWebStePath) {
+				t.Log(i18n.GetWithName("MoveSiteDir", siteDir))
+				if fileOp.Stat(siteDir) {
+					if fileOp.Stat(path.Join(siteDir, "conf.d")) {
+						_ = fileOp.Rename(path.Join(siteDir, "conf.d"), path.Join(siteDir, "conf.d.bak"))
+					}
+					if fileOp.Stat(path.Join(siteDir, "sites")) {
+						_ = fileOp.Rename(path.Join(siteDir, "sites"), path.Join(siteDir, "sites.bak"))
+					}
+					if err := fileOp.Rename(path.Join(oldWebStePath, "sites"), path.Join(siteDir, "sites")); err != nil {
+						return err
+					}
+					if err := fileOp.Rename(path.Join(oldWebStePath, "conf.d"), path.Join(siteDir, "conf.d")); err != nil {
+						return err
+					}
+				} else {
+					err := fileOp.Rename(oldWebStePath, siteDir)
+					if err != nil {
+						return err
+					}
+				}
+				t.Log(i18n.GetMsgByKey("MoveSiteDirSuccess"))
+			}
+			if !fileOp.Stat(siteDir) {
+				_ = fileOp.CreateDir(siteDir, constant.DirPerm)
+				_ = fileOp.CreateDir(path.Join(siteDir, "conf.d"), constant.DirPerm)
+			}
+			err := settingRepo.UpdateOrCreate("WEBSITE_DIR", siteDir)
+			if err != nil {
+				return err
+			}
+			go RestartPHPRuntime()
+		}
+	}
+	return nil
+}
+
 func handleOpenrestyFile(appInstall *model.AppInstall) error {
 	websites, _ := websiteRepo.List()
 	hasDefaultWebsite := false
@@ -1899,3 +2071,59 @@ func handleSSLConfig(appInstall *model.AppInstall, hasDefaultWebsite bool) error
 	}
 	return nil
 }
+
+func SyncTags(remoteProperties dto.ExtraProperties) error {
+	tx, ctx := getTxAndContext()
+	defer tx.Rollback()
+	localTags, _ := tagRepo.All()
+	localTagsMap := make(map[string]*model.Tag)
+	for i := range localTags {
+		localTagsMap[localTags[i].Key] = &localTags[i]
+	}
+	var err error
+	remoteTagsMap := make(map[string]*dto.Tag)
+	for i := range remoteProperties.Tags {
+		remoteTagsMap[remoteProperties.Tags[i].Key] = &remoteProperties.Tags[i]
+	}
+
+	for key, localTag := range localTagsMap {
+		if _, exists := remoteTagsMap[key]; !exists {
+			_ = tagRepo.DeleteByID(ctx, localTag.ID)
+		}
+	}
+
+	for _, remoteTag := range remoteProperties.Tags {
+		translations, _ := json.Marshal(remoteTag.Locales)
+
+		if existTag, exists := localTagsMap[remoteTag.Key]; exists {
+			if needsUpdate(existTag, remoteTag, string(translations)) {
+				existTag.Name = remoteTag.Name
+				existTag.Sort = remoteTag.Sort
+				existTag.Translations = string(translations)
+
+				if err = tagRepo.Save(ctx, existTag); err != nil {
+					return err
+				}
+			}
+		} else {
+			newTag := &model.Tag{
+				Key:          remoteTag.Key,
+				Name:         remoteTag.Name,
+				Sort:         remoteTag.Sort,
+				Translations: string(translations),
+			}
+			if err = tagRepo.Create(ctx, newTag); err != nil {
+				return err
+			}
+		}
+	}
+
+	tx.Commit()
+	return nil
+}
+
+func needsUpdate(localTag *model.Tag, remoteTag dto.Tag, translations string) bool {
+	return localTag.Name != remoteTag.Name ||
+		localTag.Sort != remoteTag.Sort ||
+		localTag.Translations != translations
+}

agent/app/service/backup.go

@@ -14,9 +14,11 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
 	"github.com/1Panel-dev/1Panel/agent/app/repo"
+	"github.com/1Panel-dev/1Panel/agent/app/task"
 	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/i18n"
 	"github.com/1Panel-dev/1Panel/agent/utils/cloud_storage"
 	"github.com/1Panel-dev/1Panel/agent/utils/cloud_storage/client"
 	"github.com/1Panel-dev/1Panel/agent/utils/encrypt"
@@ -37,6 +39,7 @@ type IBackupService interface {
 	Delete(id uint) error
 	RefreshToken(req dto.OperateByID) error
 	GetLocalDir() (string, error)
+	UploadForRecover(req dto.UploadForRecover) error
 
 	MysqlBackup(db dto.CommonBackup) error
 	PostgresqlBackup(db dto.CommonBackup) error
@@ -307,6 +310,16 @@ func (u *BackupService) RefreshToken(req dto.OperateByID) error {
 	return backupRepo.Save(&backup)
 }
 
+func (u *BackupService) UploadForRecover(req dto.UploadForRecover) error {
+	fileOp := files.NewFileOp()
+	if !fileOp.Stat(req.TargetDir) {
+		if err := fileOp.CreateDir(req.TargetDir, constant.DirPerm); err != nil {
+			return err
+		}
+	}
+	return fileOp.Copy(req.FilePath, req.TargetDir)
+}
+
 func (u *BackupService) checkBackupConn(backup *model.BackupAccount) (bool, error) {
 	client, err := newClient(backup, false)
 	if err != nil {
@@ -393,9 +406,13 @@ type backupClientHelper struct {
 	name        string
 	backupPath  string
 	client      cloud_storage.CloudStorageClient
+
+	isOk      bool
+	hasBackup bool
+	message   string
 }
 
-func NewBackupClientMap(ids []string) (map[string]backupClientHelper, error) {
+func NewBackupClientMap(ids []string) map[string]backupClientHelper {
 	var accounts []model.BackupAccount
 	var idItems []uint
 	for i := 0; i < len(ids); i++ {
@@ -406,18 +423,63 @@ func NewBackupClientMap(ids []string) (map[string]backupClientHelper, error) {
 	clientMap := make(map[string]backupClientHelper)
 	for _, item := range accounts {
 		backClient, err := newClient(&item, true)
-		if err != nil {
-			return nil, err
-		}
-		clientMap[fmt.Sprintf("%v", item.ID)] = backupClientHelper{
+		itemHelper := backupClientHelper{
 			client:      backClient,
 			name:        item.Name,
 			backupPath:  item.BackupPath,
 			accountType: item.Type,
 			id:          item.ID,
+			isOk:        err == nil,
 		}
+		if err != nil {
+			itemHelper.message = err.Error()
+		}
+		clientMap[fmt.Sprintf("%v", item.ID)] = itemHelper
 	}
-	return clientMap, nil
+	return clientMap
+}
+
+func uploadWithMap(taskItem task.Task, accountMap map[string]backupClientHelper, src, dst, accountIDs string, downloadAccountID, retry uint) error {
+	accounts := strings.Split(accountIDs, ",")
+	for _, account := range accounts {
+		if len(account) == 0 {
+			continue
+		}
+		itemBackup, ok := accountMap[account]
+		if !ok {
+			continue
+		}
+		if itemBackup.hasBackup {
+			continue
+		}
+		if !itemBackup.isOk {
+			taskItem.LogFailed(i18n.GetMsgWithDetail("LoadBackupFailed", itemBackup.message))
+			continue
+		}
+		name := itemBackup.name
+		if itemBackup.name == "localhost" {
+			name = i18n.GetMsgByKey("Localhost")
+		}
+		taskItem.LogStart(i18n.GetMsgWithMap("UploadFile", map[string]interface{}{
+			"file":   path.Join(itemBackup.backupPath, dst),
+			"backup": name,
+		}))
+		for i := 0; i < int(retry)+1; i++ {
+			_, err := itemBackup.client.Upload(src, path.Join(itemBackup.backupPath, dst))
+			taskItem.LogWithStatus(i18n.GetMsgByKey("Upload"), err)
+			if err != nil {
+				if account == fmt.Sprintf("%d", downloadAccountID) {
+					return err
+				}
+			} else {
+				break
+			}
+		}
+		itemBackup.hasBackup = true
+		accountMap[account] = itemBackup
+	}
+	os.RemoveAll(src)
+	return nil
 }
 
 func newClient(account *model.BackupAccount, isEncrypt bool) (cloud_storage.CloudStorageClient, error) {

agent/app/service/backup_mysql.go

@@ -59,44 +59,11 @@ func (u *BackupService) MysqlRecover(req dto.CommonRecover) error {
 }
 
 func (u *BackupService) MysqlRecoverByUpload(req dto.CommonRecover) error {
-	file := req.File
-	fileName := path.Base(req.File)
-	if strings.HasSuffix(fileName, ".tar.gz") {
-		fileNameItem := time.Now().Format(constant.DateTimeSlimLayout)
-		dstDir := fmt.Sprintf("%s/%s", path.Dir(req.File), fileNameItem)
-		fileOp := files.NewFileOp()
-		if !fileOp.Stat(dstDir) {
-			if err := fileOp.CreateDir(dstDir, os.ModePerm); err != nil {
-				return fmt.Errorf("mkdir %s failed, err: %v", dstDir, err)
-			}
-		}
-		if err := fileOp.TarGzExtractPro(req.File, dstDir, ""); err != nil {
-			_ = os.RemoveAll(dstDir)
-			return err
-		}
-		global.LOG.Infof("decompress file %s successful, now start to check test.sql is exist", req.File)
-		hasTestSql := false
-		_ = filepath.Walk(dstDir, func(path string, info os.FileInfo, err error) error {
-			if err != nil {
-				return nil
-			}
-			if !info.IsDir() && info.Name() == "test.sql" {
-				hasTestSql = true
-				file = path
-				fileName = "test.sql"
-			}
-			return nil
-		})
-		if !hasTestSql {
-			_ = os.RemoveAll(dstDir)
-			return fmt.Errorf("no such file named test.sql in %s", fileName)
-		}
-		defer func() {
-			_ = os.RemoveAll(dstDir)
-		}()
+	recoveFile, err := loadSqlFile(req.File)
+	if err != nil {
+		return err
 	}
-
-	req.File = path.Dir(file) + "/" + fileName
+	req.File = recoveFile
 	if err := handleMysqlRecover(req, nil, false, req.TaskID); err != nil {
 		return err
 	}
@@ -243,3 +210,55 @@ func doMysqlBackup(db DatabaseHelper, targetDir, fileName string) error {
 	}
 	return cli.Backup(backupInfo)
 }
+
+func loadSqlFile(file string) (string, error) {
+	if !strings.HasSuffix(file, ".tar.gz") && !strings.HasSuffix(file, ".zip") {
+		return file, nil
+	}
+	fileName := path.Base(file)
+	fileDir := path.Dir(file)
+	fileNameItem := time.Now().Format(constant.DateTimeSlimLayout)
+	dstDir := fmt.Sprintf("%s/%s", fileDir, fileNameItem)
+	_ = os.Mkdir(dstDir, constant.DirPerm)
+	if strings.HasSuffix(fileName, ".tar.gz") {
+		fileOp := files.NewFileOp()
+		if err := fileOp.TarGzExtractPro(file, dstDir, ""); err != nil {
+			_ = os.RemoveAll(dstDir)
+			return "", err
+		}
+	}
+	if strings.HasSuffix(fileName, ".zip") {
+		archiver, err := files.NewShellArchiver(files.Zip)
+		if err != nil {
+			_ = os.RemoveAll(dstDir)
+			return "", err
+		}
+		if err := archiver.Extract(file, dstDir, ""); err != nil {
+			_ = os.RemoveAll(dstDir)
+			return "", err
+		}
+	}
+	global.LOG.Infof("decompress file %s successful, now start to check test.sql is exist", file)
+	var sqlFiles []string
+	hasTestSql := false
+	_ = filepath.Walk(dstDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+		if !info.IsDir() && strings.HasSuffix(info.Name(), ".sql") {
+			sqlFiles = append(sqlFiles, path)
+			if info.Name() == "test.sql" {
+				hasTestSql = true
+			}
+		}
+		return nil
+	})
+	if len(sqlFiles) == 1 {
+		return sqlFiles[0], nil
+	}
+	if !hasTestSql {
+		_ = os.RemoveAll(dstDir)
+		return "", fmt.Errorf("no such file named test.sql in %s", fileName)
+	}
+	return "", nil
+}

agent/app/service/backup_postgresql.go

@@ -4,8 +4,6 @@ import (
 	"fmt"
 	"os"
 	"path"
-	"path/filepath"
-	"strings"
 	"time"
 
 	"github.com/1Panel-dev/1Panel/agent/app/repo"
@@ -59,44 +57,11 @@ func (u *BackupService) PostgresqlRecover(req dto.CommonRecover) error {
 }
 
 func (u *BackupService) PostgresqlRecoverByUpload(req dto.CommonRecover) error {
-	file := req.File
-	fileName := path.Base(req.File)
-	if strings.HasSuffix(fileName, ".tar.gz") {
-		fileNameItem := time.Now().Format(constant.DateTimeSlimLayout)
-		dstDir := fmt.Sprintf("%s/%s", path.Dir(req.File), fileNameItem)
-		fileOp := files.NewFileOp()
-		if !fileOp.Stat(dstDir) {
-			if err := fileOp.CreateDir(dstDir, os.ModePerm); err != nil {
-				return fmt.Errorf("mkdir %s failed, err: %v", dstDir, err)
-			}
-		}
-		if err := fileOp.TarGzExtractPro(req.File, dstDir, ""); err != nil {
-			_ = os.RemoveAll(dstDir)
-			return err
-		}
-		global.LOG.Infof("decompress file %s successful, now start to check test.sql is exist", req.File)
-		hasTestSql := false
-		_ = filepath.Walk(dstDir, func(path string, info os.FileInfo, err error) error {
-			if err != nil {
-				return nil
-			}
-			if !info.IsDir() && info.Name() == "test.sql" {
-				hasTestSql = true
-				file = path
-				fileName = "test.sql"
-			}
-			return nil
-		})
-		if !hasTestSql {
-			_ = os.RemoveAll(dstDir)
-			return fmt.Errorf("no such file named test.sql in %s", fileName)
-		}
-		defer func() {
-			_ = os.RemoveAll(dstDir)
-		}()
+	recoveFile, err := loadSqlFile(req.File)
+	if err != nil {
+		return err
 	}
-
-	req.File = path.Dir(file) + "/" + fileName
+	req.File = recoveFile
 	if err := handlePostgresqlRecover(req, nil, false); err != nil {
 		return err
 	}
@@ -119,7 +84,7 @@ func handlePostgresqlBackup(db DatabaseHelper, parentTask *task.Task, targetDir,
 	}
 
 	itemHandler := func() error { return doPostgresqlgBackup(db, targetDir, fileName) }
-	backupTask.AddSubTask(task.GetTaskName(itemName, task.TaskBackup, task.TaskScopeWebsite), func(task *task.Task) error { return itemHandler() }, nil)
+	backupTask.AddSubTask(task.GetTaskName(itemName, task.TaskBackup, task.TaskScopeDatabase), func(task *task.Task) error { return itemHandler() }, nil)
 	if parentTask != nil {
 		return itemHandler()
 	}
@@ -137,7 +102,7 @@ func handlePostgresqlRecover(req dto.CommonRecover, parentTask *task.Task, isRol
 	}
 	itemTask = parentTask
 	if parentTask == nil {
-		itemTask, err = task.NewTaskWithOps("Redis", task.TaskRecover, task.TaskScopeDatabase, req.TaskID, dbInfo.ID)
+		itemTask, err = task.NewTaskWithOps(req.Name, task.TaskRecover, task.TaskScopeDatabase, req.TaskID, dbInfo.ID)
 		if err != nil {
 			return err
 		}

agent/app/service/backup_record.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path"
 	"sync"
+	"time"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
@@ -249,20 +250,32 @@ func (u *BackupRecordService) LoadRecordSize(req dto.SearchForSize) ([]dto.Recor
 			recordIds = append(recordIds, fmt.Sprintf("%v", record.DownloadID))
 		}
 	}
-	clientMap, err := NewBackupClientMap(recordIds)
-	if err != nil {
-		return nil, err
-	}
 
+	clientMap := NewBackupClientMap(recordIds)
 	var datas []dto.RecordFileSize
 	var wg sync.WaitGroup
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
 	for i := 0; i < len(list); i++ {
 		datas = append(datas, dto.RecordFileSize{ID: list[i].ID})
 		if val, ok := clientMap[fmt.Sprintf("%v", list[i].DownloadID)]; ok {
+			if !val.isOk {
+				continue
+			}
 			wg.Add(1)
 			go func(index int) {
-				datas[index].Size, _ = val.client.Size(path.Join(val.backupPath, list[i].FilePath))
-				wg.Done()
+				defer wg.Done()
+				done := make(chan struct{}, 1)
+				go func() {
+					datas[index].Size, _ = val.client.Size(path.Join(val.backupPath, list[i].FilePath))
+					defer close(done)
+				}()
+				select {
+				case <-ctx.Done():
+					return
+				case <-done:
+					return
+				}
 			}(i)
 		}
 	}

agent/app/service/clam.go

@@ -3,37 +3,28 @@ package service
 import (
 	"bufio"
 	"fmt"
-	"github.com/1Panel-dev/1Panel/agent/utils/alert_push"
 	"os"
 	"os/exec"
 	"path"
-	"sort"
 	"strconv"
 	"strings"
-	"time"
-
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/repo"
+	"github.com/1Panel-dev/1Panel/agent/app/task"
 	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/alert_push"
+	"github.com/1Panel-dev/1Panel/agent/utils/clam"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
-	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/systemctl"
 	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
 	"github.com/jinzhu/copier"
 	"github.com/robfig/cron/v3"
 )
 
-const (
-	clamServiceNameCentOs = "clamd@scan.service"
-	clamServiceNameUbuntu = "clamav-daemon.service"
-	freshClamService      = "clamav-freshclam.service"
-	resultDir             = "clamav"
-)
-
 type ClamService struct {
 	serviceName string
 }
@@ -46,13 +37,13 @@ type IClamService interface {
 	Update(req dto.ClamUpdate) error
 	UpdateStatus(id uint, status string) error
 	Delete(req dto.ClamDelete) error
-	HandleOnce(req dto.OperateByID) error
+	HandleOnce(id uint) error
+
 	LoadFile(req dto.ClamFileReq) (string, error)
 	UpdateFile(req dto.UpdateByNameAndFile) error
-	LoadRecords(req dto.ClamLogSearch) (int64, interface{}, error)
-	CleanRecord(req dto.OperateByID) error
 
-	LoadRecordLog(req dto.ClamLogReq) (string, error)
+	SearchRecords(req dto.ClamLogSearch) (int64, interface{}, error)
+	CleanRecord(id uint) error
 }
 
 func NewIClamService() IClamService {
@@ -63,22 +54,22 @@ func (c *ClamService) LoadBaseInfo() (dto.ClamBaseInfo, error) {
 	var baseInfo dto.ClamBaseInfo
 	baseInfo.Version = "-"
 	baseInfo.FreshVersion = "-"
-	exist1, _ := systemctl.IsExist(clamServiceNameCentOs)
+	exist1, _ := systemctl.IsExist(constant.ClamServiceNameCentOs)
 	if exist1 {
-		c.serviceName = clamServiceNameCentOs
+		c.serviceName = constant.ClamServiceNameCentOs
 		baseInfo.IsExist = true
-		baseInfo.IsActive, _ = systemctl.IsActive(clamServiceNameCentOs)
+		baseInfo.IsActive, _ = systemctl.IsActive(constant.ClamServiceNameCentOs)
 	}
-	exist2, _ := systemctl.IsExist(clamServiceNameUbuntu)
+	exist2, _ := systemctl.IsExist(constant.ClamServiceNameUbuntu)
 	if exist2 {
-		c.serviceName = clamServiceNameUbuntu
+		c.serviceName = constant.ClamServiceNameUbuntu
 		baseInfo.IsExist = true
-		baseInfo.IsActive, _ = systemctl.IsActive(clamServiceNameUbuntu)
+		baseInfo.IsActive, _ = systemctl.IsActive(constant.ClamServiceNameUbuntu)
 	}
-	freshExist, _ := systemctl.IsExist(freshClamService)
+	freshExist, _ := systemctl.IsExist(constant.FreshClamService)
 	if freshExist {
 		baseInfo.FreshIsExist = true
-		baseInfo.FreshIsActive, _ = systemctl.IsActive(freshClamService)
+		baseInfo.FreshIsActive, _ = systemctl.IsActive(constant.FreshClamService)
 	}
 	if !cmd.Which("clamdscan") {
 		baseInfo.IsActive = false
@@ -94,7 +85,7 @@ func (c *ClamService) LoadBaseInfo() (dto.ClamBaseInfo, error) {
 			}
 		}
 	} else {
-		_ = StopAllCronJob(false)
+		_ = clam.CheckClamIsActive(false, clamRepo)
 	}
 	if baseInfo.FreshIsActive {
 		version, err := cmd.RunDefaultWithStdoutBashC("freshclam --version")
@@ -118,7 +109,7 @@ func (c *ClamService) Operate(operate string) error {
 		}
 		return nil
 	case "fresh-start", "fresh-restart", "fresh-stop":
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("systemctl %s %s", strings.TrimPrefix(operate, "fresh-"), freshClamService)
+		stdout, err := cmd.RunDefaultWithStdoutBashCf("systemctl %s %s", strings.TrimPrefix(operate, "fresh-"), constant.FreshClamService)
 		if err != nil {
 			return fmt.Errorf("%s the %s failed, err: %s", operate, c.serviceName, stdout)
 		}
@@ -129,31 +120,25 @@ func (c *ClamService) Operate(operate string) error {
 }
 
 func (c *ClamService) SearchWithPage(req dto.SearchClamWithPage) (int64, interface{}, error) {
-	total, commands, err := clamRepo.Page(req.Page, req.PageSize, repo.WithByLikeName(req.Info), repo.WithOrderRuleBy(req.OrderBy, req.Order))
+	total, clams, err := clamRepo.Page(req.Page, req.PageSize, repo.WithByLikeName(req.Info), repo.WithOrderRuleBy(req.OrderBy, req.Order))
 	if err != nil {
 		return 0, nil, err
 	}
 	var datas []dto.ClamInfo
-	for _, command := range commands {
+	for _, clam := range clams {
 		var item dto.ClamInfo
-		if err := copier.Copy(&item, &command); err != nil {
+		if err := copier.Copy(&item, &clam); err != nil {
 			return 0, nil, buserr.WithDetail("ErrStructTransform", err.Error(), nil)
 		}
-		item.LastHandleDate = "-"
 		datas = append(datas, item)
 	}
-	nyc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
 	for i := 0; i < len(datas); i++ {
-		logPaths := loadFileByName(datas[i].Name)
-		sort.Slice(logPaths, func(i, j int) bool {
-			return logPaths[i] > logPaths[j]
-		})
-		if len(logPaths) != 0 {
-			t1, err := time.ParseInLocation(constant.DateTimeSlimLayout, logPaths[0], nyc)
-			if err != nil {
-				continue
-			}
-			datas[i].LastHandleDate = t1.Format(constant.DateTimeLayout)
+		record, _ := clamRepo.RecordFirst(datas[i].ID)
+		if record.ID != 0 {
+			datas[i].LastRecordStatus = record.Status
+			datas[i].LastRecordTime = record.StartTime.Format(constant.DateTimeLayout)
+		} else {
+			datas[i].LastRecordTime = "-"
 		}
 		alertBase := dto.AlertBase{
 			AlertType: "clams",
@@ -175,6 +160,9 @@ func (c *ClamService) Create(req dto.ClamCreate) error {
 	if clam.ID != 0 {
 		return buserr.New("ErrRecordExist")
 	}
+	if cmd.CheckIllegal(req.Path) {
+		return buserr.New("ErrCmdIllegal")
+	}
 	if err := copier.Copy(&clam, &req); err != nil {
 		return buserr.WithDetail("ErrStructTransform", err.Error(), nil)
 	}
@@ -182,7 +170,7 @@ func (c *ClamService) Create(req dto.ClamCreate) error {
 		clam.InfectedDir = ""
 	}
 	if len(req.Spec) != 0 {
-		entryID, err := xpack.StartClam(clam, false)
+		entryID, err := xpack.StartClam(&clam, false)
 		if err != nil {
 			return err
 		}
@@ -192,7 +180,7 @@ func (c *ClamService) Create(req dto.ClamCreate) error {
 	if err := clamRepo.Create(&clam); err != nil {
 		return err
 	}
-	if req.AlertCount != 0 {
+	if req.AlertCount != 0 && req.AlertTitle != "" && req.AlertMethod != "" {
 		createAlert := dto.AlertCreate{
 			Title:     req.AlertTitle,
 			SendCount: req.AlertCount,
@@ -210,6 +198,9 @@ func (c *ClamService) Create(req dto.ClamCreate) error {
 }
 
 func (c *ClamService) Update(req dto.ClamUpdate) error {
+	if cmd.CheckIllegal(req.Path) {
+		return buserr.New("ErrCmdIllegal")
+	}
 	clam, _ := clamRepo.Get(repo.WithByName(req.Name))
 	if clam.ID == 0 {
 		return buserr.New("ErrRecordNotFound")
@@ -232,7 +223,7 @@ func (c *ClamService) Update(req dto.ClamUpdate) error {
 		upMap["entry_id"] = 0
 	}
 	if len(req.Spec) != 0 && clam.Status != constant.StatusDisable {
-		newEntryID, err := xpack.StartClam(clamItem, true)
+		newEntryID, err := xpack.StartClam(&clamItem, true)
 		if err != nil {
 			return err
 		}
@@ -275,7 +266,7 @@ func (c *ClamService) UpdateStatus(id uint, status string) error {
 		err     error
 	)
 	if status == constant.StatusEnable {
-		entryID, err = xpack.StartClam(clam, true)
+		entryID, err = xpack.StartClam(&clam, true)
 		if err != nil {
 			return err
 		}
@@ -293,9 +284,10 @@ func (c *ClamService) Delete(req dto.ClamDelete) error {
 		if clam.ID == 0 {
 			continue
 		}
-		if req.RemoveRecord {
-			_ = os.RemoveAll(path.Join(global.Dir.DataDir, resultDir, clam.Name))
+		if len(clam.Spec) != 0 {
+			global.Cron.Remove(cron.EntryID(clam.EntryID))
 		}
+		_ = c.CleanRecord(clam.ID)
 		if req.RemoveInfected {
 			_ = os.RemoveAll(path.Join(clam.InfectedDir, "1panel-infected", clam.Name))
 		}
@@ -310,128 +302,78 @@ func (c *ClamService) Delete(req dto.ClamDelete) error {
 	return nil
 }
 
-func (c *ClamService) HandleOnce(req dto.OperateByID) error {
-	if cleaned := StopAllCronJob(true); cleaned {
+func (c *ClamService) HandleOnce(id uint) error {
+	if active := clam.CheckClamIsActive(true, clamRepo); !active {
 		return buserr.New("ErrClamdscanNotFound")
 	}
-	clam, _ := clamRepo.Get(repo.WithByID(req.ID))
-	if clam.ID == 0 {
+	clamItem, _ := clamRepo.Get(repo.WithByID(id))
+	if clamItem.ID == 0 {
 		return buserr.New("ErrRecordNotFound")
 	}
-	if cmd.CheckIllegal(clam.Path) {
-		return buserr.New("ErrCmdIllegal")
-	}
-	timeNow := time.Now().Format(constant.DateTimeSlimLayout)
-	logFile := path.Join(global.Dir.DataDir, resultDir, clam.Name, timeNow)
-	if _, err := os.Stat(path.Dir(logFile)); err != nil {
-		_ = os.MkdirAll(path.Dir(logFile), os.ModePerm)
+	record := clamRepo.StartRecords(clamItem.ID)
+	taskItem, err := task.NewTaskWithOps("clam-"+clamItem.Name, task.TaskScan, task.TaskScopeClam, record.TaskID, clamItem.ID)
+	if err != nil {
+		return fmt.Errorf("new task for exec shell failed, err: %v", err)
 	}
+	clam.AddScanTask(taskItem, clamItem, record.StartTime.Format(constant.DateTimeSlimLayout))
 	go func() {
-		strategy := ""
-		switch clam.InfectedStrategy {
-		case "remove":
-			strategy = "--remove"
-		case "move":
-			dir := path.Join(clam.InfectedDir, "1panel-infected", clam.Name, timeNow)
-			strategy = "--move=" + dir
-			if _, err := os.Stat(dir); err != nil {
-				_ = os.MkdirAll(dir, os.ModePerm)
-			}
-		case "copy":
-			dir := path.Join(clam.InfectedDir, "1panel-infected", clam.Name, timeNow)
-			strategy = "--copy=" + dir
-			if _, err := os.Stat(dir); err != nil {
-				_ = os.MkdirAll(dir, os.ModePerm)
-			}
+		err := taskItem.Execute()
+		taskRepo := repo.NewITaskRepo()
+		taskItem, _ := taskRepo.GetFirst(taskRepo.WithByID(record.TaskID))
+		if len(taskItem.ID) == 0 {
+			record.TaskID = ""
 		}
-		global.LOG.Debugf("clamdscan --fdpass %s %s -l %s", strategy, clam.Path, logFile)
-		stdout, err := cmd.RunDefaultWithStdoutBashCf("clamdscan --fdpass %s %s -l %s", strategy, clam.Path, logFile)
 		if err != nil {
-			global.LOG.Errorf("clamdscan failed, stdout: %v, err: %v", stdout, err)
+			clamRepo.EndRecords(record, constant.StatusFailed, err.Error())
+			return
 		}
-		handleAlert(stdout, clam.Name, clam.ID)
+		handleAlert(record.InfectedFiles, clamItem.Name, clamItem.ID)
+		clam.AnalysisFromLog(taskItem.LogFile, &record)
+		clamRepo.EndRecords(record, constant.StatusDone, "")
 	}()
 	return nil
 }
 
-func (c *ClamService) LoadRecords(req dto.ClamLogSearch) (int64, interface{}, error) {
+func (c *ClamService) SearchRecords(req dto.ClamLogSearch) (int64, interface{}, error) {
 	clam, _ := clamRepo.Get(repo.WithByID(req.ClamID))
 	if clam.ID == 0 {
 		return 0, nil, buserr.New("ErrRecordNotFound")
 	}
-	logPaths := loadFileByName(clam.Name)
-	if len(logPaths) == 0 {
-		return 0, nil, nil
-	}
 
-	var filterFiles []string
-	nyc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
-	for _, item := range logPaths {
-		t1, err := time.ParseInLocation(constant.DateTimeSlimLayout, item, nyc)
-		if err != nil {
-			continue
+	total, records, err := clamRepo.PageRecords(req.Page, req.PageSize, clamRepo.WithByClamID(req.ClamID), repo.WithByStatus(req.Status), repo.WithByCreatedAt(req.StartTime, req.EndTime))
+	if err != nil {
+		return 0, nil, err
+	}
+	var datas []dto.ClamRecord
+	for _, record := range records {
+		var item dto.ClamRecord
+		if err := copier.Copy(&item, &record); err != nil {
+			return 0, nil, buserr.WithDetail("ErrStructTransform", err.Error(), nil)
 		}
-		if t1.After(req.StartTime) && t1.Before(req.EndTime) {
-			filterFiles = append(filterFiles, item)
-		}
-	}
-	if len(filterFiles) == 0 {
-		return 0, nil, nil
-	}
-
-	sort.Slice(filterFiles, func(i, j int) bool {
-		return filterFiles[i] > filterFiles[j]
-	})
-
-	var records []string
-	total, start, end := len(filterFiles), (req.Page-1)*req.PageSize, req.Page*req.PageSize
-	if start > total {
-		records = make([]string, 0)
-	} else {
-		if end >= total {
-			end = total
-		}
-		records = filterFiles[start:end]
-	}
-
-	var datas []dto.ClamLog
-	for i := 0; i < len(records); i++ {
-		item := loadResultFromLog(path.Join(global.Dir.DataDir, resultDir, clam.Name, records[i]))
 		datas = append(datas, item)
 	}
 	return int64(total), datas, nil
 }
-func (c *ClamService) LoadRecordLog(req dto.ClamLogReq) (string, error) {
-	logPath := path.Join(global.Dir.DataDir, resultDir, req.ClamName, req.RecordName)
-	var tail string
-	if req.Tail != "0" {
-		tail = req.Tail
-	} else {
-		tail = "+1"
-	}
-	cmd := exec.Command("tail", "-n", tail, logPath)
-	stdout, err := cmd.CombinedOutput()
-	if err != nil {
-		return "", fmt.Errorf("tail -n %v failed, err: %v", req.Tail, err)
-	}
-	return string(stdout), nil
-}
 
-func (c *ClamService) CleanRecord(req dto.OperateByID) error {
-	clam, _ := clamRepo.Get(repo.WithByID(req.ID))
-	if clam.ID == 0 {
-		return buserr.New("ErrRecordNotFound")
+func (c *ClamService) CleanRecord(id uint) error {
+	record, _ := clamRepo.ListRecord()
+	for _, item := range record {
+		if len(item.TaskID) != 0 {
+			continue
+		}
+		taskItem, _ := taskRepo.GetFirst(taskRepo.WithByID(item.TaskID))
+		if len(taskItem.LogFile) != 0 {
+			_ = os.Remove(taskItem.LogFile)
+		}
 	}
-	pathItem := path.Join(global.Dir.DataDir, resultDir, clam.Name)
-	_ = os.RemoveAll(pathItem)
-	return nil
+	return clamRepo.DeleteRecord(clamRepo.WithByClamID(id))
 }
 
 func (c *ClamService) LoadFile(req dto.ClamFileReq) (string, error) {
 	filePath := ""
 	switch req.Name {
 	case "clamd":
-		if c.serviceName == clamServiceNameUbuntu {
+		if c.serviceName == constant.ClamServiceNameUbuntu {
 			filePath = "/etc/clamav/clamd.conf"
 		} else {
 			filePath = "/etc/clamd.d/scan.conf"
@@ -441,13 +383,13 @@ func (c *ClamService) LoadFile(req dto.ClamFileReq) (string, error) {
 		if len(filePath) != 0 {
 			break
 		}
-		if c.serviceName == clamServiceNameUbuntu {
+		if c.serviceName == constant.ClamServiceNameUbuntu {
 			filePath = "/var/log/clamav/clamav.log"
 		} else {
 			filePath = "/var/log/clamd.scan"
 		}
 	case "freshclam":
-		if c.serviceName == clamServiceNameUbuntu {
+		if c.serviceName == constant.ClamServiceNameUbuntu {
 			filePath = "/etc/clamav/freshclam.conf"
 		} else {
 			filePath = "/etc/freshclam.conf"
@@ -457,7 +399,7 @@ func (c *ClamService) LoadFile(req dto.ClamFileReq) (string, error) {
 		if len(filePath) != 0 {
 			break
 		}
-		if c.serviceName == clamServiceNameUbuntu {
+		if c.serviceName == constant.ClamServiceNameUbuntu {
 			filePath = "/var/log/clamav/freshclam.log"
 		} else {
 			filePath = "/var/log/freshclam.log"
@@ -487,15 +429,15 @@ func (c *ClamService) UpdateFile(req dto.UpdateByNameAndFile) error {
 	service := ""
 	switch req.Name {
 	case "clamd":
-		if c.serviceName == clamServiceNameUbuntu {
-			service = clamServiceNameUbuntu
+		if c.serviceName == constant.ClamServiceNameUbuntu {
+			service = constant.ClamServiceNameUbuntu
 			filePath = "/etc/clamav/clamd.conf"
 		} else {
-			service = clamServiceNameCentOs
+			service = constant.ClamServiceNameCentOs
 			filePath = "/etc/clamd.d/scan.conf"
 		}
 	case "freshclam":
-		if c.serviceName == clamServiceNameUbuntu {
+		if c.serviceName == constant.ClamServiceNameUbuntu {
 			filePath = "/etc/clamav/freshclam.conf"
 		} else {
 			filePath = "/etc/freshclam.conf"
@@ -517,86 +459,16 @@ func (c *ClamService) UpdateFile(req dto.UpdateByNameAndFile) error {
 	return nil
 }
 
-func StopAllCronJob(withCheck bool) bool {
-	if withCheck {
-		isActive := false
-		exist1, _ := systemctl.IsExist(clamServiceNameCentOs)
-		if exist1 {
-			isActive, _ = systemctl.IsActive(clamServiceNameCentOs)
-		}
-		exist2, _ := systemctl.IsExist(clamServiceNameUbuntu)
-		if exist2 {
-			isActive, _ = systemctl.IsActive(clamServiceNameUbuntu)
-		}
-		if isActive {
-			return false
-		}
-	}
-	clams, _ := clamRepo.List(repo.WithByStatus(constant.StatusEnable))
-	for i := 0; i < len(clams); i++ {
-		global.Cron.Remove(cron.EntryID(clams[i].EntryID))
-		_ = clamRepo.Update(clams[i].ID, map[string]interface{}{"status": constant.StatusDisable, "entry_id": 0})
-	}
-	return true
-}
-
-func loadFileByName(name string) []string {
-	var logPaths []string
-	pathItem := path.Join(global.Dir.DataDir, resultDir, name)
-	fileItems, err := os.ReadDir(pathItem)
-	if err != nil {
-		return logPaths
-	}
-	for _, item := range fileItems {
-		if !item.IsDir() {
-			logPaths = append(logPaths, item.Name())
-		}
-	}
-	return logPaths
-}
-func loadResultFromLog(pathItem string) dto.ClamLog {
-	var data dto.ClamLog
-	data.Name = path.Base(pathItem)
-	data.Status = constant.StatusWaiting
-	file, err := os.ReadFile(pathItem)
-	if err != nil {
-		return data
-	}
-	lines := strings.Split(string(file), "\n")
-	for _, line := range lines {
-		if strings.Contains(line, "- SCAN SUMMARY -") {
-			data.Status = constant.StatusDone
-		}
-		if data.Status != constant.StatusDone {
-			continue
-		}
-		switch {
-		case strings.HasPrefix(line, "Infected files:"):
-			data.InfectedFiles = strings.TrimPrefix(line, "Infected files:")
-		case strings.HasPrefix(line, "Total errors:"):
-			data.TotalError = strings.TrimPrefix(line, "Total errors:")
-		case strings.HasPrefix(line, "Time:"):
-			if strings.Contains(line, "(") {
-				data.ScanTime = strings.ReplaceAll(strings.Split(line, "(")[1], ")", "")
-				continue
-			}
-			data.ScanTime = strings.TrimPrefix(line, "Time:")
-		case strings.HasPrefix(line, "Start Date:"):
-			data.ScanDate = strings.TrimPrefix(line, "Start Date:")
-		}
-	}
-	return data
-}
 func (c *ClamService) loadLogPath(name string) string {
 	confPath := ""
 	if name == "clamd-log" {
-		if c.serviceName == clamServiceNameUbuntu {
+		if c.serviceName == constant.ClamServiceNameUbuntu {
 			confPath = "/etc/clamav/clamd.conf"
 		} else {
 			confPath = "/etc/clamd.d/scan.conf"
 		}
 	} else {
-		if c.serviceName == clamServiceNameUbuntu {
+		if c.serviceName == constant.ClamServiceNameUbuntu {
 			confPath = "/etc/clamav/freshclam.conf"
 		} else {
 			confPath = "/etc/freshclam.conf"
@@ -627,23 +499,16 @@ func (c *ClamService) loadLogPath(name string) string {
 	return ""
 }
 
-func handleAlert(stdout, clamName string, clamId uint) {
-	if strings.Contains(stdout, "- SCAN SUMMARY -") {
-		lines := strings.Split(stdout, "\n")
-		for _, line := range lines {
-			if strings.HasPrefix(line, "Infected files: ") {
-				infectedFiles, _ := strconv.Atoi(strings.TrimPrefix(line, "Infected files: "))
-				if infectedFiles > 0 {
-					pushAlert := dto.PushAlert{
-						TaskName:  clamName,
-						AlertType: "clams",
-						EntryID:   clamId,
-						Param:     strconv.Itoa(infectedFiles),
-					}
-					_ = alert_push.PushAlert(pushAlert)
-					break
-				}
-			}
-		}
+func handleAlert(infectedFiles, clamName string, clamId uint) {
+	itemInfected, _ := strconv.Atoi(strings.TrimSpace(infectedFiles))
+	if itemInfected < 0 {
+		return
 	}
+	pushAlert := dto.PushAlert{
+		TaskName:  clamName,
+		AlertType: "clams",
+		EntryID:   clamId,
+		Param:     strconv.Itoa(itemInfected),
+	}
+	_ = alert_push.PushAlert(pushAlert)
 }

agent/app/service/container.go

@@ -45,8 +45,8 @@ import (
 	"github.com/docker/docker/client"
 	"github.com/docker/go-connections/nat"
 	v1 "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/shirou/gopsutil/v3/cpu"
-	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v4/cpu"
+	"github.com/shirou/gopsutil/v4/mem"
 )
 
 type ContainerService struct{}
@@ -54,6 +54,7 @@ type ContainerService struct{}
 type IContainerService interface {
 	Page(req dto.PageContainer) (int64, interface{}, error)
 	List() []dto.ContainerOptions
+	ListByImage(imageName string) []dto.ContainerOptions
 	LoadStatus() (dto.ContainerStatus, error)
 	PageNetwork(req dto.SearchWithPage) (int64, interface{}, error)
 	ListNetwork() ([]dto.Options, error)
@@ -82,7 +83,7 @@ type IContainerService interface {
 	CreateVolume(req dto.VolumeCreate) error
 	TestCompose(req dto.ComposeCreate) (bool, error)
 	ComposeUpdate(req dto.ComposeUpdate) error
-	Prune(req dto.ContainerPrune) (dto.ContainerPruneReport, error)
+	Prune(req dto.ContainerPrune) error
 
 	LoadUsers(req dto.OperationWithName) []string
 
@@ -246,6 +247,33 @@ func (u *ContainerService) List() []dto.ContainerOptions {
 	return options
 }
 
+func (u *ContainerService) ListByImage(imageName string) []dto.ContainerOptions {
+	var options []dto.ContainerOptions
+	client, err := docker.NewDockerClient()
+	if err != nil {
+		global.LOG.Errorf("load docker client for contianer list failed, err: %v", err)
+		return nil
+	}
+	defer client.Close()
+	containers, err := client.ContainerList(context.Background(), container.ListOptions{All: true})
+	if err != nil {
+		global.LOG.Errorf("load container list failed, err: %v", err)
+		return nil
+	}
+	for _, container := range containers {
+		if container.Image != imageName {
+			continue
+		}
+		for _, name := range container.Names {
+			if len(name) != 0 {
+				options = append(options, dto.ContainerOptions{Name: strings.TrimPrefix(name, "/"), State: container.State})
+			}
+		}
+	}
+
+	return options
+}
+
 func (u *ContainerService) LoadStatus() (dto.ContainerStatus, error) {
 	var data dto.ContainerStatus
 	client, err := docker.NewDockerClient()
@@ -417,66 +445,93 @@ func (u *ContainerService) Inspect(req dto.InspectReq) (string, error) {
 	return string(bytes), nil
 }
 
-func (u *ContainerService) Prune(req dto.ContainerPrune) (dto.ContainerPruneReport, error) {
-	report := dto.ContainerPruneReport{}
+func (u *ContainerService) Prune(req dto.ContainerPrune) error {
 	client, err := docker.NewDockerClient()
 	if err != nil {
-		return report, err
+		return err
 	}
 	defer client.Close()
-	pruneFilters := filters.NewArgs()
-	if req.WithTagAll {
-		pruneFilters.Add("dangling", "false")
-		if req.PruneType != "image" {
-			pruneFilters.Add("until", "24h")
-		}
-	}
+	name := ""
 	switch req.PruneType {
 	case "container":
-		rep, err := client.ContainersPrune(context.Background(), pruneFilters)
-		if err != nil {
-			return report, err
-		}
-		report.DeletedNumber = len(rep.ContainersDeleted)
-		report.SpaceReclaimed = int(rep.SpaceReclaimed)
+		name = "Container"
 	case "image":
-		rep, err := client.ImagesPrune(context.Background(), pruneFilters)
-		if err != nil {
-			return report, err
-		}
-		report.DeletedNumber = len(rep.ImagesDeleted)
-		report.SpaceReclaimed = int(rep.SpaceReclaimed)
-	case "network":
-		rep, err := client.NetworksPrune(context.Background(), pruneFilters)
-		if err != nil {
-			return report, err
-		}
-		report.DeletedNumber = len(rep.NetworksDeleted)
+		name = "Image"
 	case "volume":
-		versions, err := client.ServerVersion(context.Background())
-		if err != nil {
-			return report, err
-		}
-		if common.ComparePanelVersion(versions.APIVersion, "1.42") {
-			pruneFilters.Add("all", "true")
-		}
-		rep, err := client.VolumesPrune(context.Background(), pruneFilters)
-		if err != nil {
-			return report, err
-		}
-		report.DeletedNumber = len(rep.VolumesDeleted)
-		report.SpaceReclaimed = int(rep.SpaceReclaimed)
+		name = "Volume"
 	case "buildcache":
-		opts := build.CachePruneOptions{}
-		opts.All = true
-		rep, err := client.BuildCachePrune(context.Background(), opts)
-		if err != nil {
-			return report, err
-		}
-		report.DeletedNumber = len(rep.CachesDeleted)
-		report.SpaceReclaimed = int(rep.SpaceReclaimed)
+		name = "BuildCache"
+	case "network":
+		name = "Network"
 	}
-	return report, nil
+	taskItem, err := task.NewTaskWithOps(i18n.GetMsgByKey(name), task.TaskClean, task.TaskScopeContainer, req.TaskID, 1)
+	if err != nil {
+		global.LOG.Errorf("new task for create container failed, err: %v", err)
+		return err
+	}
+
+	taskItem.AddSubTask(i18n.GetMsgByKey("TaskClean"), func(t *task.Task) error {
+		pruneFilters := filters.NewArgs()
+		if req.WithTagAll {
+			pruneFilters.Add("dangling", "false")
+			if req.PruneType != "image" {
+				pruneFilters.Add("until", "24h")
+			}
+		}
+		DeletedNumber := 0
+		SpaceReclaimed := 0
+		switch req.PruneType {
+		case "container":
+			rep, err := client.ContainersPrune(context.Background(), pruneFilters)
+			if err != nil {
+				return err
+			}
+			DeletedNumber = len(rep.ContainersDeleted)
+			SpaceReclaimed = int(rep.SpaceReclaimed)
+		case "image":
+			rep, err := client.ImagesPrune(context.Background(), pruneFilters)
+			if err != nil {
+				return err
+			}
+			DeletedNumber = len(rep.ImagesDeleted)
+			SpaceReclaimed = int(rep.SpaceReclaimed)
+		case "network":
+			rep, err := client.NetworksPrune(context.Background(), pruneFilters)
+			if err != nil {
+				return err
+			}
+			DeletedNumber = len(rep.NetworksDeleted)
+		case "volume":
+			versions, err := client.ServerVersion(context.Background())
+			if err != nil {
+				return err
+			}
+			if common.ComparePanelVersion(versions.APIVersion, "1.42") {
+				pruneFilters.Add("all", "true")
+			}
+			rep, err := client.VolumesPrune(context.Background(), pruneFilters)
+			if err != nil {
+				return err
+			}
+			DeletedNumber = len(rep.VolumesDeleted)
+			SpaceReclaimed = int(rep.SpaceReclaimed)
+		case "buildcache":
+			opts := build.CachePruneOptions{}
+			opts.All = true
+			rep, err := client.BuildCachePrune(context.Background(), opts)
+			if err != nil {
+				return err
+			}
+			DeletedNumber = len(rep.CachesDeleted)
+			SpaceReclaimed = int(rep.SpaceReclaimed)
+		}
+		taskItem.Log(i18n.GetMsgWithMap("PruneHelper", map[string]interface{}{"name": i18n.GetMsgByKey(name), "count": DeletedNumber, "size": common.LoadSizeUnit2F(float64(SpaceReclaimed))}))
+		return nil
+	}, nil)
+	go func() {
+		_ = taskItem.Execute()
+	}()
+	return nil
 }
 
 func (u *ContainerService) LoadResourceLimit() (*dto.ResourceLimit, error) {
@@ -718,17 +773,14 @@ func (u *ContainerService) ContainerUpgrade(req dto.ContainerUpgrade) error {
 	}
 	defer client.Close()
 	ctx := context.Background()
-	oldContainer, err := client.ContainerInspect(ctx, req.Name)
-	if err != nil {
-		return err
-	}
-	taskItem, err := task.NewTaskWithOps(req.Name, task.TaskUpgrade, task.TaskScopeContainer, req.TaskID, 1)
+	taskItem, err := task.NewTaskWithOps(req.Image, task.TaskUpgrade, task.TaskScopeImage, req.TaskID, 1)
 	if err != nil {
 		global.LOG.Errorf("new task for create container failed, err: %v", err)
 		return err
 	}
 	go func() {
 		taskItem.AddSubTask(i18n.GetWithName("ContainerImagePull", req.Image), func(t *task.Task) error {
+			taskItem.LogStart(i18n.GetWithName("ContainerImagePull", req.Image))
 			if !checkImageExist(client, req.Image) || req.ForcePull {
 				if err := pullImages(taskItem, client, req.Image); err != nil {
 					if !req.ForcePull {
@@ -739,38 +791,49 @@ func (u *ContainerService) ContainerUpgrade(req dto.ContainerUpgrade) error {
 			}
 			return nil
 		}, nil)
-
-		taskItem.AddSubTask(i18n.GetWithName("ContainerCreate", req.Name), func(t *task.Task) error {
-			config := oldContainer.Config
-			config.Image = req.Image
-			hostConf := oldContainer.HostConfig
-			var networkConf network.NetworkingConfig
-			if oldContainer.NetworkSettings != nil {
-				for networkKey := range oldContainer.NetworkSettings.Networks {
-					networkConf.EndpointsConfig = map[string]*network.EndpointSettings{networkKey: {}}
-					break
+		for _, item := range req.Names {
+			var oldContainer container.InspectResponse
+			taskItem.AddSubTask(i18n.GetWithName("ContainerLoadInfo", item), func(t *task.Task) error {
+				taskItem.Logf("----------------- %s -----------------", item)
+				oldContainer, err = client.ContainerInspect(ctx, item)
+				if err != nil {
+					return err
 				}
-			}
-			err := client.ContainerRemove(ctx, req.Name, container.RemoveOptions{Force: true})
-			taskItem.LogWithStatus(i18n.GetWithName("ContainerRemoveOld", req.Name), err)
-			if err != nil {
-				return err
-			}
+				return nil
+			}, nil)
 
-			con, err := client.ContainerCreate(ctx, config, hostConf, &networkConf, &v1.Platform{}, req.Name)
-			if err != nil {
-				taskItem.Log(i18n.GetMsgByKey("ContainerRecreate"))
-				reCreateAfterUpdate(req.Name, client, oldContainer.Config, oldContainer.HostConfig, oldContainer.NetworkSettings)
-				return fmt.Errorf("upgrade container failed, err: %v", err)
-			}
-			err = client.ContainerStart(ctx, con.ID, container.StartOptions{})
-			taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerStartCheck"), err)
-			if err != nil {
-				return fmt.Errorf("upgrade successful but start failed, err: %v", err)
-			}
-			return nil
-		}, nil)
+			taskItem.AddSubTask(i18n.GetWithName("ContainerCreate", item), func(t *task.Task) error {
+				config := oldContainer.Config
+				config.Image = req.Image
+				hostConf := oldContainer.HostConfig
+				var networkConf network.NetworkingConfig
+				if oldContainer.NetworkSettings != nil {
+					for networkKey := range oldContainer.NetworkSettings.Networks {
+						networkConf.EndpointsConfig = map[string]*network.EndpointSettings{networkKey: {}}
+						break
+					}
+				}
+				err := client.ContainerRemove(ctx, item, container.RemoveOptions{Force: true})
+				taskItem.LogWithStatus(i18n.GetWithName("ContainerRemoveOld", item), err)
+				if err != nil {
+					return err
+				}
 
+				con, err := client.ContainerCreate(ctx, config, hostConf, &networkConf, &v1.Platform{}, item)
+				if err != nil {
+					taskItem.Log(i18n.GetMsgByKey("ContainerRecreate"))
+					reCreateAfterUpdate(item, client, oldContainer.Config, oldContainer.HostConfig, oldContainer.NetworkSettings)
+					return fmt.Errorf("upgrade container failed, err: %v", err)
+				}
+				err = client.ContainerStart(ctx, con.ID, container.StartOptions{})
+				taskItem.LogWithStatus(i18n.GetMsgByKey("ContainerStartCheck"), err)
+				if err != nil {
+					return fmt.Errorf("upgrade successful but start failed, err: %v", err)
+				}
+				return nil
+			}, nil)
+
+		}
 		if err := taskItem.Execute(); err != nil {
 			global.LOG.Error(err.Error())
 		}
@@ -1241,29 +1304,29 @@ func checkImageExist(client *client.Client, imageItem string) bool {
 }
 
 func checkImageLike(client *client.Client, imageName string) bool {
-    if client == nil {
-        var err error
-        client, err = docker.NewDockerClient()
-        if err != nil {
-            return false
-        }
-    }
-    images, err := client.ImageList(context.Background(), image.ListOptions{})
-    if err != nil {
-        return false
-    }
+	if client == nil {
+		var err error
+		client, err = docker.NewDockerClient()
+		if err != nil {
+			return false
+		}
+	}
+	images, err := client.ImageList(context.Background(), image.ListOptions{})
+	if err != nil {
+		return false
+	}
 
-    for _, img := range images {
-        for _, tag := range img.RepoTags {
-            parts := strings.Split(tag, "/")
-            imageNameWithTag := parts[len(parts)-1]
+	for _, img := range images {
+		for _, tag := range img.RepoTags {
+			parts := strings.Split(tag, "/")
+			imageNameWithTag := parts[len(parts)-1]
 
-            if imageNameWithTag == imageName {
-                return true
-            }
-        }
-    }
-    return false
+			if imageNameWithTag == imageName {
+				return true
+			}
+		}
+	}
+	return false
 }
 
 func pullImages(task *task.Task, client *client.Client, imageName string) error {
@@ -1351,7 +1414,7 @@ func checkPortStats(ports []dto.PortHelper) (nat.PortMap, error) {
 				portMap[nat.Port(fmt.Sprintf("%d/%s", containerStart+i, port.Protocol))] = []nat.PortBinding{bindItem}
 			}
 			for i := hostStart; i <= hostEnd; i++ {
-				if common.ScanPort(i) {
+				if common.ScanPortWithIP(port.HostIP, i) {
 					return portMap, buserr.WithDetail("ErrPortInUsed", i, nil)
 				}
 			}
@@ -1362,7 +1425,7 @@ func checkPortStats(ports []dto.PortHelper) (nat.PortMap, error) {
 			} else {
 				portItem, _ = strconv.Atoi(port.HostPort)
 			}
-			if common.ScanPort(portItem) {
+			if common.ScanPortWithIP(port.HostIP, portItem) {
 				return portMap, buserr.WithDetail("ErrPortInUsed", portItem, nil)
 			}
 			bindItem := nat.PortBinding{HostPort: strconv.Itoa(portItem), HostIP: port.HostIP}

agent/app/service/container_compose.go

@@ -10,12 +10,9 @@ import (
 	"strings"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/agent/app/repo"
-
-	"github.com/docker/docker/api/types/container"
-
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/repo"
 	"github.com/1Panel-dev/1Panel/agent/app/task"
 	"github.com/1Panel-dev/1Panel/agent/buserr"
 	"github.com/1Panel-dev/1Panel/agent/constant"
@@ -24,6 +21,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/compose"
 	"github.com/1Panel-dev/1Panel/agent/utils/docker"
+	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	"golang.org/x/net/context"
 )
@@ -54,14 +52,13 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 	}
 
 	composeCreatedByLocal, _ := composeRepo.ListRecord()
-
 	composeLocalMap := make(map[string]dto.ComposeInfo)
 	for _, localItem := range composeCreatedByLocal {
 		composeItemLocal := dto.ComposeInfo{
-			ContainerNumber: 0,
-			CreatedAt:       localItem.CreatedAt.Format(constant.DateTimeLayout),
-			ConfigFile:      localItem.Path,
-			Workdir:         strings.TrimSuffix(localItem.Path, "/docker-compose.yml"),
+			ContainerCount: 0,
+			CreatedAt:      localItem.CreatedAt.Format(constant.DateTimeLayout),
+			ConfigFile:     localItem.Path,
+			Workdir:        strings.TrimSuffix(localItem.Path, "/docker-compose.yml"),
 		}
 		composeItemLocal.CreatedBy = "1Panel"
 		composeItemLocal.Path = localItem.Path
@@ -78,18 +75,24 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 				CreateTime:  time.Unix(container.Created, 0).Format(constant.DateTimeLayout),
 			}
 			if compose, has := composeMap[name]; has {
-				compose.ContainerNumber++
+				compose.ContainerCount++
+				if strings.ToLower(containerItem.State) == "running" {
+					compose.RunningCount++
+				}
 				compose.Containers = append(compose.Containers, containerItem)
 				composeMap[name] = compose
 			} else {
 				config := container.Labels[composeConfigLabel]
 				workdir := container.Labels[composeWorkdirLabel]
 				composeItem := dto.ComposeInfo{
-					ContainerNumber: 1,
-					CreatedAt:       time.Unix(container.Created, 0).Format(constant.DateTimeLayout),
-					ConfigFile:      config,
-					Workdir:         workdir,
-					Containers:      []dto.ComposeContainer{containerItem},
+					ContainerCount: 1,
+					CreatedAt:      time.Unix(container.Created, 0).Format(constant.DateTimeLayout),
+					ConfigFile:     config,
+					Workdir:        workdir,
+					Containers:     []dto.ComposeContainer{containerItem},
+				}
+				if strings.ToLower(containerItem.State) == "running" {
+					composeItem.RunningCount = 1
 				}
 				createdBy, ok := container.Labels[composeCreatedBy]
 				if ok {
@@ -118,8 +121,8 @@ func (u *ContainerService) PageCompose(req dto.SearchWithPage) (int64, interface
 	}
 	for key, item := range composeMap {
 		if existingItem, exists := mergedMap[key]; exists {
-			if item.ContainerNumber > 0 {
-				if existingItem.ContainerNumber <= 0 {
+			if item.ContainerCount > 0 {
+				if existingItem.ContainerCount <= 0 {
 					mergedMap[key] = item
 				}
 			}
@@ -224,12 +227,9 @@ func (u *ContainerService) ComposeOperation(req dto.ComposeOperation) error {
 	if cmd.CheckIllegal(req.Path, req.Operation) {
 		return buserr.New("ErrCmdIllegal")
 	}
-	if _, err := os.Stat(req.Path); err != nil {
-		return fmt.Errorf("load file with path %s failed, %v", req.Path, err)
-	}
 	if req.Operation == "delete" {
-		if stdout, err := compose.Operate(req.Path, "down"); err != nil {
-			return errors.New(string(stdout))
+		if err := removeContainerForCompose(req.Name, req.Path); err != nil && !req.Force {
+			return err
 		}
 		if req.WithFile {
 			_ = os.RemoveAll(path.Dir(req.Path))
@@ -237,6 +237,9 @@ func (u *ContainerService) ComposeOperation(req dto.ComposeOperation) error {
 		_ = composeRepo.DeleteRecord(repo.WithByName(req.Name))
 		return nil
 	}
+	if _, err := os.Stat(req.Path); err != nil {
+		return fmt.Errorf("load file with path %s failed, %v", req.Path, err)
+	}
 	if req.Operation == "up" {
 		if stdout, err := compose.Up(req.Path); err != nil {
 			return errors.New(string(stdout))
@@ -305,6 +308,33 @@ func (u *ContainerService) loadPath(req *dto.ComposeCreate) error {
 	return nil
 }
 
+func removeContainerForCompose(composeName, composePath string) error {
+	if _, err := os.Stat(composePath); err == nil {
+		if stdout, err := compose.Operate(composePath, "down"); err != nil {
+			return errors.New(stdout)
+		}
+		return nil
+	}
+	var options container.ListOptions
+	options.All = true
+	options.Filters = filters.NewArgs()
+	options.Filters.Add("label", "com.docker.compose.project="+composeName)
+	client, err := docker.NewDockerClient()
+	if err != nil {
+		return err
+	}
+	defer client.Close()
+	ctx := context.Background()
+	containers, err := client.ContainerList(ctx, options)
+	if err != nil {
+		return err
+	}
+	for _, c := range containers {
+		_ = client.ContainerRemove(ctx, c.ID, container.RemoveOptions{RemoveVolumes: true, Force: true})
+	}
+	return nil
+}
+
 func recreateCompose(content, path string) error {
 	file, err := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0640)
 	if err != nil {

agent/app/service/container_volume.go

@@ -5,6 +5,7 @@ import (
 	"sort"
 	"strings"
 	"time"
+	"unicode"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/buserr"
@@ -53,25 +54,27 @@ func (u *ContainerService) PageVolume(req dto.SearchWithPage) (int64, interface{
 
 	nyc, _ := time.LoadLocation(common.LoadTimeZoneByCmd())
 	for _, item := range records {
-		tag := make([]string, 0)
-		for _, val := range item.Labels {
-			tag = append(tag, val)
+		var volume dto.Volume
+		volume.Driver = item.Driver
+		volume.Mountpoint = item.Mountpoint
+		volume.Name = simplifyVolumeName(item.Name)
+		for key, val := range item.Labels {
+			volume.Labels = append(volume.Labels, dto.VolumeOption{Key: key, Value: val})
 		}
-		var createTime time.Time
-		if strings.Contains(item.CreatedAt, "Z") {
-			createTime, _ = time.ParseInLocation("2006-01-02T15:04:05Z", item.CreatedAt, nyc)
-		} else if strings.Contains(item.CreatedAt, "+") {
-			createTime, _ = time.ParseInLocation("2006-01-02T15:04:05+08:00", item.CreatedAt, nyc)
-		} else {
-			createTime, _ = time.ParseInLocation("2006-01-02T15:04:05", item.CreatedAt, nyc)
+		for key, val := range item.Options {
+			volume.Options = append(volume.Options, dto.VolumeOption{Key: key, Value: val})
 		}
-		data = append(data, dto.Volume{
-			CreatedAt:  createTime,
-			Name:       item.Name,
-			Driver:     item.Driver,
-			Mountpoint: item.Mountpoint,
-			Labels:     tag,
+		sort.Slice(volume.Options, func(i, j int) bool {
+			return volume.Options[i].Key < volume.Options[j].Key
 		})
+		if strings.Contains(item.CreatedAt, "Z") {
+			volume.CreatedAt, _ = time.ParseInLocation("2006-01-02T15:04:05Z", item.CreatedAt, nyc)
+		} else if strings.Contains(item.CreatedAt, "+") {
+			volume.CreatedAt, _ = time.ParseInLocation("2006-01-02T15:04:05+08:00", item.CreatedAt, nyc)
+		} else {
+			volume.CreatedAt, _ = time.ParseInLocation("2006-01-02T15:04:05", item.CreatedAt, nyc)
+		}
+		data = append(data, volume)
 	}
 
 	return int64(total), data, nil
@@ -140,3 +143,16 @@ func (u *ContainerService) CreateVolume(req dto.VolumeCreate) error {
 	}
 	return nil
 }
+
+func simplifyVolumeName(name string) string {
+	if len(name) != 64 {
+		return name
+	}
+
+	for _, char := range name {
+		if !unicode.Is(unicode.ASCII_Hex_Digit, char) {
+			return name
+		}
+	}
+	return name[:12]
+}

agent/app/service/cronjob.go

@@ -32,8 +32,8 @@ type ICronjobService interface {
 	HandleOnce(id uint) error
 	Update(id uint, req dto.CronjobOperate) error
 	UpdateStatus(id uint, status string) error
+	UpdateGroup(req dto.ChangeGroup) error
 	Delete(req dto.CronjobBatchDelete) error
-	Download(down dto.CronjobDownload) (string, error)
 	StartJob(cronjob *model.Cronjob, isUpdate bool) (string, error)
 	CleanRecord(req dto.CronjobClean) error
 
@@ -50,7 +50,11 @@ func NewICronjobService() ICronjobService {
 }
 
 func (u *CronjobService) SearchWithPage(search dto.PageCronjob) (int64, interface{}, error) {
-	total, cronjobs, err := cronjobRepo.Page(search.Page, search.PageSize, repo.WithByLikeName(search.Info), repo.WithOrderRuleBy(search.OrderBy, search.Order))
+	total, cronjobs, err := cronjobRepo.Page(search.Page,
+		search.PageSize,
+		repo.WithByGroups(search.GroupIDs),
+		repo.WithByLikeName(search.Info),
+		repo.WithOrderRuleBy(search.OrderBy, search.Order))
 	var dtoCronjobs []dto.CronjobInfo
 	for _, cronjob := range cronjobs {
 		var item dto.CronjobInfo
@@ -116,6 +120,7 @@ func (u *CronjobService) Export(req dto.OperateByIDs) (string, error) {
 		item := dto.CronjobTrans{
 			Name:           cronjob.Name,
 			Type:           cronjob.Type,
+			GroupID:        cronjob.GroupID,
 			SpecCustom:     cronjob.SpecCustom,
 			Spec:           cronjob.Spec,
 			Executor:       cronjob.Executor,
@@ -211,6 +216,7 @@ func (u *CronjobService) Import(req []dto.CronjobTrans) error {
 		cronjob := model.Cronjob{
 			Name:           item.Name,
 			Type:           item.Type,
+			GroupID:        item.GroupID,
 			SpecCustom:     item.SpecCustom,
 			Spec:           item.Spec,
 			Executor:       item.Executor,
@@ -375,7 +381,7 @@ func (u *CronjobService) Import(req []dto.CronjobTrans) error {
 			cronjob.Status = constant.StatusDisable
 		}
 		_ = cronjobRepo.Create(&cronjob)
-		if item.AlertCount != 0 {
+		if item.AlertCount != 0 && item.AlertTitle != "" && item.AlertMethod != "" {
 			createAlert := dto.AlertCreate{
 				Title:     item.AlertTitle,
 				SendCount: item.AlertCount,
@@ -491,10 +497,7 @@ func (u *CronjobService) CleanRecord(req dto.CronjobClean) error {
 	}
 	if req.CleanData {
 		if hasBackup(cronjob.Type) {
-			accountMap, err := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
-			if err != nil {
-				return err
-			}
+			accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
 			if !req.CleanRemoteData {
 				for key := range accountMap {
 					if key != constant.Local {
@@ -528,37 +531,14 @@ func (u *CronjobService) CleanRecord(req dto.CronjobClean) error {
 	return nil
 }
 
-func (u *CronjobService) Download(req dto.CronjobDownload) (string, error) {
-	record, _ := cronjobRepo.GetRecord(repo.WithByID(req.RecordID))
-	if record.ID == 0 {
-		return "", buserr.New("ErrRecordNotFound")
-	}
-	account, client, err := NewBackupClientWithID(req.BackupAccountID)
-	if err != nil {
-		return "", err
-	}
-	if account.Type == "LOCAL" || record.FromLocal {
-		if _, err := os.Stat(record.File); err != nil && os.IsNotExist(err) {
-			return "", err
-		}
-		return record.File, nil
-	}
-	tempPath := fmt.Sprintf("%s/download/%s", global.Dir.DataDir, record.File)
-	if _, err := os.Stat(tempPath); err != nil && os.IsNotExist(err) {
-		_ = os.MkdirAll(path.Dir(tempPath), os.ModePerm)
-		isOK, err := client.Download(record.File, tempPath)
-		if !isOK || err != nil {
-			return "", err
-		}
-	}
-	return tempPath, nil
-}
-
 func (u *CronjobService) HandleOnce(id uint) error {
 	cronjob, _ := cronjobRepo.Get(repo.WithByID(id))
 	if cronjob.ID == 0 {
 		return buserr.New("ErrRecordNotFound")
 	}
+	if cronjob.IsExecuting {
+		return buserr.New("InExecuting")
+	}
 	u.HandleJob(&cronjob)
 	return nil
 }
@@ -599,7 +579,7 @@ func (u *CronjobService) Create(req dto.CronjobOperate) error {
 	if err := cronjobRepo.Create(&cronjob); err != nil {
 		return err
 	}
-	if req.AlertCount != 0 {
+	if req.AlertCount != 0 && req.AlertTitle != "" && req.AlertMethod != "" {
 		createAlert := dto.AlertCreate{
 			Title:     req.AlertTitle,
 			SendCount: req.AlertCount,
@@ -703,6 +683,7 @@ func (u *CronjobService) Update(id uint, req dto.CronjobOperate) error {
 		upMap["status"] = constant.StatusEnable
 	}
 	upMap["name"] = req.Name
+	upMap["group_id"] = req.GroupID
 	upMap["spec_custom"] = req.SpecCustom
 	upMap["spec"] = spec
 	upMap["script"] = req.Script
@@ -774,6 +755,14 @@ func (u *CronjobService) UpdateStatus(id uint, status string) error {
 	return cronjobRepo.Update(cronjob.ID, map[string]interface{}{"status": status, "entry_ids": entryIDs})
 }
 
+func (u *CronjobService) UpdateGroup(req dto.ChangeGroup) error {
+	cronjob, _ := cronjobRepo.Get(repo.WithByID(req.ID))
+	if cronjob.ID == 0 {
+		return buserr.New("ErrRecordNotFound")
+	}
+	return cronjobRepo.Update(cronjob.ID, map[string]interface{}{"group_id": req.GroupID})
+}
+
 func (u *CronjobService) AddCronJob(cronjob *model.Cronjob) (int, error) {
 	addFunc := func() {
 		u.HandleJob(cronjob)

agent/app/service/cronjob_backup.go

@@ -27,11 +27,12 @@ import (
 func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
 	apps := loadAppsForJob(cronjob)
 	if len(apps) == 0 {
-		return errors.New("no such app in database!")
+		addSkipTask("App", taskItem)
+		return nil
 	}
-	accountMap, err := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
-	if err != nil {
-		return err
+	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
+	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
+		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	for _, app := range apps {
 		retry := 0
@@ -44,31 +45,36 @@ func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time, t
 			record.DetailName = app.Name
 			record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
 			backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/app/%s/%s", app.App.Key, app.Name))
-			record.FileName = fmt.Sprintf("app_%s_%s.tar.gz", app.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
+			record.FileName = simplifiedFileName(fmt.Sprintf("app_%s_%s.tar.gz", app.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5)))
 			if err := doAppBackup(&app, task, backupDir, record.FileName, cronjob.ExclusionRules, cronjob.Secret); err != nil {
 				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
 					retry++
 					return err
 				} else {
 					task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+					cleanAccountMap(accountMap)
 					return nil
 				}
 			}
-			downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, record.FileName))
-			if err != nil {
+
+			src := path.Join(backupDir, record.FileName)
+			dst := strings.TrimPrefix(src, global.Dir.LocalBackupDir+"/tmp/")
+			if err := uploadWithMap(*task, accountMap, src, dst, cronjob.SourceAccountIDs, cronjob.DownloadAccountID, cronjob.RetryTimes); err != nil {
 				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
 					retry++
 					return err
 				}
 				task.Log(i18n.GetMsgWithDetail("IgnoreUploadErr", err.Error()))
+				cleanAccountMap(accountMap)
 				return nil
 			}
-			record.FileDir = path.Dir(downloadPath)
+			record.FileDir = path.Dir(dst)
 			if err := backupRepo.CreateRecord(&record); err != nil {
 				global.LOG.Errorf("save backup record failed, err: %v", err)
 				return err
 			}
 			u.removeExpiredBackup(cronjob, accountMap, record)
+			cleanAccountMap(accountMap)
 			return nil
 		}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
 	}
@@ -78,11 +84,12 @@ func (u *CronjobService) handleApp(cronjob model.Cronjob, startTime time.Time, t
 func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
 	webs := loadWebsForJob(cronjob)
 	if len(webs) == 0 {
-		return errors.New("no such website in database!")
+		addSkipTask("Website", taskItem)
+		return nil
 	}
-	accountMap, err := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
-	if err != nil {
-		return err
+	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
+	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
+		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	for _, web := range webs {
 		retry := 0
@@ -95,7 +102,7 @@ func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Tim
 			record.DetailName = web.Alias
 			record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
 			backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/website/%s", web.Alias))
-			record.FileName = fmt.Sprintf("website_%s_%s.tar.gz", web.Alias, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
+			record.FileName = simplifiedFileName(fmt.Sprintf("website_%s_%s.tar.gz", web.Alias, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5)))
 
 			if err := doWebsiteBackup(&web, taskItem, backupDir, record.FileName, cronjob.ExclusionRules, cronjob.Secret); err != nil {
 				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
@@ -103,25 +110,29 @@ func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Tim
 					return err
 				} else {
 					task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+					cleanAccountMap(accountMap)
 					return nil
 				}
 			}
 
-			downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, record.FileName))
-			if err != nil {
+			src := path.Join(backupDir, record.FileName)
+			dst := strings.TrimPrefix(src, global.Dir.LocalBackupDir+"/tmp/")
+			if err := uploadWithMap(*task, accountMap, src, dst, cronjob.SourceAccountIDs, cronjob.DownloadAccountID, cronjob.RetryTimes); err != nil {
 				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
 					retry++
 					return err
 				}
 				task.Log(i18n.GetMsgWithDetail("IgnoreUploadErr", err.Error()))
+				cleanAccountMap(accountMap)
 				return nil
 			}
-			record.FileDir = path.Dir(downloadPath)
+			record.FileDir = path.Dir(dst)
 			if err := backupRepo.CreateRecord(&record); err != nil {
 				global.LOG.Errorf("save backup record failed, err: %v", err)
 				return err
 			}
 			u.removeExpiredBackup(cronjob, accountMap, record)
+			cleanAccountMap(accountMap)
 			return nil
 		}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
 	}
@@ -131,11 +142,12 @@ func (u *CronjobService) handleWebsite(cronjob model.Cronjob, startTime time.Tim
 func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
 	dbs := loadDbsForJob(cronjob)
 	if len(dbs) == 0 {
-		return errors.New("no such db in database!")
+		addSkipTask("Database", taskItem)
+		return nil
 	}
-	accountMap, err := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
-	if err != nil {
-		return err
+	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
+	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
+		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
 	for _, dbInfo := range dbs {
 		retry := 0
@@ -150,7 +162,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 			record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
 
 			backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/database/%s/%s/%s", dbInfo.DBType, record.Name, dbInfo.Name))
-			record.FileName = fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5))
+			record.FileName = simplifiedFileName(fmt.Sprintf("db_%s_%s.sql.gz", dbInfo.Name, startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5)))
 			if cronjob.DBType == "mysql" || cronjob.DBType == "mariadb" || cronjob.DBType == "mysql-cluster" {
 				if err := doMysqlBackup(dbInfo, backupDir, record.FileName); err != nil {
 					if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
@@ -158,6 +170,7 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 						return err
 					} else {
 						task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+						cleanAccountMap(accountMap)
 						return nil
 					}
 				}
@@ -168,26 +181,30 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 						return err
 					} else {
 						task.Log(i18n.GetMsgWithDetail("IgnoreBackupErr", err.Error()))
+						cleanAccountMap(accountMap)
 						return nil
 					}
 				}
 			}
 
-			downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, record.FileName))
-			if err != nil {
+			src := path.Join(backupDir, record.FileName)
+			dst := strings.TrimPrefix(src, global.Dir.LocalBackupDir+"/tmp/")
+			if err := uploadWithMap(*task, accountMap, src, dst, cronjob.SourceAccountIDs, cronjob.DownloadAccountID, cronjob.RetryTimes); err != nil {
 				if retry < int(cronjob.RetryTimes) || !cronjob.IgnoreErr {
 					retry++
 					return err
 				}
 				task.Log(i18n.GetMsgWithDetail("IgnoreUploadErr", err.Error()))
+				cleanAccountMap(accountMap)
 				return nil
 			}
-			record.FileDir = path.Dir(downloadPath)
+			record.FileDir = path.Dir(dst)
 			if err := backupRepo.CreateRecord(&record); err != nil {
 				global.LOG.Errorf("save backup record failed, err: %v", err)
 				return err
 			}
 			u.removeExpiredBackup(cronjob, accountMap, record)
+			cleanAccountMap(accountMap)
 			return nil
 		}, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
 	}
@@ -195,15 +212,16 @@ func (u *CronjobService) handleDatabase(cronjob model.Cronjob, startTime time.Ti
 }
 
 func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
+	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
+	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
+		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+	}
 	taskItem.AddSubTaskWithOps(task.GetTaskName(cronjob.SourceDir, task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
-		accountMap, err := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
-		if err != nil {
-			return err
-		}
 		fileName := fmt.Sprintf("%s.tar.gz", startTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(2))
 		if cronjob.IsDir || len(strings.Split(cronjob.SourceDir, ",")) == 1 {
 			fileName = loadFileName(cronjob.SourceDir)
 		}
+		fileName = simplifiedFileName(fileName)
 		backupDir := path.Join(global.Dir.LocalBackupDir, fmt.Sprintf("tmp/%s/%s", cronjob.Type, cronjob.Name))
 
 		fileOp := files.NewFileOp()
@@ -225,15 +243,15 @@ func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.T
 		record.CronjobID = cronjob.ID
 		record.Name = cronjob.Name
 		record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
-		downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(backupDir, fileName))
-		if err != nil {
-			taskItem.LogFailedWithErr("Upload backup file", err)
+
+		src := path.Join(backupDir, fileName)
+		dst := strings.TrimPrefix(src, global.Dir.LocalBackupDir+"/tmp/")
+		if err := uploadWithMap(*task, accountMap, src, dst, cronjob.SourceAccountIDs, cronjob.DownloadAccountID, cronjob.RetryTimes); err != nil {
 			return err
 		}
-		record.FileDir = path.Dir(downloadPath)
+		record.FileDir = path.Dir(dst)
 		record.FileName = fileName
 		if err := backupRepo.CreateRecord(&record); err != nil {
-			taskItem.LogFailedWithErr("Save record", err)
 			return err
 		}
 		u.removeExpiredBackup(cronjob, accountMap, record)
@@ -243,11 +261,11 @@ func (u *CronjobService) handleDirectory(cronjob model.Cronjob, startTime time.T
 }
 
 func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.Time, taskItem *task.Task) error {
-	taskItem.AddSubTaskWithOps(task.GetTaskName(i18n.GetMsgByKey("BackupSystemLog"), task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
-		accountMap, err := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
-		if err != nil {
-			return err
-		}
+	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
+	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
+		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+	}
+	taskItem.AddSubTaskWithOps(task.GetTaskName(i18n.GetMsgByKey("SystemLog"), task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
 		nameItem := startTime.Format(constant.DateTimeSlimLayout) + common.RandStrAndNum(5)
 		fileName := fmt.Sprintf("system_log_%s.tar.gz", nameItem)
 		backupDir := path.Join(global.Dir.LocalBackupDir, "tmp/log", nameItem)
@@ -260,15 +278,15 @@ func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.T
 		record.CronjobID = cronjob.ID
 		record.Name = cronjob.Name
 		record.DownloadAccountID, record.SourceAccountIDs = cronjob.DownloadAccountID, cronjob.SourceAccountIDs
-		downloadPath, err := u.uploadCronjobBackFile(cronjob, task, accountMap, path.Join(path.Dir(backupDir), fileName))
-		if err != nil {
-			taskItem.LogFailedWithErr("Upload backup file", err)
+
+		src := path.Join(path.Dir(backupDir), fileName)
+		dst := strings.TrimPrefix(src, global.Dir.LocalBackupDir+"/tmp/")
+		if err := uploadWithMap(*task, accountMap, src, dst, cronjob.SourceAccountIDs, cronjob.DownloadAccountID, cronjob.RetryTimes); err != nil {
 			return err
 		}
-		record.FileDir = path.Dir(downloadPath)
+		record.FileDir = path.Dir(dst)
 		record.FileName = fileName
 		if err := backupRepo.CreateRecord(&record); err != nil {
-			taskItem.LogFailedWithErr("Save record", err)
 			return err
 		}
 		u.removeExpiredBackup(cronjob, accountMap, record)
@@ -278,11 +296,10 @@ func (u *CronjobService) handleSystemLog(cronjob model.Cronjob, startTime time.T
 }
 
 func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, jobRecord model.JobRecords, taskItem *task.Task) error {
-	accountMap, err := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
-	if err != nil {
-		return err
+	accountMap := NewBackupClientMap(strings.Split(cronjob.SourceAccountIDs, ","))
+	if !accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
+		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", accountMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
 	}
-
 	var record model.BackupRecord
 	record.From = "cronjob"
 	record.Type = "snapshot"
@@ -302,9 +319,10 @@ func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, jobRecord model.J
 		return err
 	}
 	req := dto.SnapshotCreate{
-		Name:   fmt.Sprintf("snapshot-1panel-%s-%s-linux-%s-%s", scope, versionItem.Value, loadOs(), jobRecord.StartTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5)),
-		Secret: cronjob.Secret,
-		TaskID: jobRecord.TaskID,
+		Name:    fmt.Sprintf("snapshot-1panel-%s-%s-linux-%s-%s", scope, versionItem.Value, loadOs(), jobRecord.StartTime.Format(constant.DateTimeSlimLayout)+common.RandStrAndNum(5)),
+		Secret:  cronjob.Secret,
+		TaskID:  jobRecord.TaskID,
+		Timeout: cronjob.Timeout,
 
 		SourceAccountIDs:  record.SourceAccountIDs,
 		DownloadAccountID: cronjob.DownloadAccountID,
@@ -320,7 +338,7 @@ func (u *CronjobService) handleSnapshot(cronjob model.Cronjob, jobRecord model.J
 		IgnoreFiles:       strings.Split(cronjob.ExclusionRules, ","),
 	}
 
-	if err := NewISnapshotService().SnapshotCreate(taskItem, req, jobRecord.ID, cronjob.RetryTimes, cronjob.Timeout); err != nil {
+	if err := NewISnapshotService().SnapshotCreate(taskItem, req, jobRecord.ID, cronjob.RetryTimes); err != nil {
 		return err
 	}
 	record.FileName = req.Name + ".tar.gz"
@@ -357,6 +375,13 @@ type DatabaseHelper struct {
 	Name     string
 }
 
+func addSkipTask(source string, taskItem *task.Task) {
+	taskItem.AddSubTask(task.GetTaskName(i18n.GetMsgByKey(source), task.TaskBackup, task.TaskScopeCronjob), func(task *task.Task) error {
+		taskItem.Log(i18n.GetMsgByKey("NoSuchResource"))
+		return nil
+	}, nil)
+}
+
 func loadDbsForJob(cronjob model.Cronjob) []DatabaseHelper {
 	var dbs []DatabaseHelper
 	if cronjob.DBName == "all" {
@@ -460,6 +485,7 @@ func handleBackupLogs(taskItem *task.Task, targetDir, fileName string, secret st
 			}
 		}
 	}
+	taskItem.Logf("%s Website logs...", i18n.GetMsgByKey("TaskBackup"))
 
 	systemDir := path.Join(targetDir, "system")
 	if _, err := os.Stat(systemDir); err != nil && os.IsNotExist(err) {
@@ -468,7 +494,6 @@ func handleBackupLogs(taskItem *task.Task, targetDir, fileName string, secret st
 		}
 	}
 
-	taskItem.Logf("%s System logs...", i18n.GetMsgByKey("TaskBackup"))
 	systemLogFiles, _ := os.ReadDir(global.Dir.LogDir)
 	if len(systemLogFiles) != 0 {
 		for i := 0; i < len(systemLogFiles); i++ {
@@ -477,8 +502,8 @@ func handleBackupLogs(taskItem *task.Task, targetDir, fileName string, secret st
 			}
 		}
 	}
+	taskItem.Logf("%s System logs...", i18n.GetMsgByKey("TaskBackup"))
 
-	taskItem.Logf("%s SSH logs...", i18n.GetMsgByKey("TaskBackup"))
 	loginLogFiles, _ := os.ReadDir("/var/log")
 	loginDir := path.Join(targetDir, "login")
 	if _, err := os.Stat(loginDir); err != nil && os.IsNotExist(err) {
@@ -493,7 +518,7 @@ func handleBackupLogs(taskItem *task.Task, targetDir, fileName string, secret st
 			}
 		}
 	}
-	taskItem.Log("backup ssh log successful!")
+	taskItem.Logf("%s SSH logs...", i18n.GetMsgByKey("TaskBackup"))
 
 	if err := fileOp.TarGzCompressPro(true, targetDir, path.Join(path.Dir(targetDir), fileName), secret, ""); err != nil {
 		return err
@@ -563,3 +588,22 @@ func loadFileName(src string) string {
 	timestamp := time.Now().Format(constant.DateTimeSlimLayout)
 	return fmt.Sprintf("%s_%s_%s.tar.gz", cleanName, timestamp, common.RandStrAndNum(2))
 }
+
+func simplifiedFileName(name string) string {
+	name = strings.ReplaceAll(name, "/", "_")
+	name = strings.ReplaceAll(name, ":", "_")
+	name = strings.ReplaceAll(name, "*", "_")
+	name = strings.ReplaceAll(name, "?", "_")
+	name = strings.ReplaceAll(name, "\"", "_")
+	name = strings.ReplaceAll(name, "<", "_")
+	name = strings.ReplaceAll(name, ">", "_")
+	name = strings.ReplaceAll(name, "|", "_")
+	return name
+}
+
+func cleanAccountMap(accountMap map[string]backupClientHelper) {
+	for key, val := range accountMap {
+		val.hasBackup = false
+		accountMap[key] = val
+	}
+}

agent/app/service/cronjob_helper.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/1Panel-dev/1Panel/agent/utils/alert_push"
+	"github.com/pkg/errors"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
@@ -24,34 +25,51 @@ import (
 )
 
 func (u *CronjobService) HandleJob(cronjob *model.Cronjob) {
-	record := cronjobRepo.StartRecords(cronjob.ID, "", cronjob.Type)
-	go func() {
-		taskItem, err := task.NewTaskWithOps(fmt.Sprintf("cronjob-%s", cronjob.Name), task.TaskHandle, task.TaskScopeCronjob, record.TaskID, cronjob.ID)
-		if err != nil {
-			global.LOG.Errorf("new task for exec shell failed, err: %v", err)
-			return
-		}
-		err = u.loadTask(cronjob, &record, taskItem)
-		if cronjob.Type == "snapshot" {
-			if err != nil {
-				taskItem, _ := taskRepo.GetFirst(taskRepo.WithByID(record.TaskID))
-				if len(taskItem.ID) == 0 {
-					record.TaskID = ""
+	cronjobItem, _ := cronjobRepo.Get(repo.WithByID(cronjob.ID))
+	if cronjobItem.IsExecuting {
+		cronjobRepo.AddFailedRecord(cronjob.ID, i18n.GetMsgByKey("InExecuting"))
+		return
+	}
+	record := cronjobRepo.StartRecords(cronjob.ID)
+	taskItem, err := task.NewTaskWithOps(fmt.Sprintf("cronjob-%s", cronjob.Name), task.TaskHandle, task.TaskScopeCronjob, record.TaskID, cronjob.ID)
+	if err != nil {
+		global.LOG.Errorf("new task for exec shell failed, err: %v", err)
+		return
+	}
+	if cronjob.Type == "snapshot" {
+		go func() {
+			_ = cronjobRepo.UpdateRecords(record.ID, map[string]interface{}{"records": record.Records})
+			if err := taskRepo.Save(context.Background(), taskItem.Task); err != nil {
+				global.LOG.Errorf("save task for snapshot cronjob failed, err: %v", err)
+				return
+			}
+			if err = u.handleSnapshot(*cronjob, record, taskItem); err != nil {
+				if len(taskItem.Task.CurrentStep) == 0 {
+					taskItem.Log(err.Error())
+					taskItem.Task.Status = constant.StatusFailed
+					taskItem.Task.ErrorMsg = err.Error()
+					taskItem.Task.EndAt = time.Now()
+					_ = taskRepo.Save(context.Background(), taskItem.Task)
 				}
 				cronjobRepo.EndRecords(record, constant.StatusFailed, err.Error(), record.Records)
 				handleCronJobAlert(cronjob)
 				return
 			}
 			cronjobRepo.EndRecords(record, constant.StatusSuccess, "", record.Records)
-			return
-		}
-		if err != nil {
-			global.LOG.Debugf("preper to handle cron job [%s] %s failed, err: %v", cronjob.Type, cronjob.Name, err)
+		}()
+		return
+	}
+	if err = u.loadTask(cronjob, &record, taskItem); err != nil {
+		global.LOG.Debugf("preper to handle cron job [%s] %s failed, err: %v", cronjob.Type, cronjob.Name, err)
+		item, _ := taskRepo.GetFirst(taskRepo.WithByID(record.TaskID))
+		if len(item.ID) == 0 {
 			record.TaskID = ""
-			cronjobRepo.EndRecords(record, constant.StatusFailed, err.Error(), record.Records)
-			handleCronJobAlert(cronjob)
-			return
 		}
+		cronjobRepo.EndRecords(record, constant.StatusFailed, err.Error(), record.Records)
+		handleCronJobAlert(cronjob)
+		return
+	}
+	go func() {
 		if err := taskItem.Execute(); err != nil {
 			taskItem, _ := taskRepo.GetFirst(taskRepo.WithByID(record.TaskID))
 			if len(taskItem.ID) == 0 {
@@ -109,9 +127,6 @@ func (u *CronjobService) loadTask(cronjob *model.Cronjob, record *model.JobRecor
 		err = u.handleDirectory(*cronjob, record.StartTime, taskItem)
 	case "log":
 		err = u.handleSystemLog(*cronjob, record.StartTime, taskItem)
-	case "snapshot":
-		_ = cronjobRepo.UpdateRecords(record.ID, map[string]interface{}{"records": record.Records})
-		err = u.handleSnapshot(*cronjob, *record, taskItem)
 	}
 	return err
 }
@@ -191,14 +206,14 @@ func (u *CronjobService) handleNtpSync(cronjob model.Cronjob, taskItem *task.Tas
 }
 
 func (u *CronjobService) handleCutWebsiteLog(cronjob *model.Cronjob, startTime time.Time, taskItem *task.Task) error {
+	clientMap := NewBackupClientMap([]string{fmt.Sprintf("%v", cronjob.DownloadAccountID)})
+	if !clientMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].isOk {
+		return errors.New(i18n.GetMsgWithDetail("LoadBackupFailed", clientMap[fmt.Sprintf("%d", cronjob.DownloadAccountID)].message))
+	}
 	taskItem.AddSubTaskWithOps(i18n.GetWithName("CutWebsiteLog", cronjob.Name), func(t *task.Task) error {
 		websites := loadWebsForJob(*cronjob)
 		fileOp := files.NewFileOp()
 		baseDir := GetOpenrestyDir(SitesRootDir)
-		clientMap, err := NewBackupClientMap([]string{fmt.Sprintf("%v", cronjob.DownloadAccountID)})
-		if err != nil {
-			return fmt.Errorf("load local backup client failed, err: %v", err)
-		}
 		for _, website := range websites {
 			taskItem.Log(website.Alias)
 			var record model.BackupRecord
@@ -264,34 +279,6 @@ func (u *CronjobService) handleSystemClean(cronjob model.Cronjob, taskItem *task
 	taskItem.AddSubTaskWithOps(i18n.GetMsgByKey("HandleSystemClean"), cleanTask, nil, int(cronjob.RetryTimes), time.Duration(cronjob.Timeout)*time.Second)
 }
 
-func (u *CronjobService) uploadCronjobBackFile(cronjob model.Cronjob, task *task.Task, accountMap map[string]backupClientHelper, file string) (string, error) {
-	defer func() {
-		_ = os.Remove(file)
-	}()
-	var errItem error
-	accounts := strings.Split(cronjob.SourceAccountIDs, ",")
-	cloudSrc := strings.TrimPrefix(file, global.Dir.LocalBackupDir+"/tmp/")
-	for _, account := range accounts {
-		if len(account) != 0 {
-			task.LogStart(i18n.GetMsgWithMap("UploadFile", map[string]interface{}{
-				"file":   pathUtils.Join(accountMap[account].backupPath, cloudSrc),
-				"backup": accountMap[account].name,
-			}))
-			_, err := accountMap[account].client.Upload(file, pathUtils.Join(accountMap[account].backupPath, cloudSrc))
-			task.LogWithStatus(
-				i18n.GetMsgWithMap("UploadFile", map[string]interface{}{
-					"file":   pathUtils.Join(accountMap[account].backupPath, cloudSrc),
-					"backup": accountMap[account].name,
-				}), err)
-			if err != nil {
-				errItem = err
-				continue
-			}
-		}
-	}
-	return cloudSrc, errItem
-}
-
 func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap map[string]backupClientHelper, record model.BackupRecord) {
 	var opts []repo.DBOption
 	opts = append(opts, repo.WithByFrom("cronjob"))
@@ -314,6 +301,9 @@ func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap m
 					if _, ok := accountMap[account]; !ok {
 						continue
 					}
+					if !accountMap[account].isOk {
+						continue
+					}
 					_, _ = accountMap[account].client.Delete(pathUtils.Join(accountMap[account].backupPath, "system_snapshot", records[i].FileName))
 				}
 			}
@@ -324,6 +314,9 @@ func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap m
 					if _, ok := accountMap[account]; !ok {
 						continue
 					}
+					if !accountMap[account].isOk {
+						continue
+					}
 					_, _ = accountMap[account].client.Delete(pathUtils.Join(accountMap[account].backupPath, records[i].FileDir, records[i].FileName))
 				}
 			}