fix: fix issue with mcp bind website (#8356)

Refs #7869

.goreleaser.yaml

@@ -33,7 +33,7 @@ builds:
       - s390x
 
 archives:
-  - format: tar.gz
+  - formats: [ 'tar.gz' ]
     name_template: "1panel-v{{ .Version }}-{{ .Os }}-{{ .Arch }}{{- if .Arm }}v{{ .Arm }}{{ end }}"
     wrap_in_directory: true
     files:

CONTRIBUTING.md

@@ -10,7 +10,7 @@ PR are always welcome, even if they only contain small fixes like typos or a few
 
 Please submit a PR broken down into small changes bit by bit. A PR consisting of a lot of features and code changes may be hard to review. It is recommended to submit PRs in an incremental fashion.
 
-This [development guideline](https://docs.1panel.hk/dev_manual/dev_manual/) contains information about repository structure, how to set up development environment, how to run it, and more.
+This [development guideline](https://docs.1panel.pro/dev_manual/dev_manual/) contains information about repository structure, how to set up development environment, how to run it, and more.
 
 Note: If you split your pull request to small changes, please make sure any of the changes goes to master will not break anything. Otherwise, it can not be merged until this feature complete.
 

README.md

@@ -1,8 +1,7 @@
-<p align="center"><a href="https://1panel.hk"><img src="https://resource.1panel.hk/img/1panel-logo.png" alt="1Panel" width="300" /></a></p>
-<p align="center"><b>Top-Rated Web-based Linux Server Management Tool<br>Best VPS control panel</b></p>
+<p align="center"><a href="https://1panel.pro"><img src="https://resource.1panel.pro/img/1panel-logo.png" alt="1Panel" width="300" /></a></p>
+<p align="center"><b>Top-Rated Web-based Linux Server Management Tool</b><br>Best VPS control panel<br>新一代的 Linux 服务器运维管理面板</p>
 <p align="center">
-  <a href="https://trendshift.io/repositories/2462" target="_blank"><img src="https://trendshift.io/api/badge/repositories/2462" alt="1Panel-dev%2F1Panel | Trendshift" style="width: 180px; height: auto;" /></a>
-  <a href="https://www.producthunt.com/posts/1panel?embed=true&utm_source=badge-featured&utm_medium=badge&utm_souce=badge-1panel" target="_blank"><img src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=639696&theme=light" alt="1Panel - Top&#0045;Rated&#0032;web&#0045;based&#0032;Linux&#0032;server&#0032;management&#0032;tool | Product Hunt" style="width: 180px; height: auto;" /></a>
+  <a href="https://trendshift.io/repositories/2462" target="_blank"><img src="https://trendshift.io/api/badge/repositories/2462" alt="1Panel-dev%2F1Panel | Trendshift" style="width: 240px; height: auto;" /></a>
 </p>
 <p align="center">
   <a href="https://www.gnu.org/licenses/gpl-3.0.html"><img src="https://shields.io/github/license/1Panel-dev/1Panel?color=%231890FF" alt="License: GPL v3"></a>
@@ -34,7 +33,7 @@
 
 1Panel is an open-source, modern web-based control panel for Linux server management.
 
-- **Efficient Management**: Through a user-friendly web graphical interface, 1Panel enables users to effortlessly manage their Linux servers. Key features include host monitoring, file management, database administration, and container management.
+- **Efficient Management**: Through a user-friendly web graphical interface, 1Panel enables users to effortlessly manage their Linux servers. Key features include host monitoring, file management, database administration, container management, LLMs management.
 - **Rapid Website Deployment**: With deep integration of the popular open-source website building software WordPress, 1Panel streamlines the process of domain binding and SSL certificate configuration, all achievable with just one click.
 - **Application Store**: 1Panel curates a wide range of high-quality open-source tools and applications, facilitating easy installation and updates for its users.
 - **Security and Reliability**: By leveraging containerization and secure application deployment practices, 1Panel minimizes vulnerability exposure. It further enhances security through integrated firewall management and log auditing capabilities.
@@ -45,16 +44,16 @@
 Execute the script below and follow the prompts to install 1Panel:
 
 ```bash
-curl -sSL https://resource.1panel.hk/quick_start.sh -o quick_start.sh && bash quick_start.sh
+curl -sSL https://resource.1panel.pro/quick_start.sh -o quick_start.sh && bash quick_start.sh
 ```
 
-Please refer to our [documentation](https://docs.1panel.hk/quick_start/) for more details.
+Please refer to our [documentation](https://docs.1panel.pro/quick_start/) for more details.
 
 中国用户请使用这个 [安装脚本](https://1panel.cn/docs/installation/online_installation/)，其应用数量比国际版本更丰富。
 
 ## Screenshot
 
-![UI Display](https://resource.1panel.hk/img/1panel.png)
+![UI Display](https://resource.1panel.pro/img/1panel.png)
 
 ## Star History
 
@@ -62,7 +61,9 @@ Please refer to our [documentation](https://docs.1panel.hk/quick_start/) for mor
 
 ## Pro Edition
 
-Compared to the OSS Edition, 1Panel Pro Edition provides users with a wealth of enhanced features and technical support services. Enhanced features include WAF enhancement, website tamper protection, website monitoring, GPU monitoring, custom logo and theme color, etc. [Click to view the detailed introduction of the Pro Edition](https://1panel.hk/pricing).
+Compared to the OSS Edition, 1Panel Pro Edition provides users with a wealth of enhanced features and technical support services. Enhanced features include WAF enhancement, Website monitoring, Mobile APP, custom logo and theme, etc. 
+
+[Click to see Pro Edition details](https://1panel.pro/pricing).
 
 ## Security Information
 

backend/app/api/v1/ai.go

@@ -0,0 +1,257 @@
+package v1
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/gpu"
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/gpu/common"
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/xpu"
+	"github.com/gin-gonic/gin"
+)
+
+// @Tags AI
+// @Summary Create Ollama model
+// @Accept json
+// @Param request body dto.OllamaModelName true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/ollama/model [post]
+// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"添加 Ollama 模型 [name]","formatEN":"add Ollama model [name]"}
+func (b *BaseApi) CreateOllamaModel(c *gin.Context) {
+	var req dto.OllamaModelName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := AIToolService.Create(req.Name); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags AI
+// @Summary Rereate Ollama model
+// @Accept json
+// @Param request body dto.OllamaModelName true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/ollama/model/recreate [post]
+// @x-panel-log {"bodyKeys":["name"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"添加 Ollama 模型重试 [name]","formatEN":"re-add Ollama model [name]"}
+func (b *BaseApi) RecreateOllamaModel(c *gin.Context) {
+	var req dto.OllamaModelName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := AIToolService.Recreate(req.Name); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags AI
+// @Summary Close Ollama model conn
+// @Accept json
+// @Param request body dto.OllamaModelName true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/ollama/model/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
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := AIToolService.Close(req.Name); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, nil)
+}
+
+// @Tags AI
+// @Summary Sync Ollama model list
+// @Success 200 {array} dto.OllamaModelDropList
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/ollama/model/sync [post]
+// @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"同步 Ollama 模型列表","formatEN":"sync Ollama model list"}
+func (b *BaseApi) SyncOllamaModel(c *gin.Context) {
+	list, err := AIToolService.Sync()
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, list)
+}
+
+// @Tags AI
+// @Summary Page Ollama models
+// @Accept json
+// @Param request body dto.SearchWithPage true "request"
+// @Success 200 {object} dto.PageResult
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/ollama/model/search [post]
+func (b *BaseApi) SearchOllamaModel(c *gin.Context) {
+	var req dto.SearchWithPage
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	total, list, err := AIToolService.Search(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, dto.PageResult{
+		Items: list,
+		Total: total,
+	})
+}
+
+// @Tags AI
+// @Summary Page Ollama models
+// @Accept json
+// @Param request body dto.OllamaModelName true "request"
+// @Success 200 {string} details
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/ollama/model/load [post]
+func (b *BaseApi) LoadOllamaModelDetail(c *gin.Context) {
+	var req dto.OllamaModelName
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	detail, err := AIToolService.LoadDetail(req.Name)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithData(c, detail)
+}
+
+// @Tags AI
+// @Summary Delete Ollama model
+// @Accept json
+// @Param request body dto.ForceDelete true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/ollama/model/del [post]
+// @x-panel-log {"bodyKeys":["ids"],"paramKeys":[],"BeforeFunctions":[{"input_column":"id","input_value":"ids","isList":true,"db":"ollama_models","output_column":"name","output_value":"names"}],"formatZH":"删除 Ollama 模型 [names]","formatEN":"remove Ollama model [names]"}
+func (b *BaseApi) DeleteOllamaModel(c *gin.Context) {
+	var req dto.ForceDelete
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+
+	if err := AIToolService.Delete(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags AI
+// @Summary Load gpu / xpu info
+// @Accept json
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/gpu/load [get]
+func (b *BaseApi) LoadGpuInfo(c *gin.Context) {
+	ok, client := gpu.New()
+	if ok {
+		info, err := client.LoadGpuInfo()
+		if err != nil {
+			helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+			return
+		}
+		helper.SuccessWithData(c, info)
+		return
+	}
+	xpuOK, xpuClient := xpu.New()
+	if xpuOK {
+		info, err := xpuClient.LoadGpuInfo()
+		if err != nil {
+			helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+			return
+		}
+		helper.SuccessWithData(c, info)
+		return
+	}
+	helper.SuccessWithData(c, &common.GpuInfo{})
+}
+
+// @Tags AI
+// @Summary Bind domain
+// @Accept json
+// @Param request body dto.OllamaBindDomain true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/domain/bind [post]
+func (b *BaseApi) BindDomain(c *gin.Context) {
+	var req dto.OllamaBindDomain
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := AIToolService.BindDomain(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags AI
+// @Summary Get bind domain
+// @Accept json
+// @Param request body dto.OllamaBindDomainReq true "request"
+// @Success 200 {object} dto.OllamaBindDomainRes
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /ai/domain/get [post]
+func (b *BaseApi) GetBindDomain(c *gin.Context) {
+	var req dto.OllamaBindDomainReq
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	res, err := AIToolService.GetBindDomain(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, res)
+}
+
+// Tags AI
+// Summary Update bind domain
+// Accept json
+// Param request body dto.OllamaBindDomain true "request"
+// Success 200
+// Security ApiKeyAuth
+// Security Timestamp
+// Router /ai/domain/update [post]
+func (b *BaseApi) UpdateBindDomain(c *gin.Context) {
+	var req dto.OllamaBindDomain
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	if err := AIToolService.UpdateBindDomain(req); err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}

backend/app/api/v1/container.go

@@ -391,7 +391,7 @@ func (b *BaseApi) ContainerOperation(c *gin.Context) {
 
 // @Tags Container
 // @Summary Container stats
-// @Param id path integer true "container id"
+// @Param id path string true "container id"
 // @Success 200 {object} dto.ContainerStats
 // @Security ApiKeyAuth
 // @Security Timestamp

backend/app/api/v1/entry.go

@@ -15,6 +15,8 @@ var (
 	appService        = service.NewIAppService()
 	appInstallService = service.NewIAppInstalledService()
 
+	AIToolService = service.NewIAIToolService()
+
 	containerService       = service.NewIContainerService()
 	composeTemplateService = service.NewIComposeTemplateService()
 	imageRepoService       = service.NewIImageRepoService()
@@ -66,4 +68,6 @@ var (
 	favoriteService   = service.NewIFavoriteService()
 
 	websiteCAService = service.NewIWebsiteCAService()
+
+	mcpServerService = service.NewIMcpServerService()
 )

backend/app/api/v1/file.go

@@ -410,11 +410,37 @@ func (b *BaseApi) CheckFile(c *gin.Context) {
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
 		return
 	}
-	if _, err := os.Stat(req.Path); err != nil {
-		helper.SuccessWithData(c, false)
+	fileOp := files.NewFileOp()
+	if fileOp.Stat(req.Path) {
+		helper.SuccessWithData(c, true)
 		return
 	}
-	helper.SuccessWithData(c, true)
+	if req.WithInit {
+		if err := fileOp.CreateDir(req.Path, 0644); err != nil {
+			helper.SuccessWithData(c, false)
+			return
+		}
+		helper.SuccessWithData(c, true)
+		return
+	}
+	helper.SuccessWithData(c, false)
+}
+
+// @Tags File
+// @Summary Batch check file exist
+// @Accept json
+// @Param request body request.FilePathsCheck true "request"
+// @Success 200 {array} response.ExistFileInfo
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /files/batch/check [post]
+func (b *BaseApi) BatchCheckFiles(c *gin.Context) {
+	var req request.FilePathsCheck
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	fileList := fileService.BatchCheckFiles(req)
+	helper.SuccessWithData(c, fileList)
 }
 
 // @Tags File

backend/app/api/v1/host_tool.go

@@ -14,7 +14,7 @@ import (
 // @Success 200 {object} response.HostToolRes
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool [post]
+// @Router /hosts/tool [post]
 func (b *BaseApi) GetToolStatus(c *gin.Context) {
 	var req request.HostToolReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -36,7 +36,7 @@ func (b *BaseApi) GetToolStatus(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/create [post]
+// @Router /hosts/tool/create [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
@@ -58,7 +58,7 @@ func (b *BaseApi) InitToolConfig(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/operate [post]
+// @Router /hosts/tool/operate [post]
 // @x-panel-log {"bodyKeys":["operate","type"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] [type] ","formatEN":"[operate] [type]"}
 func (b *BaseApi) OperateTool(c *gin.Context) {
 	var req request.HostToolReq
@@ -80,7 +80,7 @@ func (b *BaseApi) OperateTool(c *gin.Context) {
 // @Success 200 {object} response.HostToolConfig
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/config [post]
+// @Router /hosts/tool/config [post]
 // @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] 主机工具配置文件 ","formatEN":"[operate] tool config"}
 func (b *BaseApi) OperateToolConfig(c *gin.Context) {
 	var req request.HostToolConfig
@@ -103,7 +103,7 @@ func (b *BaseApi) OperateToolConfig(c *gin.Context) {
 // @Success 200 {string} logContent
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/log [post]
+// @Router /hosts/tool/log [post]
 func (b *BaseApi) GetToolLog(c *gin.Context) {
 	var req request.HostToolLogReq
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -125,7 +125,7 @@ func (b *BaseApi) GetToolLog(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/supervisor/process [post]
+// @Router /hosts/tool/supervisor/process [post]
 // @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] 守护进程 ","formatEN":"[operate] process"}
 func (b *BaseApi) OperateProcess(c *gin.Context) {
 	var req request.SupervisorProcessConfig
@@ -147,7 +147,7 @@ func (b *BaseApi) OperateProcess(c *gin.Context) {
 // @Success 200 {object} response.SupervisorProcessConfig
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/supervisor/process [get]
+// @Router /hosts/tool/supervisor/process [get]
 func (b *BaseApi) GetProcess(c *gin.Context) {
 	configs, err := hostToolService.GetSupervisorProcessConfig()
 	if err != nil {
@@ -164,7 +164,7 @@ func (b *BaseApi) GetProcess(c *gin.Context) {
 // @Success 200 {string} content
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/tool/supervisor/process/file [post]
+// @Router /hosts/tool/supervisor/process/file [post]
 // @x-panel-log {"bodyKeys":["operate"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operate] Supervisor 进程文件 ","formatEN":"[operate] Supervisor Process Config file"}
 func (b *BaseApi) GetProcessFile(c *gin.Context) {
 	var req request.SupervisorProcessFileReq

backend/app/api/v1/mcp_server.go

@@ -0,0 +1,167 @@
+package v1
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/api/v1/helper"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/gin-gonic/gin"
+)
+
+// @Tags McpServer
+// @Summary List mcp servers
+// @Accept json
+// @Param request body request.McpServerSearch true "request"
+// @Success 200 {object} response.McpServersRes
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/search [post]
+func (b *BaseApi) PageMcpServers(c *gin.Context) {
+	var req request.McpServerSearch
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	list := mcpServerService.Page(req)
+	helper.SuccessWithData(c, list)
+}
+
+// @Tags McpServer
+// @Summary Create mcp server
+// @Accept json
+// @Param request body request.McpServerCreate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/server [post]
+func (b *BaseApi) CreateMcpServer(c *gin.Context) {
+	var req request.McpServerCreate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := mcpServerService.Create(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags McpServer
+// @Summary Update mcp server
+// @Accept json
+// @Param request body request.McpServerUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/server/update [post]
+func (b *BaseApi) UpdateMcpServer(c *gin.Context) {
+	var req request.McpServerUpdate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := mcpServerService.Update(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags McpServer
+// @Summary Delete mcp server
+// @Accept json
+// @Param request body request.McpServerDelete true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/server/del [post]
+func (b *BaseApi) DeleteMcpServer(c *gin.Context) {
+	var req request.McpServerDelete
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := mcpServerService.Delete(req.ID)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags McpServer
+// @Summary Operate mcp server
+// @Accept json
+// @Param request body request.McpServerOperate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/server/op [post]
+func (b *BaseApi) OperateMcpServer(c *gin.Context) {
+	var req request.McpServerOperate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := mcpServerService.Operate(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags McpServer
+// @Summary Bind Domain for mcp server
+// @Accept json
+// @Param request body request.McpBindDomain true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/domain/bind [post]
+func (b *BaseApi) BindMcpDomain(c *gin.Context) {
+	var req request.McpBindDomain
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := mcpServerService.BindDomain(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags McpServer
+// @Summary Update bind Domain for mcp server
+// @Accept json
+// @Param request body request.McpBindDomainUpdate true "request"
+// @Success 200
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/domain/update [post]
+func (b *BaseApi) UpdateMcpBindDomain(c *gin.Context) {
+	var req request.McpBindDomainUpdate
+	if err := helper.CheckBindAndValidate(&req, c); err != nil {
+		return
+	}
+	err := mcpServerService.UpdateBindDomain(req)
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithOutData(c)
+}
+
+// @Tags McpServer
+// @Summary Get bin Domain for mcp server
+// @Accept json
+// @Success 200 {object} response.McpBindDomainRes
+// @Security ApiKeyAuth
+// @Security Timestamp
+// @Router /mcp/domain/get [get]
+func (b *BaseApi) GetMcpBindDomain(c *gin.Context) {
+	res, err := mcpServerService.GetBindDomain()
+	if err != nil {
+		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
+		return
+	}
+	helper.SuccessWithData(c, res)
+}

backend/app/api/v1/setting.go

@@ -56,8 +56,8 @@ func (b *BaseApi) UpdateSetting(c *gin.Context) {
 		return
 	}
 	if req.Key == "SecurityEntrance" {
-		if checkEntrancePattern(req.Value) {
-			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, fmt.Errorf("regexp match string with %s failed", req.Value))
+		if !checkEntrancePattern(req.Value) {
+			helper.ErrorWithDetail(c, constant.CodeErrBadRequest, constant.ErrTypeInvalidParams, fmt.Errorf("the format of the security entrance %s is incorrect.", req.Value))
 			return
 		}
 	}
@@ -66,6 +66,10 @@ func (b *BaseApi) UpdateSetting(c *gin.Context) {
 		helper.ErrorWithDetail(c, constant.CodeErrInternalServer, constant.ErrTypeInternalServer, err)
 		return
 	}
+	if req.Key == "SecurityEntrance" {
+		entranceValue := base64.StdEncoding.EncodeToString([]byte(req.Value))
+		c.SetCookie("SecurityEntrance", entranceValue, 0, "", "", false, true)
+	}
 	helper.SuccessWithData(c, nil)
 }
 

backend/app/api/v1/ssh.go

@@ -12,7 +12,7 @@ import (
 // @Success 200 {object} dto.SSHInfo
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/search [post]
+// @Router /hosts/ssh/search [post]
 func (b *BaseApi) GetSSHInfo(c *gin.Context) {
 	info, err := sshService.GetSSHInfo()
 	if err != nil {
@@ -29,7 +29,7 @@ func (b *BaseApi) GetSSHInfo(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/operate [post]
+// @Router /hosts/ssh/operate [post]
 // @x-panel-log {"bodyKeys":["operation"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"[operation] SSH ","formatEN":"[operation] SSH"}
 func (b *BaseApi) OperateSSH(c *gin.Context) {
 	var req dto.Operate
@@ -51,7 +51,7 @@ func (b *BaseApi) OperateSSH(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/update [post]
+// @Router /hosts/ssh/update [post]
 // @x-panel-log {"bodyKeys":["key","value"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"修改 SSH 配置 [key] => [value]","formatEN":"update SSH setting [key] => [value]"}
 func (b *BaseApi) UpdateSSH(c *gin.Context) {
 	var req dto.SSHUpdate
@@ -73,7 +73,7 @@ func (b *BaseApi) UpdateSSH(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/conffile/update [post]
+// @Router /hosts/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
@@ -95,7 +95,7 @@ func (b *BaseApi) UpdateSSHByfile(c *gin.Context) {
 // @Success 200
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/generate [post]
+// @Router /hosts/ssh/generate [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"生成 SSH 密钥 ","formatEN":"generate SSH secret"}
 func (b *BaseApi) GenerateSSH(c *gin.Context) {
 	var req dto.GenerateSSH
@@ -117,7 +117,7 @@ func (b *BaseApi) GenerateSSH(c *gin.Context) {
 // @Success 200 {string} data
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/secret [post]
+// @Router /hosts/ssh/secret [post]
 func (b *BaseApi) LoadSSHSecret(c *gin.Context) {
 	var req dto.GenerateLoad
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -139,7 +139,7 @@ func (b *BaseApi) LoadSSHSecret(c *gin.Context) {
 // @Success 200 {object} dto.SSHLog
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/log [post]
+// @Router /hosts/ssh/log [post]
 func (b *BaseApi) LoadSSHLogs(c *gin.Context) {
 	var req dto.SearchSSHLog
 	if err := helper.CheckBindAndValidate(&req, c); err != nil {
@@ -159,7 +159,7 @@ func (b *BaseApi) LoadSSHLogs(c *gin.Context) {
 // @Success 200 {string} data
 // @Security ApiKeyAuth
 // @Security Timestamp
-// @Router /host/ssh/conf [get]
+// @Router /hosts/ssh/conf [get]
 func (b *BaseApi) LoadSSHConf(c *gin.Context) {
 	data, err := sshService.LoadSSHConf()
 	if err != nil {

backend/app/api/v1/terminal.go

@@ -68,12 +68,11 @@ func (b *BaseApi) WsSsh(c *gin.Context) {
 
 	<-quitChan
 
-	if wshandleError(wsConn, err) {
-		return
-	}
+	dt := time.Now().Add(time.Second)
+	_ = wsConn.WriteControl(websocket.CloseMessage, nil, dt)
 }
 
-func (b *BaseApi) RedisWsSsh(c *gin.Context) {
+func (b *BaseApi) ContainerWsSSH(c *gin.Context) {
 	wsConn, err := upGrader.Upgrade(c.Writer, c.Request, nil)
 	if err != nil {
 		global.LOG.Errorf("gin context http handler failed, err: %v", err)
@@ -95,38 +94,30 @@ func (b *BaseApi) RedisWsSsh(c *gin.Context) {
 	if wshandleError(wsConn, errors.WithMessage(err, "invalid param rows in request")) {
 		return
 	}
-	name := c.Query("name")
-	from := c.Query("from")
-	commands := []string{"redis-cli"}
-	database, err := databaseService.Get(name)
-	if wshandleError(wsConn, errors.WithMessage(err, "no such database in db")) {
-		return
-	}
-	if from == "local" {
-		redisInfo, err := appInstallService.LoadConnInfo(dto.OperationWithNameAndType{Name: name, Type: "redis"})
-		if wshandleError(wsConn, errors.WithMessage(err, "no such database in db")) {
+	source := c.Query("source")
+	var containerID string
+	var initCmd []string
+	switch source {
+	case "redis":
+		containerID, initCmd, err = loadRedisInitCmd(c)
+	case "ollama":
+		containerID, initCmd, err = loadOllamaInitCmd(c)
+	case "container":
+		containerID, initCmd, err = loadContainerInitCmd(c)
+	default:
+		if wshandleError(wsConn, fmt.Errorf("not support such source %s", source)) {
 			return
 		}
-		name = redisInfo.ContainerName
-		if len(database.Password) != 0 {
-			commands = []string{"redis-cli", "-a", database.Password, "--no-auth-warning"}
-		}
-	} else {
-		itemPort := fmt.Sprintf("%v", database.Port)
-		commands = []string{"redis-cli", "-h", database.Address, "-p", itemPort}
-		if len(database.Password) != 0 {
-			commands = []string{"redis-cli", "-h", database.Address, "-p", itemPort, "-a", database.Password, "--no-auth-warning"}
-		}
-		name = "1Panel-redis-cli-tools"
 	}
-
-	pidMap := loadMapFromDockerTop(name)
-	itemCmds := append([]string{"exec", "-it", name}, commands...)
-	slave, err := terminal.NewCommand(itemCmds)
 	if wshandleError(wsConn, err) {
 		return
 	}
-	defer killBash(name, strings.Join(commands, " "), pidMap)
+	pidMap := loadMapFromDockerTop(containerID)
+	slave, err := terminal.NewCommand(initCmd)
+	if wshandleError(wsConn, err) {
+		return
+	}
+	defer killBash(containerID, strings.ReplaceAll(strings.Join(initCmd, " "), fmt.Sprintf("exec -it %s ", containerID), ""), pidMap)
 	defer slave.Close()
 
 	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave, false)
@@ -141,83 +132,68 @@ func (b *BaseApi) RedisWsSsh(c *gin.Context) {
 	<-quitChan
 
 	global.LOG.Info("websocket finished")
-	if wshandleError(wsConn, err) {
-		return
-	}
+	dt := time.Now().Add(time.Second)
+	_ = wsConn.WriteControl(websocket.CloseMessage, nil, dt)
+
 }
 
-func (b *BaseApi) ContainerWsSsh(c *gin.Context) {
-	wsConn, err := upGrader.Upgrade(c.Writer, c.Request, nil)
+func loadRedisInitCmd(c *gin.Context) (string, []string, error) {
+	name := c.Query("name")
+	from := c.Query("from")
+	commands := []string{"exec", "-it"}
+	database, err := databaseService.Get(name)
 	if err != nil {
-		global.LOG.Errorf("gin context http handler failed, err: %v", err)
-		return
+		return "", nil, fmt.Errorf("no such database in db, err: %v", err)
 	}
-	defer wsConn.Close()
-
-	if global.CONF.System.IsDemo {
-		if wshandleError(wsConn, errors.New("   demo server, prohibit this operation!")) {
-			return
+	if from == "local" {
+		redisInfo, err := appInstallService.LoadConnInfo(dto.OperationWithNameAndType{Name: name, Type: "redis"})
+		if err != nil {
+			return "", nil, fmt.Errorf("no such app in db, err: %v", err)
+		}
+		name = redisInfo.ContainerName
+		commands = append(commands, []string{name, "redis-cli"}...)
+		if len(database.Password) != 0 {
+			commands = append(commands, []string{"-a", database.Password, "--no-auth-warning"}...)
+		}
+	} else {
+		name = "1Panel-redis-cli-tools"
+		commands = append(commands, []string{name, "redis-cli", "-h", database.Address, "-p", fmt.Sprintf("%v", database.Port)}...)
+		if len(database.Password) != 0 {
+			commands = append(commands, []string{"-a", database.Password, "--no-auth-warning"}...)
 		}
 	}
+	return name, commands, nil
+}
 
+func loadOllamaInitCmd(c *gin.Context) (string, []string, error) {
+	name := c.Query("name")
+	if cmd.CheckIllegal(name) {
+		return "", nil, fmt.Errorf("ollama model %s contains illegal characters", name)
+	}
+	ollamaInfo, err := appInstallService.LoadConnInfo(dto.OperationWithNameAndType{Name: "", Type: "ollama"})
+	if err != nil {
+		return "", nil, fmt.Errorf("no such app in db, err: %v", err)
+	}
+	containerName := ollamaInfo.ContainerName
+	return containerName, []string{"exec", "-it", containerName, "ollama", "run", name}, nil
+}
+
+func loadContainerInitCmd(c *gin.Context) (string, []string, error) {
 	containerID := c.Query("containerid")
 	command := c.Query("command")
 	user := c.Query("user")
-	if len(command) == 0 || len(containerID) == 0 {
-		if wshandleError(wsConn, errors.New("error param of command or containerID")) {
-			return
-		}
-	}
-	cols, err := strconv.Atoi(c.DefaultQuery("cols", "80"))
-	if wshandleError(wsConn, errors.WithMessage(err, "invalid param cols in request")) {
-		return
-	}
-	rows, err := strconv.Atoi(c.DefaultQuery("rows", "40"))
-	if wshandleError(wsConn, errors.WithMessage(err, "invalid param rows in request")) {
-		return
-	}
-
-	cmds := []string{"exec", containerID, command}
-	if len(user) != 0 {
-		cmds = []string{"exec", "-u", user, containerID, command}
-	}
 	if cmd.CheckIllegal(user, containerID, command) {
-		if wshandleError(wsConn, errors.New("  The command contains illegal characters.")) {
-			return
-		}
+		return "", nil, fmt.Errorf("the command contains illegal characters. command: %s, user: %s, containerID: %s", command, user, containerID)
 	}
-	stdout, err := cmd.ExecWithCheck("docker", cmds...)
-	if wshandleError(wsConn, errors.WithMessage(err, stdout)) {
-		return
+	if len(command) == 0 || len(containerID) == 0 {
+		return "", nil, fmt.Errorf("error param of command: %s or containerID: %s", command, containerID)
 	}
-
 	commands := []string{"exec", "-it", containerID, command}
 	if len(user) != 0 {
 		commands = []string{"exec", "-it", "-u", user, containerID, command}
 	}
-	pidMap := loadMapFromDockerTop(containerID)
-	slave, err := terminal.NewCommand(commands)
-	if wshandleError(wsConn, err) {
-		return
-	}
-	defer killBash(containerID, command, pidMap)
-	defer slave.Close()
 
-	tty, err := terminal.NewLocalWsSession(cols, rows, wsConn, slave, true)
-	if wshandleError(wsConn, err) {
-		return
-	}
-
-	quitChan := make(chan bool, 3)
-	tty.Start(quitChan)
-	go slave.Wait(quitChan)
-
-	<-quitChan
-
-	global.LOG.Info("websocket finished")
-	if wshandleError(wsConn, err) {
-		return
-	}
+	return containerID, commands, nil
 }
 
 func wshandleError(ws *websocket.Conn, err error) bool {

backend/app/dto/ai.go

@@ -0,0 +1,45 @@
+package dto
+
+import "time"
+
+type OllamaModelInfo struct {
+	ID           uint   `json:"id"`
+	Name         string `json:"name"`
+	Size         string `json:"size"`
+	From         string `json:"from"`
+	LogFileExist bool   `json:"logFileExist"`
+
+	Status    string    `json:"status"`
+	Message   string    `json:"message"`
+	CreatedAt time.Time `json:"createdAt"`
+}
+
+type OllamaModelDropList struct {
+	ID   uint   `json:"id"`
+	Name string `json:"name"`
+}
+
+type OllamaModelName struct {
+	Name string `json:"name"`
+}
+
+type OllamaBindDomain struct {
+	Domain       string `json:"domain" validate:"required"`
+	AppInstallID uint   `json:"appInstallID" validate:"required"`
+	SSLID        uint   `json:"sslID"`
+	WebsiteID    uint   `json:"websiteID"`
+	IPList       string `json:"ipList"`
+}
+
+type OllamaBindDomainReq struct {
+	AppInstallID uint `json:"appInstallID" validate:"required"`
+}
+
+type OllamaBindDomainRes struct {
+	Domain        string   `json:"domain"`
+	SSLID         uint     `json:"sslID"`
+	AcmeAccountID uint     `json:"acmeAccountID"`
+	AllowIPs      []string `json:"allowIPs"`
+	WebsiteID     uint     `json:"websiteID"`
+	ConnUrl       string   `json:"connUrl"`
+}

backend/app/dto/app.go

@@ -78,8 +78,8 @@ type AppProperty struct {
 	Name               string   `json:"name"`
 	Type               string   `json:"type"`
 	Tags               []string `json:"tags"`
-	ShortDescZh        string   `json:"shortDescZh"`
-	ShortDescEn        string   `json:"shortDescEn"`
+	ShortDescZh        string   `json:"shortDescZh" yaml:"shortDescZh"`
+	ShortDescEn        string   `json:"shortDescEn" yaml:"shortDescEn"`
 	Description        Locale   `json:"description"`
 	Key                string   `json:"key"`
 	Required           []string `json:"Required"`
@@ -90,6 +90,7 @@ type AppProperty struct {
 	Github             string   `json:"github"`
 	Document           string   `json:"document"`
 	Version            float64  `json:"version"`
+	GpuSupport         bool     `json:"gpuSupport"`
 }
 
 type AppConfigVersion struct {

backend/app/dto/common_req.go

@@ -52,3 +52,8 @@ type OperationWithNameAndType struct {
 	Name string `json:"name"`
 	Type string `json:"type" validate:"required"`
 }
+
+type ForceDelete struct {
+	IDs         []uint `json:"ids"`
+	ForceDelete bool   `json:"forceDelete"`
+}

backend/app/dto/cronjob.go

@@ -71,14 +71,16 @@ type CronjobDownload struct {
 }
 
 type CronjobClean struct {
-	IsDelete  bool `json:"isDelete"`
-	CleanData bool `json:"cleanData"`
-	CronjobID uint `json:"cronjobID" validate:"required"`
+	IsDelete        bool `json:"isDelete"`
+	CleanData       bool `json:"cleanData"`
+	CleanRemoteData bool `json:"cleanRemoteData"`
+	CronjobID       uint `json:"cronjobID" validate:"required"`
 }
 
 type CronjobBatchDelete struct {
-	CleanData bool   `json:"cleanData"`
-	IDs       []uint `json:"ids" validate:"required"`
+	CleanData       bool   `json:"cleanData"`
+	CleanRemoteData bool   `json:"cleanRemoteData"`
+	IDs             []uint `json:"ids" validate:"required"`
 }
 
 type CronjobInfo struct {

backend/app/dto/firewall.go

@@ -30,7 +30,8 @@ type PortRuleOperate struct {
 }
 
 type ForwardRuleOperate struct {
-	Rules []struct {
+	ForceDelete bool `json:"forceDelete"`
+	Rules       []struct {
 		Operation  string `json:"operation" validate:"required,oneof=add remove"`
 		Num        string `json:"num"`
 		Protocol   string `json:"protocol" validate:"required,oneof=tcp udp tcp/udp"`

backend/app/dto/mcp.go

@@ -0,0 +1,10 @@
+package dto
+
+type DockerComposeService struct {
+	Image         string   `yaml:"image"`
+	ContainerName string   `yaml:"container_name"`
+	Restart       string   `yaml:"restart"`
+	Ports         []string `yaml:"ports"`
+	Environment   []string `yaml:"environment"`
+	Command       []string `yaml:"command"`
+}

backend/app/dto/request/app.go

@@ -33,6 +33,7 @@ type AppContainerConfig struct {
 	DockerCompose string  `json:"dockerCompose"`
 	HostMode      bool    `json:"hostMode"`
 	PullImage     bool    `json:"pullImage"`
+	GpuConfig     bool    `json:"gpuConfig"`
 }
 
 type AppInstalledSearch struct {

backend/app/dto/request/file.go

@@ -76,7 +76,12 @@ type FileRename struct {
 }
 
 type FilePathCheck struct {
-	Path string `json:"path" validate:"required"`
+	Path     string `json:"path" validate:"required"`
+	WithInit bool   `json:"withInit"`
+}
+
+type FilePathsCheck struct {
+	Paths []string `json:"paths" validate:"required"`
 }
 
 type FileWget struct {

backend/app/dto/request/mcp_server.go

@@ -0,0 +1,57 @@
+package request
+
+import "github.com/1Panel-dev/1Panel/backend/app/dto"
+
+type McpServerSearch struct {
+	dto.PageInfo
+	Name string `json:"name"`
+	Sync bool   `json:"sync"`
+}
+
+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"`
+}
+
+type McpServerUpdate struct {
+	ID uint `json:"id" validate:"required"`
+	McpServerCreate
+}
+
+type Environment struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+type Volume struct {
+	Source string `json:"source"`
+	Target string `json:"target"`
+}
+
+type McpServerDelete struct {
+	ID uint `json:"id" validate:"required"`
+}
+
+type McpServerOperate struct {
+	ID      uint   `json:"id" validate:"required"`
+	Operate string `json:"operate" validate:"required"`
+}
+
+type McpBindDomain struct {
+	Domain string `json:"domain" validate:"required"`
+	SSLID  uint   `json:"sslID"`
+	IPList string `json:"ipList"`
+}
+
+type McpBindDomainUpdate struct {
+	WebsiteID uint   `json:"websiteID" validate:"required"`
+	SSLID     uint   `json:"sslID"`
+	IPList    string `json:"ipList"`
+}

backend/app/dto/response/app.go

@@ -41,6 +41,7 @@ type AppItem struct {
 	Versions    []string `json:"versions"`
 	Limit       int      `json:"limit"`
 	Tags        []TagDTO `json:"tags"`
+	GpuSupport  bool     `json:"gpuSupport"`
 }
 
 type TagDTO struct {
@@ -66,10 +67,11 @@ type AppInstalledCheck struct {
 
 type AppDetailDTO struct {
 	model.AppDetail
-	Enable   bool        `json:"enable"`
-	Params   interface{} `json:"params"`
-	Image    string      `json:"image"`
-	HostMode bool        `json:"hostMode"`
+	Enable     bool        `json:"enable"`
+	Params     interface{} `json:"params"`
+	Image      string      `json:"image"`
+	HostMode   bool        `json:"hostMode"`
+	GpuSupport bool        `json:"gpuSupport"`
 }
 
 type IgnoredApp struct {
@@ -90,9 +92,10 @@ type AppInstalledDTO struct {
 }
 
 type AppDetail struct {
-	Website  string `json:"website"`
-	Document string `json:"document"`
-	Github   string `json:"github"`
+	Website    string `json:"website"`
+	Document   string `json:"document"`
+	Github     string `json:"github"`
+	GpuSupport bool   `json:"gpuSupport"`
 }
 
 type AppInstallDTO struct {

backend/app/dto/response/file.go

@@ -2,6 +2,7 @@ package response
 
 import (
 	"github.com/1Panel-dev/1Panel/backend/utils/files"
+	"time"
 )
 
 type FileInfo struct {
@@ -46,3 +47,10 @@ type FileLineContent struct {
 type FileExist struct {
 	Exist bool `json:"exist"`
 }
+
+type ExistFileInfo struct {
+	Name    string    `json:"name"`
+	Path    string    `json:"path"`
+	Size    float64   `json:"size"`
+	ModTime time.Time `json:"modTime"`
+}

backend/app/dto/response/mcp_server.go

@@ -0,0 +1,26 @@
+package response
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+)
+
+type McpServersRes struct {
+	Items []McpServerDTO `json:"items"`
+	Total int64          `json:"total"`
+}
+
+type McpServerDTO struct {
+	model.McpServer
+	Environments []request.Environment `json:"environments"`
+	Volumes      []request.Volume      `json:"volumes"`
+}
+
+type McpBindDomainRes struct {
+	Domain        string   `json:"domain"`
+	SSLID         uint     `json:"sslID"`
+	AcmeAccountID uint     `json:"acmeAccountID"`
+	AllowIPs      []string `json:"allowIPs"`
+	WebsiteID     uint     `json:"websiteID"`
+	ConnUrl       string   `json:"connUrl"`
+}

backend/app/dto/setting.go

@@ -71,6 +71,7 @@ type SettingInfo struct {
 	ApiKey             string `json:"apiKey"`
 	IpWhiteList        string `json:"ipWhiteList"`
 	ApiKeyValidityTime string `json:"apiKeyValidityTime"`
+	LicenseVerify      string `json:"licenseVerify"`
 }
 
 type SettingUpdate struct {

backend/app/model/ai.go

@@ -0,0 +1,11 @@
+package model
+
+type OllamaModel struct {
+	BaseModel
+
+	Name    string `json:"name"`
+	Size    string `json:"size"`
+	From    string `json:"from"`
+	Status  string `json:"status"`
+	Message string `json:"message"`
+}

backend/app/model/app.go

@@ -20,6 +20,7 @@ type App struct {
 	Type               string `json:"type" gorm:"type:varchar(64);not null"`
 	Status             string `json:"status" gorm:"type:varchar(64);not null"`
 	Required           string `json:"required" gorm:"type:varchar(64);"`
+	GpuSupport         bool   `json:"gpuSupport"`
 	CrossVersionUpdate bool   `json:"crossVersionUpdate" yaml:"crossVersionUpdate"`
 	Limit              int    `json:"limit" gorm:"type:Integer;not null"`
 	Website            string `json:"website" gorm:"type:varchar(64);not null"`

backend/app/model/mcp_server.go

@@ -0,0 +1,18 @@
+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"`
+}

backend/app/repo/ai.go

@@ -0,0 +1,69 @@
+package repo
+
+import (
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/global"
+)
+
+type AiRepo struct{}
+
+type IAiRepo interface {
+	Get(opts ...DBOption) (model.OllamaModel, error)
+	List(opts ...DBOption) ([]model.OllamaModel, error)
+	Page(limit, offset int, opts ...DBOption) (int64, []model.OllamaModel, error)
+	Create(cronjob *model.OllamaModel) error
+	Update(id uint, vars map[string]interface{}) error
+	Delete(opts ...DBOption) error
+}
+
+func NewIAiRepo() IAiRepo {
+	return &AiRepo{}
+}
+
+func (u *AiRepo) Get(opts ...DBOption) (model.OllamaModel, error) {
+	var item model.OllamaModel
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.First(&item).Error
+	return item, err
+}
+
+func (u *AiRepo) List(opts ...DBOption) ([]model.OllamaModel, error) {
+	var list []model.OllamaModel
+	db := global.DB.Model(&model.OllamaModel{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	err := db.Find(&list).Error
+	return list, err
+}
+
+func (u *AiRepo) Page(page, size int, opts ...DBOption) (int64, []model.OllamaModel, error) {
+	var list []model.OllamaModel
+	db := global.DB.Model(&model.OllamaModel{})
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	count := int64(0)
+	db = db.Count(&count)
+	err := db.Limit(size).Offset(size * (page - 1)).Find(&list).Error
+	return count, list, err
+}
+
+func (u *AiRepo) Create(item *model.OllamaModel) error {
+	return global.DB.Create(item).Error
+}
+
+func (u *AiRepo) Update(id uint, vars map[string]interface{}) error {
+	return global.DB.Model(&model.OllamaModel{}).Where("id = ?", id).Updates(vars).Error
+}
+
+func (u *AiRepo) Delete(opts ...DBOption) error {
+	db := global.DB
+	for _, opt := range opts {
+		db = opt(db)
+	}
+	return db.Delete(&model.OllamaModel{}).Error
+}

backend/app/repo/group.go

@@ -16,6 +16,7 @@ type IGroupRepo interface {
 	Delete(opts ...DBOption) error
 	CancelDefault(groupType string) error
 	WithByHostDefault() DBOption
+	WithByWebsiteDefault() DBOption
 }
 
 func NewIGroupRepo() IGroupRepo {
@@ -56,6 +57,12 @@ func (u *GroupRepo) WithByHostDefault() DBOption {
 	}
 }
 
+func (u *GroupRepo) WithByWebsiteDefault() DBOption {
+	return func(g *gorm.DB) *gorm.DB {
+		return g.Where("is_default = ? AND type = ?", 1, "website")
+	}
+}
+
 func (u *GroupRepo) Delete(opts ...DBOption) error {
 	db := global.DB
 	for _, opt := range opts {

backend/app/repo/mcp_server.go

@@ -0,0 +1,56 @@
+package repo
+
+import "github.com/1Panel-dev/1Panel/backend/app/model"
+
+type McpServerRepo struct {
+}
+
+type IMcpServerRepo interface {
+	Page(page, size int, opts ...DBOption) (int64, []model.McpServer, error)
+	GetFirst(opts ...DBOption) (*model.McpServer, error)
+	Create(mcpServer *model.McpServer) error
+	Save(mcpServer *model.McpServer) error
+	DeleteBy(opts ...DBOption) error
+	List(opts ...DBOption) ([]model.McpServer, error)
+}
+
+func NewIMcpServerRepo() IMcpServerRepo {
+	return &McpServerRepo{}
+}
+
+func (m McpServerRepo) Page(page, size int, opts ...DBOption) (int64, []model.McpServer, error) {
+	var servers []model.McpServer
+	db := getDb(opts...).Model(&model.McpServer{})
+	count := int64(0)
+	db = db.Count(&count)
+	err := db.Limit(size).Offset(size * (page - 1)).Find(&servers).Error
+	return count, servers, err
+}
+
+func (m McpServerRepo) GetFirst(opts ...DBOption) (*model.McpServer, error) {
+	var mcpServer model.McpServer
+	if err := getDb(opts...).First(&mcpServer).Error; err != nil {
+		return nil, err
+	}
+	return &mcpServer, nil
+}
+
+func (m McpServerRepo) List(opts ...DBOption) ([]model.McpServer, error) {
+	var mcpServers []model.McpServer
+	if err := getDb(opts...).Find(&mcpServers).Error; err != nil {
+		return nil, err
+	}
+	return mcpServers, nil
+}
+
+func (m McpServerRepo) Create(mcpServer *model.McpServer) error {
+	return getDb().Create(mcpServer).Error
+}
+
+func (m McpServerRepo) Save(mcpServer *model.McpServer) error {
+	return getDb().Save(mcpServer).Error
+}
+
+func (m McpServerRepo) DeleteBy(opts ...DBOption) error {
+	return getDb(opts...).Delete(&model.McpServer{}).Error
+}

backend/app/service/ai.go

@@ -0,0 +1,415 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path"
+	"strings"
+
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
+
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/app/repo"
+	"github.com/1Panel-dev/1Panel/backend/buserr"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+)
+
+type AIToolService struct{}
+
+type IAIToolService interface {
+	Search(search dto.SearchWithPage) (int64, []dto.OllamaModelInfo, error)
+	Create(name string) error
+	Close(name string) error
+	Recreate(name string) error
+	Delete(req dto.ForceDelete) error
+	Sync() ([]dto.OllamaModelDropList, error)
+	LoadDetail(name string) (string, error)
+	BindDomain(req dto.OllamaBindDomain) error
+	GetBindDomain(req dto.OllamaBindDomainReq) (*dto.OllamaBindDomainRes, error)
+	UpdateBindDomain(req dto.OllamaBindDomain) error
+}
+
+func NewIAIToolService() IAIToolService {
+	return &AIToolService{}
+}
+
+func (u *AIToolService) Search(req dto.SearchWithPage) (int64, []dto.OllamaModelInfo, error) {
+	var options []repo.DBOption
+	if len(req.Info) != 0 {
+		options = append(options, commonRepo.WithLikeName(req.Info))
+	}
+	total, list, err := aiRepo.Page(req.Page, req.PageSize, options...)
+	if err != nil {
+		return 0, nil, err
+	}
+	var dtoLists []dto.OllamaModelInfo
+	for _, itemModel := range list {
+		var item dto.OllamaModelInfo
+		if err := copier.Copy(&item, &itemModel); err != nil {
+			return 0, nil, errors.WithMessage(constant.ErrStructTransform, err.Error())
+		}
+		logPath := path.Join(global.CONF.System.DataDir, "log", "AITools", itemModel.Name)
+		if _, err := os.Stat(logPath); err == nil {
+			item.LogFileExist = true
+		}
+		dtoLists = append(dtoLists, item)
+	}
+	return int64(total), dtoLists, err
+}
+
+func (u *AIToolService) LoadDetail(name string) (string, error) {
+	if cmd.CheckIllegal(name) {
+		return "", buserr.New(constant.ErrCmdIllegal)
+	}
+	containerName, err := LoadContainerName()
+	if err != nil {
+		return "", err
+	}
+	stdout, err := cmd.Execf("docker exec %s ollama show %s", containerName, name)
+	if err != nil {
+		return "", err
+	}
+	return stdout, err
+}
+
+func (u *AIToolService) Create(name string) error {
+	if cmd.CheckIllegal(name) {
+		return buserr.New(constant.ErrCmdIllegal)
+	}
+	modelInfo, _ := aiRepo.Get(commonRepo.WithByName(name))
+	if modelInfo.ID != 0 {
+		return constant.ErrRecordExist
+	}
+	containerName, err := LoadContainerName()
+	if err != nil {
+		return err
+	}
+	logItem := path.Join(global.CONF.System.DataDir, "log", "AITools", name)
+	if _, err := os.Stat(path.Dir(logItem)); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(path.Dir(logItem), os.ModePerm); err != nil {
+			return err
+		}
+	}
+	info := model.OllamaModel{
+		Name:   name,
+		From:   "local",
+		Status: constant.StatusWaiting,
+	}
+	if err := aiRepo.Create(&info); err != nil {
+		return err
+	}
+	file, err := os.OpenFile(logItem, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		return err
+	}
+	go pullOllamaModel(file, containerName, info)
+	return nil
+}
+
+func (u *AIToolService) Close(name string) error {
+	if cmd.CheckIllegal(name) {
+		return buserr.New(constant.ErrCmdIllegal)
+	}
+	containerName, err := LoadContainerName()
+	if err != nil {
+		return err
+	}
+	stdout, err := cmd.Execf("docker exec %s ollama stop %s", containerName, name)
+	if err != nil {
+		return fmt.Errorf("handle ollama stop %s failed, stdout: %s, err: %v", name, stdout, err)
+	}
+	return nil
+}
+
+func (u *AIToolService) Recreate(name string) error {
+	if cmd.CheckIllegal(name) {
+		return buserr.New(constant.ErrCmdIllegal)
+	}
+	modelInfo, _ := aiRepo.Get(commonRepo.WithByName(name))
+	if modelInfo.ID == 0 {
+		return constant.ErrRecordNotFound
+	}
+	containerName, err := LoadContainerName()
+	if err != nil {
+		return err
+	}
+	if err := aiRepo.Update(modelInfo.ID, map[string]interface{}{"status": constant.StatusWaiting, "from": "local"}); err != nil {
+		return err
+	}
+	logItem := path.Join(global.CONF.System.DataDir, "log", "AITools", name)
+	if _, err := os.Stat(path.Dir(logItem)); err != nil && os.IsNotExist(err) {
+		if err = os.MkdirAll(path.Dir(logItem), os.ModePerm); err != nil {
+			return err
+		}
+	}
+	file, err := os.OpenFile(logItem, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
+	if err != nil {
+		return err
+	}
+	go pullOllamaModel(file, containerName, modelInfo)
+	return nil
+}
+
+func (u *AIToolService) Delete(req dto.ForceDelete) error {
+	ollamaList, _ := aiRepo.List(commonRepo.WithIdsIn(req.IDs))
+	if len(ollamaList) == 0 {
+		return constant.ErrRecordNotFound
+	}
+	containerName, err := LoadContainerName()
+	if err != nil && !req.ForceDelete {
+		return err
+	}
+	for _, item := range ollamaList {
+		if item.Status != constant.StatusDeleted {
+			stdout, err := cmd.Execf("docker exec %s ollama rm %s", containerName, item.Name)
+			if err != nil && !req.ForceDelete {
+				return fmt.Errorf("handle ollama rm %s failed, stdout: %s, err: %v", item.Name, stdout, err)
+			}
+		}
+		_ = aiRepo.Delete(commonRepo.WithByID(item.ID))
+		logItem := path.Join(global.CONF.System.DataDir, "log", "AITools", item.Name)
+		_ = os.Remove(logItem)
+	}
+	return nil
+}
+
+func (u *AIToolService) Sync() ([]dto.OllamaModelDropList, error) {
+	containerName, err := LoadContainerName()
+	if err != nil {
+		return nil, err
+	}
+	stdout, err := cmd.Execf("docker exec %s ollama list", containerName)
+	if err != nil {
+		return nil, err
+	}
+	var list []model.OllamaModel
+	lines := strings.Split(stdout, "\n")
+	for _, line := range lines {
+		parts := strings.Fields(line)
+		if len(parts) < 5 {
+			continue
+		}
+		if parts[0] == "NAME" {
+			continue
+		}
+		list = append(list, model.OllamaModel{Name: parts[0], Size: parts[2] + " " + parts[3]})
+	}
+	listInDB, _ := aiRepo.List()
+	var dropList []dto.OllamaModelDropList
+	for _, itemModel := range listInDB {
+		isExit := false
+		for i := 0; i < len(list); i++ {
+			if list[i].Name == itemModel.Name {
+				_ = aiRepo.Update(itemModel.ID, map[string]interface{}{"status": constant.StatusSuccess, "message": "", "size": list[i].Size})
+				list = append(list[:i], list[(i+1):]...)
+				isExit = true
+				break
+			}
+		}
+		if !isExit && itemModel.Status != constant.StatusWaiting {
+			_ = aiRepo.Update(itemModel.ID, map[string]interface{}{"status": constant.StatusDeleted, "message": "not exist", "size": ""})
+			dropList = append(dropList, dto.OllamaModelDropList{ID: itemModel.ID, Name: itemModel.Name})
+			continue
+		}
+	}
+	for _, item := range list {
+		item.Status = constant.StatusSuccess
+		item.From = "remote"
+		_ = aiRepo.Create(&item)
+	}
+
+	return dropList, nil
+}
+
+func (u *AIToolService) BindDomain(req dto.OllamaBindDomain) error {
+	nginxInstall, _ := getAppInstallByKey(constant.AppOpenresty)
+	if nginxInstall.ID == 0 {
+		return buserr.New("ErrOpenrestyInstall")
+	}
+	var (
+		ipList []string
+		err    error
+	)
+	if len(req.IPList) > 0 {
+		ipList, err = common.HandleIPList(req.IPList)
+		if err != nil {
+			return err
+		}
+	}
+	if req.SSLID > 0 {
+		ssl, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(req.SSLID))
+		if err != nil {
+			return err
+		}
+		if ssl.Pem == "" {
+			return buserr.New("ErrSSL")
+		}
+	}
+	createWebsiteReq := request.WebsiteCreate{
+		PrimaryDomain: req.Domain,
+		Alias:         strings.ToLower(req.Domain),
+		Type:          constant.Deployment,
+		AppType:       constant.InstalledApp,
+		AppInstallID:  req.AppInstallID,
+	}
+	websiteService := NewIWebsiteService()
+	if err := websiteService.CreateWebsite(createWebsiteReq); err != nil {
+		return err
+	}
+	website, err := websiteRepo.GetFirst(websiteRepo.WithAlias(strings.ToLower(req.Domain)))
+	if err != nil {
+		return err
+	}
+	if len(ipList) > 0 {
+		if err = ConfigAllowIPs(ipList, website); err != nil {
+			return err
+		}
+	}
+	if req.SSLID > 0 {
+		sslReq := request.WebsiteHTTPSOp{
+			WebsiteID:    website.ID,
+			Enable:       true,
+			Type:         "existed",
+			WebsiteSSLID: req.SSLID,
+			HttpConfig:   "HTTPSOnly",
+		}
+		if _, err = websiteService.OpWebsiteHTTPS(context.Background(), sslReq); err != nil {
+			return err
+		}
+	}
+	if err = ConfigAIProxy(website); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (u *AIToolService) GetBindDomain(req dto.OllamaBindDomainReq) (*dto.OllamaBindDomainRes, error) {
+	install, err := appInstallRepo.GetFirst(commonRepo.WithByID(req.AppInstallID))
+	if err != nil {
+		return nil, err
+	}
+	res := &dto.OllamaBindDomainRes{}
+	website, _ := websiteRepo.GetFirst(websiteRepo.WithAppInstallId(install.ID))
+	if website.ID == 0 {
+		return res, nil
+	}
+	res.WebsiteID = website.ID
+	res.Domain = website.PrimaryDomain
+	if website.WebsiteSSLID > 0 {
+		res.SSLID = website.WebsiteSSLID
+		ssl, _ := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebsiteSSLID))
+		res.AcmeAccountID = ssl.AcmeAccountID
+	}
+	res.ConnUrl = fmt.Sprintf("%s://%s", strings.ToLower(website.Protocol), website.PrimaryDomain)
+	res.AllowIPs = GetAllowIps(website)
+	return res, nil
+}
+
+func (u *AIToolService) UpdateBindDomain(req dto.OllamaBindDomain) error {
+	nginxInstall, _ := getAppInstallByKey(constant.AppOpenresty)
+	if nginxInstall.ID == 0 {
+		return buserr.New("ErrOpenrestyInstall")
+	}
+	var (
+		ipList []string
+		err    error
+	)
+	if len(req.IPList) > 0 {
+		ipList, err = common.HandleIPList(req.IPList)
+		if err != nil {
+			return err
+		}
+	}
+	if req.SSLID > 0 {
+		ssl, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(req.SSLID))
+		if err != nil {
+			return err
+		}
+		if ssl.Pem == "" {
+			return buserr.New("ErrSSL")
+		}
+	}
+	websiteService := NewIWebsiteService()
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
+	if err != nil {
+		return err
+	}
+	if err = ConfigAllowIPs(ipList, website); err != nil {
+		return err
+	}
+	if req.SSLID > 0 {
+		sslReq := request.WebsiteHTTPSOp{
+			WebsiteID:    website.ID,
+			Enable:       true,
+			Type:         "existed",
+			WebsiteSSLID: req.SSLID,
+			HttpConfig:   "HTTPSOnly",
+		}
+		if _, err = websiteService.OpWebsiteHTTPS(context.Background(), sslReq); err != nil {
+			return err
+		}
+		return nil
+	}
+	if website.WebsiteSSLID > 0 && req.SSLID == 0 {
+		sslReq := request.WebsiteHTTPSOp{
+			WebsiteID: website.ID,
+			Enable:    false,
+		}
+		if _, err = websiteService.OpWebsiteHTTPS(context.Background(), sslReq); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func LoadContainerName() (string, error) {
+	ollamaBaseInfo, err := appInstallRepo.LoadBaseInfo("ollama", "")
+	if err != nil {
+		return "", fmt.Errorf("ollama service is not found, err: %v", err)
+	}
+	if ollamaBaseInfo.Status != constant.Running {
+		return "", fmt.Errorf("container %s of ollama is not running, please check and retry!", ollamaBaseInfo.ContainerName)
+	}
+	return ollamaBaseInfo.ContainerName, nil
+}
+
+func pullOllamaModel(file *os.File, containerName string, info model.OllamaModel) {
+	defer file.Close()
+	cmd := exec.Command("docker", "exec", containerName, "ollama", "pull", info.Name)
+	multiWriter := io.MultiWriter(os.Stdout, file)
+	cmd.Stdout = multiWriter
+	cmd.Stderr = multiWriter
+	_ = cmd.Run()
+	itemSize, err := loadModelSize(info.Name, containerName)
+	if len(itemSize) != 0 {
+		_ = aiRepo.Update(info.ID, map[string]interface{}{"status": constant.StatusSuccess, "size": itemSize})
+	} else {
+		_ = aiRepo.Update(info.ID, map[string]interface{}{"status": constant.StatusFailed, "message": err.Error()})
+	}
+	_, _ = file.WriteString("ollama pull completed!")
+}
+
+func loadModelSize(name string, containerName string) (string, error) {
+	stdout, err := cmd.Execf("docker exec %s ollama list | grep %s", containerName, name)
+	if err != nil {
+		return "", err
+	}
+	lines := strings.Split(string(stdout), "\n")
+	for _, line := range lines {
+		parts := strings.Fields(line)
+		if len(parts) < 5 {
+			continue
+		}
+		return parts[2] + " " + parts[3], nil
+	}
+	return "", fmt.Errorf("no such model %s in ollama list, std: %s", name, string(stdout))
+}

backend/app/service/app.go

@@ -94,13 +94,14 @@ func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (interface{
 	lang := strings.ToLower(common.GetLang(ctx))
 	for _, ap := range apps {
 		appDTO := &response.AppItem{
-			ID:       ap.ID,
-			Name:     ap.Name,
-			Key:      ap.Key,
-			Type:     ap.Type,
-			Icon:     ap.Icon,
-			Resource: ap.Resource,
-			Limit:    ap.Limit,
+			ID:         ap.ID,
+			Name:       ap.Name,
+			Key:        ap.Key,
+			Type:       ap.Type,
+			Icon:       ap.Icon,
+			Resource:   ap.Resource,
+			Limit:      ap.Limit,
+			GpuSupport: ap.GpuSupport,
 		}
 		appDTO.Description = ap.GetDescription(ctx)
 		appDTOs = append(appDTOs, appDTO)
@@ -167,6 +168,7 @@ func (a AppService) GetApp(ctx *gin.Context, key string) (*response.AppDTO, erro
 	if err != nil {
 		return nil, err
 	}
+	appDTO.GpuSupport = app.GpuSupport
 	appDTO.Tags = tags
 	return &appDTO, nil
 }
@@ -264,6 +266,7 @@ func (a AppService) GetAppDetail(appID uint, version, appType string) (response.
 	if err := checkLimit(app); err != nil {
 		appDetailDTO.Enable = false
 	}
+	appDetailDTO.GpuSupport = app.GpuSupport
 	return appDetailDTO, nil
 }
 func (a AppService) GetAppDetailByID(id uint) (*response.AppDetailDTO, error) {
@@ -862,6 +865,7 @@ func (a AppService) SyncAppListFromRemote() (err error) {
 	global.LOG.Infof("Starting synchronization of application details...")
 	for _, l := range list.Apps {
 		app := appsMap[l.AppProperty.Key]
+		app.GpuSupport = l.AppProperty.GpuSupport
 
 		if l.AppProperty.Version > 0 && common.CompareVersion(strconv.FormatFloat(l.AppProperty.Version, 'f', -1, 64), setting.SystemVersion) {
 			delete(appsMap, l.AppProperty.Key)

backend/app/service/app_install.go

@@ -750,6 +750,7 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 	}
 	res.AppContainerConfig = config
 	res.HostMode = isHostModel(install.DockerCompose)
+	res.GpuConfig = isGpuConfig(install.DockerCompose)
 	return &res, nil
 }
 
@@ -838,6 +839,9 @@ func updateInstallInfoInDB(appKey, appName, param string, value interface{}) err
 			"param": strings.ReplaceAll(appInstall.Param, oldVal, newVal),
 			"env":   strings.ReplaceAll(appInstall.Env, oldVal, newVal),
 		}, commonRepo.WithByID(appInstall.ID))
+		if appKey == "mysql" || appKey == "postgresql" {
+			return nil
+		}
 	}
 	if param == "user-password" {
 		oldVal = fmt.Sprintf("\"PANEL_DB_USER_PASSWORD\":\"%v\"", appInstall.UserPassword)

backend/app/service/app_utils.go

@@ -1163,12 +1163,11 @@ func handleLocalApp(appDir string) (app *model.App, err error) {
 	app.Website = appDefine.Website
 	app.Github = appDefine.Github
 	app.Document = appDefine.Document
-
 	if appDefine.ShortDescZh != "" {
-		appDefine.Description.Zh = appDefine.ShortDescZh
+		app.ShortDescZh = appDefine.ShortDescZh
 	}
 	if appDefine.ShortDescEn != "" {
-		appDefine.Description.En = appDefine.ShortDescEn
+		app.ShortDescEn = appDefine.ShortDescEn
 	}
 	desc, _ := json.Marshal(appDefine.Description)
 	app.Description = string(desc)
@@ -1339,9 +1338,10 @@ func handleInstalled(appInstallList []model.AppInstall, updated bool, sync bool)
 			Path:        installed.GetPath(),
 			CreatedAt:   installed.CreatedAt,
 			App: response.AppDetail{
-				Github:   installed.App.Github,
-				Website:  installed.App.Website,
-				Document: installed.App.Document,
+				Github:     installed.App.Github,
+				Website:    installed.App.Website,
+				Document:   installed.App.Document,
+				GpuSupport: installed.App.GpuSupport,
 			},
 		}
 		if updated {
@@ -1500,6 +1500,20 @@ func addDockerComposeCommonParam(composeMap map[string]interface{}, serviceName
 	deploy["resources"] = resource
 	serviceValue["deploy"] = deploy
 
+	if req.GpuConfig {
+		resource["reservations"] = map[string]interface{}{
+			"devices": []map[string]interface{}{
+				{
+					"driver":       "nvidia",
+					"count":        "all",
+					"capabilities": []string{"gpu"},
+				},
+			},
+		}
+	} else {
+		delete(resource, "reservations")
+	}
+
 	ports, ok := serviceValue["ports"].([]interface{})
 	if ok {
 		for i, port := range ports {
@@ -1601,6 +1615,33 @@ func isHostModel(dockerCompose string) bool {
 	return false
 }
 
+func isGpuConfig(dockerCompose string) bool {
+	composeMap := make(map[string]interface{})
+	_ = yaml.Unmarshal([]byte(dockerCompose), &composeMap)
+	services, serviceValid := composeMap["services"].(map[string]interface{})
+	if !serviceValid {
+		return false
+	}
+	for _, service := range services {
+		serviceValue := service.(map[string]interface{})
+		deploy := map[string]interface{}{}
+		if de, ok := serviceValue["deploy"]; ok {
+			deploy = de.(map[string]interface{})
+		}
+		resource := map[string]interface{}{}
+		if res, ok := deploy["resources"]; ok {
+			resource = res.(map[string]interface{})
+		}
+		if reservations, ok := resource["reservations"]; ok {
+			reservationsMap := reservations.(map[string]interface{})
+			if _, dOk := reservationsMap["devices"]; dOk {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func RequestDownloadCallBack(downloadCallBackUrl string) {
 	if downloadCallBackUrl == "" {
 		return

backend/app/service/auth.go

@@ -3,6 +3,8 @@ package service
 import (
 	"crypto/hmac"
 	"encoding/base64"
+	"strconv"
+
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/constant"
@@ -13,7 +15,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
 	"github.com/pkg/errors"
-	"strconv"
 )
 
 type AuthService struct{}
@@ -203,10 +204,7 @@ func (u *AuthService) GetSecurityEntrance() string {
 func (u *AuthService) IsLogin(c *gin.Context) bool {
 	sID, _ := c.Cookie(constant.SessionName)
 	_, err := global.SESSION.Get(sID)
-	if err != nil {
-		return false
-	}
-	return true
+	return err == nil
 }
 
 func checkPassword(password string) error {

backend/app/service/backup_mysql.go

@@ -2,13 +2,14 @@ package service
 
 import (
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/constant"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/backend/constant"
+
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
@@ -169,8 +170,9 @@ func handleMysqlRecover(req dto.CommonRecover, isRollback bool) error {
 					Timeout: 300,
 				}); err != nil {
 					global.LOG.Errorf("rollback mysql db %s from %s failed, err: %v", req.DetailName, rollbackFile, err)
+				} else {
+					global.LOG.Infof("rollback mysql db %s from %s successful", req.DetailName, rollbackFile)
 				}
-				global.LOG.Infof("rollback mysql db %s from %s successful", req.DetailName, rollbackFile)
 				_ = os.RemoveAll(rollbackFile)
 			} else {
 				_ = os.RemoveAll(rollbackFile)
@@ -186,6 +188,7 @@ func handleMysqlRecover(req dto.CommonRecover, isRollback bool) error {
 
 		Timeout: 300,
 	}); err != nil {
+		global.LOG.Errorf("recover mysql db %s from %s failed, err: %v", req.DetailName, req.File, err)
 		return err
 	}
 	isOk = true

backend/app/service/backup_postgresql.go

@@ -2,13 +2,14 @@ package service
 
 import (
 	"fmt"
-	"github.com/1Panel-dev/1Panel/backend/constant"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 	"time"
 
+	"github.com/1Panel-dev/1Panel/backend/constant"
+
 	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	pgclient "github.com/1Panel-dev/1Panel/backend/utils/postgresql/client"
@@ -157,8 +158,9 @@ func handlePostgresqlRecover(req dto.CommonRecover, isRollback bool) error {
 					Timeout: 300,
 				}); err != nil {
 					global.LOG.Errorf("rollback postgresql db %s from %s failed, err: %v", req.DetailName, rollbackFile, err)
+				} else {
+					global.LOG.Infof("rollback postgresql db %s from %s successful", req.DetailName, rollbackFile)
 				}
-				global.LOG.Infof("rollback postgresql db %s from %s successful", req.DetailName, rollbackFile)
 				_ = os.RemoveAll(rollbackFile)
 			} else {
 				_ = os.RemoveAll(rollbackFile)
@@ -171,6 +173,7 @@ func handlePostgresqlRecover(req dto.CommonRecover, isRollback bool) error {
 		Username:   dbInfo.Username,
 		Timeout:    300,
 	}); err != nil {
+		global.LOG.Errorf("recover postgresql db %s from %s failed, err: %v", req.DetailName, req.File, err)
 		return err
 	}
 	isOk = true

backend/app/service/container.go

@@ -255,14 +255,14 @@ func (u *ContainerService) ContainerListStats() ([]dto.ContainerListStats, error
 	if err != nil {
 		return nil, err
 	}
-	var datas []dto.ContainerListStats
+	datas := make([]dto.ContainerListStats, len(list))
 	var wg sync.WaitGroup
 	wg.Add(len(list))
 	for i := 0; i < len(list); i++ {
-		go func(item types.Container) {
-			datas = append(datas, loadCpuAndMem(client, item.ID))
+		go func(index int, item types.Container) {
+			datas[index] = loadCpuAndMem(client, item.ID)
 			wg.Done()
-		}(list[i])
+		}(i, list[i])
 	}
 	wg.Wait()
 	return datas, nil
@@ -450,12 +450,14 @@ func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.Contai
 	networkSettings := oldContainer.NetworkSettings
 	bridgeNetworkSettings := networkSettings.Networks[data.Network]
 	if bridgeNetworkSettings.IPAMConfig != nil {
-		ipv4Address := bridgeNetworkSettings.IPAMConfig.IPv4Address
-		data.Ipv4 = ipv4Address
-		ipv6Address := bridgeNetworkSettings.IPAMConfig.IPv6Address
-		data.Ipv6 = ipv6Address
+		if data.Network != "bridge" {
+			data.Ipv4 = bridgeNetworkSettings.IPAMConfig.IPv4Address
+			data.Ipv6 = bridgeNetworkSettings.IPAMConfig.IPv6Address
+		}
 	} else {
-		data.Ipv4 = bridgeNetworkSettings.IPAddress
+		if data.Network != "bridge" {
+			data.Ipv4 = bridgeNetworkSettings.IPAddress
+		}
 	}
 
 	data.Cmd = oldContainer.Config.Cmd
@@ -937,15 +939,27 @@ func calculateCPUPercentUnix(stats *types.StatsJSON) float64 {
 	}
 	return cpuPercent
 }
+
 func calculateMemPercentUnix(memStats types.MemoryStats) float64 {
 	memPercent := 0.0
-	memUsage := float64(memStats.Usage)
-	memLimit := float64(memStats.Limit)
+	memUsage := calculateMemUsageUnixNoCache(memStats)
+	memLimit := memStats.Limit
 	if memUsage > 0.0 && memLimit > 0.0 {
-		memPercent = (memUsage / memLimit) * 100.0
+		memPercent = (float64(memUsage) / float64(memLimit)) * 100.0
 	}
 	return memPercent
 }
+
+func calculateMemUsageUnixNoCache(mem types.MemoryStats) uint64 {
+	if v, isCgroup1 := mem.Stats["total_inactive_file"]; isCgroup1 && v < mem.Usage {
+		return mem.Usage - v
+	}
+	if v := mem.Stats["inactive_file"]; v < mem.Usage {
+		return mem.Usage - v
+	}
+	return mem.Usage
+}
+
 func calculateBlockIO(blkio types.BlkioStats) (blkRead float64, blkWrite float64) {
 	for _, bioEntry := range blkio.IoServiceBytesRecursive {
 		switch strings.ToLower(bioEntry.Op) {
@@ -1063,7 +1077,7 @@ func loadCpuAndMem(client *client.Client, container string) dto.ContainerListSta
 	data.PercpuUsage = len(stats.CPUStats.CPUUsage.PercpuUsage)
 
 	data.MemoryCache = stats.MemoryStats.Stats["cache"]
-	data.MemoryUsage = stats.MemoryStats.Usage
+	data.MemoryUsage = calculateMemUsageUnixNoCache(stats.MemoryStats)
 	data.MemoryLimit = stats.MemoryStats.Limit
 
 	data.MemoryPercent = calculateMemPercentUnix(stats.MemoryStats)
@@ -1183,9 +1197,10 @@ func loadConfigInfo(isCreate bool, req dto.ContainerOperate, oldContainer *types
 	for _, volume := range req.Volumes {
 		if volume.Type == "volume" {
 			hostConf.Mounts = append(hostConf.Mounts, mount.Mount{
-				Type:   mount.Type(volume.Type),
-				Source: volume.SourceDir,
-				Target: volume.ContainerDir,
+				Type:     mount.Type(volume.Type),
+				Source:   volume.SourceDir,
+				Target:   volume.ContainerDir,
+				ReadOnly: volume.Mode == "ro",
 			})
 			config.Volumes[volume.ContainerDir] = struct{}{}
 		} else {
@@ -1262,12 +1277,12 @@ func loadContainerPortForInfo(itemPorts []types.Port) []dto.PortHelper {
 	var exposedPorts []dto.PortHelper
 	samePortMap := make(map[string]dto.PortHelper)
 	ports := transPortToStr(itemPorts)
-	var itemPort dto.PortHelper
 	for _, item := range ports {
 		itemStr := strings.Split(item, "->")
 		if len(itemStr) < 2 {
 			continue
 		}
+		var itemPort dto.PortHelper
 		lastIndex := strings.LastIndex(itemStr[0], ":")
 		if lastIndex == -1 {
 			itemPort.HostPort = itemStr[0]

backend/app/service/cronjob.go

@@ -114,8 +114,17 @@ func (u *CronjobService) CleanRecord(req dto.CronjobClean) error {
 			if err != nil {
 				return err
 			}
+			if !req.CleanRemoteData {
+				for key := range accountMap {
+					if key != constant.Local {
+						delete(accountMap, key)
+					}
+				}
+			}
 			cronjob.RetainCopies = 0
-			u.removeExpiredBackup(cronjob, accountMap, model.BackupRecord{})
+			if len(accountMap) != 0 {
+				u.removeExpiredBackup(cronjob, accountMap, model.BackupRecord{})
+			}
 		} else {
 			u.removeExpiredLog(cronjob)
 		}
@@ -249,7 +258,7 @@ func (u *CronjobService) Delete(req dto.CronjobBatchDelete) error {
 			global.Cron.Remove(cron.EntryID(idItem))
 		}
 		global.LOG.Infof("stop cronjob entryID: %s", cronjob.EntryIDs)
-		if err := u.CleanRecord(dto.CronjobClean{CronjobID: id, CleanData: req.CleanData, IsDelete: true}); err != nil {
+		if err := u.CleanRecord(dto.CronjobClean{CronjobID: id, CleanData: req.CleanData, CleanRemoteData: req.CleanRemoteData, IsDelete: true}); err != nil {
 			return err
 		}
 		if err := cronjobRepo.Delete(commonRepo.WithByID(id)); err != nil {

backend/app/service/cronjob_helper.go

@@ -322,7 +322,8 @@ func (u *CronjobService) uploadCronjobBackFile(cronjob model.Cronjob, accountMap
 		if len(account) != 0 {
 			global.LOG.Debugf("start upload file to %s, dir: %s", account, path.Join(accountMap[account].backupPath, cloudSrc))
 			if _, err := accountMap[account].client.Upload(file, path.Join(accountMap[account].backupPath, cloudSrc)); err != nil {
-				return "", err
+				global.LOG.Errorf("upload file to %s failed, err: %v", account, err)
+				continue
 			}
 			global.LOG.Debugf("upload successful!")
 		}
@@ -349,12 +350,18 @@ func (u *CronjobService) removeExpiredBackup(cronjob model.Cronjob, accountMap m
 		if cronjob.Type == "snapshot" {
 			for _, account := range accounts {
 				if len(account) != 0 {
+					if _, ok := accountMap[account]; !ok {
+						continue
+					}
 					_, _ = accountMap[account].client.Delete(path.Join(accountMap[account].backupPath, "system_snapshot", records[i].FileName))
 				}
 			}
 			_ = snapshotRepo.Delete(commonRepo.WithByName(strings.TrimSuffix(records[i].FileName, ".tar.gz")))
 		} else {
 			for _, account := range accounts {
+				if _, ok := accountMap[account]; !ok {
+					continue
+				}
 				if len(account) != 0 {
 					_, _ = accountMap[account].client.Delete(path.Join(accountMap[account].backupPath, records[i].FileDir, records[i].FileName))
 				}

backend/app/service/dashboard.go

@@ -10,19 +10,19 @@ import (
 	"sync"
 	"time"
 
-	"github.com/1Panel-dev/1Panel/backend/constant"
-	"github.com/shirou/gopsutil/v3/load"
-	"github.com/shirou/gopsutil/v3/mem"
-	"github.com/shirou/gopsutil/v3/net"
-
 	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/gpu"
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/xpu"
 	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
 	"github.com/1Panel-dev/1Panel/backend/utils/copier"
-	"github.com/1Panel-dev/1Panel/backend/utils/xpack"
 	"github.com/shirou/gopsutil/v3/cpu"
 	"github.com/shirou/gopsutil/v3/disk"
 	"github.com/shirou/gopsutil/v3/host"
+	"github.com/shirou/gopsutil/v3/load"
+	"github.com/shirou/gopsutil/v3/mem"
+	"github.com/shirou/gopsutil/v3/net"
 )
 
 type DashboardService struct{}
@@ -341,7 +341,17 @@ func loadDiskInfo() []dto.DiskInfo {
 }
 
 func loadGPUInfo() []dto.GPUInfo {
-	list := xpack.LoadGpuInfo()
+	ok, client := gpu.New()
+	var list []interface{}
+	if ok {
+		info, err := client.LoadGpuInfo()
+		if err != nil || len(info.GPUs) == 0 {
+			return nil
+		}
+		for _, item := range info.GPUs {
+			list = append(list, item)
+		}
+	}
 	if len(list) == 0 {
 		return nil
 	}
@@ -359,7 +369,17 @@ func loadGPUInfo() []dto.GPUInfo {
 }
 
 func loadXpuInfo() []dto.XPUInfo {
-	list := xpack.LoadXpuInfo()
+	var list []interface{}
+	ok, xpuClient := xpu.New()
+	if ok {
+		xpus, err := xpuClient.LoadDashData()
+		if err != nil || len(xpus) == 0 {
+			return nil
+		}
+		for _, item := range xpus {
+			list = append(list, item)
+		}
+	}
 	if len(list) == 0 {
 		return nil
 	}

backend/app/service/database_common.go

@@ -50,10 +50,6 @@ func (u *DBCommonService) LoadDatabaseFile(req dto.OperationWithNameAndType) (st
 		filePath = path.Join(global.CONF.System.DataDir, fmt.Sprintf("apps/postgresql/%s/data/postgresql.conf", req.Name))
 	case "redis-conf":
 		filePath = path.Join(global.CONF.System.DataDir, fmt.Sprintf("apps/redis/%s/conf/redis.conf", req.Name))
-	case "mysql-slow-logs":
-		filePath = path.Join(global.CONF.System.DataDir, fmt.Sprintf("apps/mysql/%s/data/1Panel-slow.log", req.Name))
-	case "mariadb-slow-logs":
-		filePath = path.Join(global.CONF.System.DataDir, fmt.Sprintf("apps/mariadb/%s/db/data/1Panel-slow.log", req.Name))
 	}
 	if _, err := os.Stat(filePath); err != nil {
 		return "", buserr.New("ErrHttpReqNotFound")

backend/app/service/entry.go

@@ -12,6 +12,8 @@ var (
 	appInstallRepo         = repo.NewIAppInstallRepo()
 	appInstallResourceRepo = repo.NewIAppInstallResourceRpo()
 
+	aiRepo = repo.NewIAiRepo()
+
 	mysqlRepo      = repo.NewIMysqlRepo()
 	postgresqlRepo = repo.NewIPostgresqlRepo()
 	databaseRepo   = repo.NewIDatabaseRepo()
@@ -44,4 +46,6 @@ var (
 	phpExtensionsRepo = repo.NewIPHPExtensionsRepo()
 
 	favoriteRepo = repo.NewIFavoriteRepo()
+
+	mcpServerRepo = repo.NewIMcpServerRepo()
 )

backend/app/service/file.go

@@ -50,6 +50,7 @@ type IFileService interface {
 	ChangeMode(op request.FileCreate) error
 	BatchChangeModeAndOwner(op request.FileRoleReq) error
 	ReadLogByLine(req request.FileReadByLineReq) (*response.FileLineContent, error)
+	BatchCheckFiles(req request.FilePathsCheck) []response.ExistFileInfo
 }
 
 var filteredPaths = []string{
@@ -478,6 +479,12 @@ func (f *FileService) ReadLogByLine(req request.FileReadByLineReq) (*response.Fi
 		}
 	case "image-pull", "image-push", "image-build", "compose-create":
 		logFilePath = path.Join(global.CONF.System.TmpDir, fmt.Sprintf("docker_logs/%s", req.Name))
+	case "ollama-model":
+		logFilePath = path.Join(global.CONF.System.DataDir, "log", "AITools", req.Name)
+	case "mysql-slow-logs":
+		logFilePath = path.Join(global.CONF.System.DataDir, fmt.Sprintf("apps/mysql/%s/data/1Panel-slow.log", req.Name))
+	case "mariadb-slow-logs":
+		logFilePath = path.Join(global.CONF.System.DataDir, fmt.Sprintf("apps/mariadb/%s/db/data/1Panel-slow.log", req.Name))
 	}
 
 	lines, isEndOfFile, total, err := files.ReadFileByLine(logFilePath, req.Page, req.PageSize, req.Latest)
@@ -501,3 +508,18 @@ func (f *FileService) ReadLogByLine(req request.FileReadByLineReq) (*response.Fi
 	}
 	return res, nil
 }
+
+func (f *FileService) BatchCheckFiles(req request.FilePathsCheck) []response.ExistFileInfo {
+	fileList := make([]response.ExistFileInfo, 0, len(req.Paths))
+	for _, filePath := range req.Paths {
+		if info, err := os.Stat(filePath); err == nil {
+			fileList = append(fileList, response.ExistFileInfo{
+				Size:    float64(info.Size()),
+				Name:    info.Name(),
+				Path:    filePath,
+				ModTime: info.ModTime(),
+			})
+		}
+	}
+	return fileList
+}

backend/app/service/firewall.go

@@ -381,6 +381,10 @@ func (u *FirewallService) OperateForwardRule(req dto.ForwardRuleOperate) error {
 				TargetIP:   r.TargetIP,
 				TargetPort: r.TargetPort,
 			}, r.Operation); err != nil {
+				if req.ForceDelete {
+					global.LOG.Error(err)
+					continue
+				}
 				return err
 			}
 		}

backend/app/service/mcp_server.go

@@ -0,0 +1,643 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/app/dto"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/request"
+	"github.com/1Panel-dev/1Panel/backend/app/dto/response"
+	"github.com/1Panel-dev/1Panel/backend/app/model"
+	"github.com/1Panel-dev/1Panel/backend/buserr"
+	"github.com/1Panel-dev/1Panel/backend/constant"
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
+	"github.com/1Panel-dev/1Panel/backend/utils/compose"
+	"github.com/1Panel-dev/1Panel/backend/utils/docker"
+	"github.com/1Panel-dev/1Panel/backend/utils/files"
+	"github.com/1Panel-dev/1Panel/backend/utils/nginx"
+	"github.com/1Panel-dev/1Panel/backend/utils/nginx/components"
+	"github.com/1Panel-dev/1Panel/backend/utils/nginx/parser"
+	"github.com/1Panel-dev/1Panel/cmd/server/mcp"
+	"github.com/1Panel-dev/1Panel/cmd/server/nginx_conf"
+	"github.com/subosito/gotenv"
+	"gopkg.in/yaml.v3"
+	"path"
+	"strconv"
+	"strings"
+)
+
+type McpServerService struct{}
+
+type IMcpServerService interface {
+	Page(req request.McpServerSearch) response.McpServersRes
+	Create(create request.McpServerCreate) error
+	Update(req request.McpServerUpdate) error
+	Delete(id uint) error
+	Operate(req request.McpServerOperate) error
+	GetBindDomain() (response.McpBindDomainRes, error)
+	BindDomain(req request.McpBindDomain) error
+	UpdateBindDomain(req request.McpBindDomainUpdate) error
+}
+
+func NewIMcpServerService() IMcpServerService {
+	return &McpServerService{}
+}
+
+func (m McpServerService) Page(req request.McpServerSearch) response.McpServersRes {
+	var (
+		res   response.McpServersRes
+		items []response.McpServerDTO
+	)
+
+	total, data, _ := mcpServerRepo.Page(req.PageInfo.Page, req.PageInfo.PageSize)
+	for _, item := range data {
+		_ = syncMcpServerContainerStatus(&item)
+		serverDTO := response.McpServerDTO{
+			McpServer:    item,
+			Environments: make([]request.Environment, 0),
+			Volumes:      make([]request.Volume, 0),
+		}
+		project, _ := docker.GetComposeProject(item.Name, path.Join(constant.McpDir, item.Name), []byte(item.DockerCompose), []byte(item.Env), true)
+		for _, service := range project.Services {
+			if service.Environment != nil {
+				for key, value := range service.Environment {
+					serverDTO.Environments = append(serverDTO.Environments, request.Environment{
+						Key:   key,
+						Value: *value,
+					})
+				}
+			}
+			if service.Volumes != nil {
+				for _, volume := range service.Volumes {
+					serverDTO.Volumes = append(serverDTO.Volumes, request.Volume{
+						Source: volume.Source,
+						Target: volume.Target,
+					})
+				}
+			}
+		}
+		items = append(items, serverDTO)
+	}
+	res.Total = total
+	res.Items = items
+	return res
+}
+
+func (m McpServerService) Update(req request.McpServerUpdate) error {
+	mcpServer, err := mcpServerRepo.GetFirst(commonRepo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	if mcpServer.Port != req.Port {
+		if err := checkPortExist(req.Port); err != nil {
+			return err
+		}
+	}
+	if mcpServer.ContainerName != req.ContainerName {
+		if err := checkContainerName(req.ContainerName); err != nil {
+			return err
+		}
+	}
+	mcpServer.Name = req.Name
+	mcpServer.ContainerName = req.ContainerName
+	mcpServer.Port = req.Port
+	mcpServer.Command = req.Command
+	mcpServer.BaseURL = req.BaseURL
+	mcpServer.SsePath = req.SsePath
+	mcpServer.HostIP = req.HostIP
+	if err := handleCreateParams(mcpServer, req.Environments, req.Volumes); err != nil {
+		return err
+	}
+	env := handleEnv(mcpServer)
+	mcpDir := path.Join(constant.McpDir, mcpServer.Name)
+	envPath := path.Join(mcpDir, ".env")
+	if err := gotenv.Write(env, envPath); err != nil {
+		return err
+	}
+	dockerComposePath := path.Join(mcpDir, "docker-compose.yml")
+	if err := files.NewFileOp().SaveFile(dockerComposePath, mcpServer.DockerCompose, 0644); err != nil {
+		return err
+	}
+	mcpServer.Status = constant.RuntimeStarting
+	if err := mcpServerRepo.Save(mcpServer); err != nil {
+		return err
+	}
+	go startMcp(mcpServer)
+	return nil
+}
+
+func (m McpServerService) Create(create request.McpServerCreate) error {
+	servers, _ := mcpServerRepo.List()
+	for _, server := range servers {
+		if server.Port == create.Port {
+			return buserr.New("ErrPortInUsed")
+		}
+		if server.ContainerName == create.ContainerName {
+			return buserr.New("ErrContainerName")
+		}
+		if server.Name == create.Name {
+			return buserr.New(constant.ErrNameIsExist)
+		}
+		if server.SsePath == create.SsePath {
+			return buserr.New("ErrSsePath")
+		}
+	}
+	if err := checkPortExist(create.Port); err != nil {
+		return err
+	}
+	if err := checkContainerName(create.ContainerName); err != nil {
+		return err
+	}
+	mcpDir := path.Join(constant.McpDir, create.Name)
+	mcpServer := &model.McpServer{
+		Name:          create.Name,
+		ContainerName: create.ContainerName,
+		Port:          create.Port,
+		Command:       create.Command,
+		Status:        constant.RuntimeStarting,
+		BaseURL:       create.BaseURL,
+		SsePath:       create.SsePath,
+		Dir:           mcpDir,
+		HostIP:        create.HostIP,
+	}
+	if err := handleCreateParams(mcpServer, create.Environments, create.Volumes); err != nil {
+		return err
+	}
+
+	env := handleEnv(mcpServer)
+	filesOP := files.NewFileOp()
+	if !filesOP.Stat(mcpDir) {
+		_ = filesOP.CreateDir(mcpDir, 0644)
+	}
+	envPath := path.Join(mcpDir, ".env")
+	if err := gotenv.Write(env, envPath); err != nil {
+		return err
+	}
+	dockerComposePath := path.Join(mcpDir, "docker-compose.yml")
+	if err := filesOP.SaveFile(dockerComposePath, mcpServer.DockerCompose, 0644); err != nil {
+		return err
+	}
+	if err := mcpServerRepo.Create(mcpServer); err != nil {
+		return err
+	}
+	addProxy(mcpServer)
+	go startMcp(mcpServer)
+	return nil
+}
+
+func (m McpServerService) Delete(id uint) error {
+	mcpServer, err := mcpServerRepo.GetFirst(commonRepo.WithByID(id))
+	if err != nil {
+		return err
+	}
+	composePath := path.Join(constant.McpDir, mcpServer.Name, "docker-compose.yml")
+	_, _ = compose.Down(composePath)
+	_ = files.NewFileOp().DeleteDir(path.Join(constant.McpDir, mcpServer.Name))
+
+	websiteID := GetWebsiteID()
+	if websiteID > 0 {
+		websiteService := NewIWebsiteService()
+		delProxyReq := request.WebsiteProxyDel{
+			ID:   websiteID,
+			Name: mcpServer.Name,
+		}
+		_ = websiteService.DeleteProxy(delProxyReq)
+	}
+	return mcpServerRepo.DeleteBy(commonRepo.WithByID(id))
+}
+
+func (m McpServerService) Operate(req request.McpServerOperate) error {
+	mcpServer, err := mcpServerRepo.GetFirst(commonRepo.WithByID(req.ID))
+	if err != nil {
+		return err
+	}
+	composePath := path.Join(mcpServer.Dir, "docker-compose.yml")
+	var out string
+	switch req.Operate {
+	case "start":
+		out, err = compose.Up(composePath)
+		mcpServer.Status = constant.RuntimeRunning
+	case "stop":
+		out, err = compose.Down(composePath)
+		mcpServer.Status = constant.RuntimeStopped
+	case "restart":
+		out, err = compose.Restart(composePath)
+		mcpServer.Status = constant.RuntimeRunning
+	}
+	if err != nil {
+		mcpServer.Status = constant.RuntimeError
+		mcpServer.Message = out
+	}
+	return mcpServerRepo.Save(mcpServer)
+}
+
+func (m McpServerService) GetBindDomain() (response.McpBindDomainRes, error) {
+	var res response.McpBindDomainRes
+	websiteID := GetWebsiteID()
+	if websiteID == 0 {
+		return res, nil
+	}
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteID))
+	if err != nil {
+		return res, nil
+	}
+	res.WebsiteID = website.ID
+	res.Domain = website.PrimaryDomain
+	if website.WebsiteSSLID > 0 {
+		res.SSLID = website.WebsiteSSLID
+		ssl, _ := websiteSSLRepo.GetFirst(commonRepo.WithByID(website.WebsiteSSLID))
+		res.AcmeAccountID = ssl.AcmeAccountID
+	}
+	res.ConnUrl = fmt.Sprintf("%s://%s", strings.ToLower(website.Protocol), website.PrimaryDomain)
+	res.AllowIPs = GetAllowIps(website)
+	return res, nil
+
+}
+
+func (m McpServerService) BindDomain(req request.McpBindDomain) error {
+	nginxInstall, _ := getAppInstallByKey(constant.AppOpenresty)
+	if nginxInstall.ID == 0 {
+		return buserr.New("ErrOpenrestyInstall")
+	}
+	var (
+		ipList []string
+		err    error
+	)
+	if len(req.IPList) > 0 {
+		ipList, err = common.HandleIPList(req.IPList)
+		if err != nil {
+			return err
+		}
+	}
+	if req.SSLID > 0 {
+		ssl, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(req.SSLID))
+		if err != nil {
+			return err
+		}
+		if ssl.Pem == "" {
+			return buserr.New("ErrSSL")
+		}
+	}
+	group, _ := groupRepo.Get(groupRepo.WithByWebsiteDefault())
+	createWebsiteReq := request.WebsiteCreate{
+		PrimaryDomain:  req.Domain,
+		Alias:          strings.ToLower(req.Domain),
+		Type:           constant.Static,
+		WebsiteGroupID: group.ID,
+	}
+	websiteService := NewIWebsiteService()
+	if err := websiteService.CreateWebsite(createWebsiteReq); err != nil {
+		return err
+	}
+	website, err := websiteRepo.GetFirst(websiteRepo.WithAlias(strings.ToLower(req.Domain)))
+	if err != nil {
+		return err
+	}
+	_ = settingRepo.UpdateOrCreate("MCP_WEBSITE_ID", fmt.Sprintf("%d", website.ID))
+	if len(ipList) > 0 {
+		if err = ConfigAllowIPs(ipList, website); err != nil {
+			return err
+		}
+	}
+	if req.SSLID > 0 {
+		sslReq := request.WebsiteHTTPSOp{
+			WebsiteID:    website.ID,
+			Enable:       true,
+			Type:         "existed",
+			WebsiteSSLID: req.SSLID,
+			HttpConfig:   "HTTPSOnly",
+		}
+		if _, err = websiteService.OpWebsiteHTTPS(context.Background(), sslReq); err != nil {
+			return err
+		}
+	}
+	if err = addMCPProxy(website.ID); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (m McpServerService) UpdateBindDomain(req request.McpBindDomainUpdate) error {
+	nginxInstall, _ := getAppInstallByKey(constant.AppOpenresty)
+	if nginxInstall.ID == 0 {
+		return buserr.New("ErrOpenrestyInstall")
+	}
+	var (
+		ipList []string
+		err    error
+	)
+	if len(req.IPList) > 0 {
+		ipList, err = common.HandleIPList(req.IPList)
+		if err != nil {
+			return err
+		}
+	}
+	if req.SSLID > 0 {
+		ssl, err := websiteSSLRepo.GetFirst(commonRepo.WithByID(req.SSLID))
+		if err != nil {
+			return err
+		}
+		if ssl.Pem == "" {
+			return buserr.New("ErrSSL")
+		}
+	}
+	websiteService := NewIWebsiteService()
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(req.WebsiteID))
+	if err != nil {
+		return err
+	}
+	if err = ConfigAllowIPs(ipList, website); err != nil {
+		return err
+	}
+	if req.SSLID > 0 {
+		sslReq := request.WebsiteHTTPSOp{
+			WebsiteID:    website.ID,
+			Enable:       true,
+			Type:         "existed",
+			WebsiteSSLID: req.SSLID,
+			HttpConfig:   "HTTPSOnly",
+		}
+		if _, err = websiteService.OpWebsiteHTTPS(context.Background(), sslReq); err != nil {
+			return err
+		}
+	}
+	if website.WebsiteSSLID > 0 && req.SSLID == 0 {
+		sslReq := request.WebsiteHTTPSOp{
+			WebsiteID: website.ID,
+			Enable:    false,
+		}
+		if _, err = websiteService.OpWebsiteHTTPS(context.Background(), sslReq); err != nil {
+			return err
+		}
+	}
+	go updateMcpConfig(website.ID)
+	return nil
+}
+
+func updateMcpConfig(websiteID uint) {
+	servers, _ := mcpServerRepo.List()
+	if len(servers) == 0 {
+		return
+	}
+	website, _ := websiteRepo.GetFirst(commonRepo.WithByID(websiteID))
+	websiteDomain := website.Domains[0]
+	var baseUrl string
+	if website.Protocol == constant.ProtocolHTTP {
+		baseUrl = fmt.Sprintf("http://%s", websiteDomain.Domain)
+	} else {
+		baseUrl = fmt.Sprintf("https://%s", websiteDomain.Domain)
+	}
+
+	go func() {
+		for _, server := range servers {
+			if server.BaseURL != baseUrl {
+				server.BaseURL = baseUrl
+				server.HostIP = "127.0.0.1"
+				_ = updateMcpServer(&server)
+			}
+		}
+	}()
+}
+
+func addProxy(server *model.McpServer) {
+	websiteID := GetWebsiteID()
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteID))
+	if err != nil {
+		global.LOG.Errorf("[mcp] add proxy failed, err: %v", err)
+		return
+	}
+	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
+	if err != nil {
+		global.LOG.Errorf("[mcp] add proxy failed, err: %v", err)
+		return
+	}
+	fileOp := files.NewFileOp()
+	includeDir := path.Join(nginxInstall.GetPath(), "www", "sites", website.Alias, "proxy")
+	if !fileOp.Stat(includeDir) {
+		if err = fileOp.CreateDir(includeDir, 0644); err != nil {
+			return
+		}
+	}
+	config, err := parser.NewStringParser(string(nginx_conf.SSE)).Parse()
+	if err != nil {
+		return
+	}
+	includePath := path.Join(includeDir, server.Name+".conf")
+	config.FilePath = includePath
+	directives := config.Directives
+	location, ok := directives[0].(*components.Location)
+	if !ok {
+		return
+	}
+	location.UpdateDirective("proxy_pass", []string{fmt.Sprintf("http://127.0.1:%d%s", server.Port, server.SsePath)})
+	location.ChangePath("^~", server.SsePath)
+	if err = nginx.WriteConfig(config, nginx.IndentedStyle); err != nil {
+		global.LOG.Errorf("write config failed, err: %v", buserr.WithErr(constant.ErrUpdateBuWebsite, err))
+		return
+	}
+	nginxInclude := fmt.Sprintf("/www/sites/%s/proxy/*.conf", website.Alias)
+	if err = updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{{Name: "include", Params: []string{nginxInclude}}}, &website); err != nil {
+		global.LOG.Errorf("update nginx config failed, err: %v", err)
+		return
+	}
+}
+
+func addMCPProxy(websiteID uint) error {
+	servers, _ := mcpServerRepo.List()
+	if len(servers) == 0 {
+		return nil
+	}
+	nginxInstall, err := getAppInstallByKey(constant.AppOpenresty)
+	if err != nil {
+		return err
+	}
+	website, err := websiteRepo.GetFirst(commonRepo.WithByID(websiteID))
+	if err != nil {
+		return err
+	}
+	fileOp := files.NewFileOp()
+	includeDir := path.Join(nginxInstall.GetPath(), "www", "sites", website.Alias, "proxy")
+	if !fileOp.Stat(includeDir) {
+		if err = fileOp.CreateDir(includeDir, 0644); err != nil {
+			return err
+		}
+	}
+	config, err := parser.NewStringParser(string(nginx_conf.SSE)).Parse()
+	if err != nil {
+		return err
+	}
+	websiteDomain := website.Domains[0]
+	var baseUrl string
+	if website.Protocol == constant.ProtocolHTTP {
+		baseUrl = fmt.Sprintf("http://%s", websiteDomain.Domain)
+	} else {
+		baseUrl = fmt.Sprintf("https://%s", websiteDomain.Domain)
+	}
+	if websiteDomain.Port != 80 && websiteDomain.Port != 443 {
+		baseUrl = fmt.Sprintf("%s:%d", baseUrl, websiteDomain.Port)
+	}
+	for _, server := range servers {
+		includePath := path.Join(includeDir, server.Name+".conf")
+		config.FilePath = includePath
+		directives := config.Directives
+		location, ok := directives[0].(*components.Location)
+		if !ok {
+			err = errors.New("error")
+			return err
+		}
+		location.UpdateDirective("proxy_pass", []string{fmt.Sprintf("http://127.0.1:%d%s", server.Port, server.SsePath)})
+		location.ChangePath("^~", server.SsePath)
+		if err = nginx.WriteConfig(config, nginx.IndentedStyle); err != nil {
+			return buserr.WithErr(constant.ErrUpdateBuWebsite, err)
+		}
+		server.BaseURL = baseUrl
+		server.HostIP = "127.0.0.1"
+		go updateMcpServer(&server)
+	}
+	nginxInclude := fmt.Sprintf("/www/sites/%s/proxy/*.conf", website.Alias)
+	if err = updateNginxConfig(constant.NginxScopeServer, []dto.NginxParam{{Name: "include", Params: []string{nginxInclude}}}, &website); err != nil {
+		return err
+	}
+	return nil
+}
+
+func updateMcpServer(mcpServer *model.McpServer) error {
+	env := handleEnv(mcpServer)
+	if err := gotenv.Write(env, path.Join(mcpServer.Dir, ".env")); err != nil {
+		return err
+	}
+	_ = mcpServerRepo.Save(mcpServer)
+	composePath := path.Join(constant.McpDir, mcpServer.Name, "docker-compose.yml")
+	_, _ = compose.Down(composePath)
+	if _, err := compose.Up(composePath); err != nil {
+		mcpServer.Status = constant.RuntimeError
+		mcpServer.Message = err.Error()
+	}
+	return mcpServerRepo.Save(mcpServer)
+}
+
+func handleEnv(mcpServer *model.McpServer) gotenv.Env {
+	env := make(gotenv.Env)
+	env["CONTAINER_NAME"] = mcpServer.ContainerName
+	env["COMMAND"] = mcpServer.Command
+	env["PANEL_APP_PORT_HTTP"] = strconv.Itoa(mcpServer.Port)
+	env["BASE_URL"] = mcpServer.BaseURL
+	env["SSE_PATH"] = mcpServer.SsePath
+	env["HOST_IP"] = mcpServer.HostIP
+	envStr, _ := gotenv.Marshal(env)
+	mcpServer.Env = envStr
+	return env
+}
+
+func handleCreateParams(mcpServer *model.McpServer, environments []request.Environment, volumes []request.Volume) error {
+	var composeContent []byte
+	if mcpServer.ID == 0 {
+		composeContent = mcp.DefaultMcpCompose
+	} else {
+		composeContent = []byte(mcpServer.DockerCompose)
+	}
+	composeMap := make(map[string]interface{})
+	if err := yaml.Unmarshal(composeContent, &composeMap); err != nil {
+		return err
+	}
+	services, serviceValid := composeMap["services"].(map[string]interface{})
+	if !serviceValid {
+		return buserr.New(constant.ErrFileParse)
+	}
+	serviceName := ""
+	serviceValue := make(map[string]interface{})
+
+	if mcpServer.ID > 0 {
+		serviceName = mcpServer.Name
+		serviceValue = services[serviceName].(map[string]interface{})
+	} else {
+		for name, service := range services {
+			serviceName = name
+			serviceValue = service.(map[string]interface{})
+			break
+		}
+		delete(services, serviceName)
+	}
+	delete(serviceValue, "environment")
+	if len(environments) > 0 {
+		envMap := make(map[string]string)
+		for _, env := range environments {
+			envMap[env.Key] = env.Value
+		}
+		serviceValue["environment"] = envMap
+	}
+	delete(serviceValue, "volumes")
+	if len(volumes) > 0 {
+		volumeList := make([]string, 0)
+		for _, volume := range volumes {
+			volumeList = append(volumeList, fmt.Sprintf("%s:%s", volume.Source, volume.Target))
+		}
+		serviceValue["volumes"] = volumeList
+	}
+
+	services[mcpServer.Name] = serviceValue
+	composeByte, err := yaml.Marshal(composeMap)
+	if err != nil {
+		return err
+	}
+	mcpServer.DockerCompose = string(composeByte)
+	return nil
+}
+
+func startMcp(mcpServer *model.McpServer) {
+	composePath := path.Join(constant.McpDir, mcpServer.Name, "docker-compose.yml")
+	if mcpServer.Status != constant.RuntimeNormal {
+		_, _ = compose.Down(composePath)
+	}
+	if out, err := compose.Up(composePath); err != nil {
+		mcpServer.Status = constant.RuntimeError
+		mcpServer.Message = out
+	} else {
+		mcpServer.Status = constant.RuntimeRunning
+		mcpServer.Message = ""
+	}
+	_ = syncMcpServerContainerStatus(mcpServer)
+}
+
+func syncMcpServerContainerStatus(mcpServer *model.McpServer) error {
+	containerNames := []string{mcpServer.ContainerName}
+	cli, err := docker.NewClient()
+	if err != nil {
+		return err
+	}
+	defer cli.Close()
+	containers, err := cli.ListContainersByName(containerNames)
+	if err != nil {
+		return err
+	}
+	if len(containers) == 0 {
+		mcpServer.Status = constant.RuntimeStopped
+		return mcpServerRepo.Save(mcpServer)
+	}
+	container := containers[0]
+	switch container.State {
+	case "exited":
+		mcpServer.Status = constant.RuntimeError
+	case "running":
+		mcpServer.Status = constant.RuntimeRunning
+	case "paused":
+		mcpServer.Status = constant.RuntimeStopped
+	case "restarting":
+		mcpServer.Status = constant.RuntimeReStarting
+	default:
+		if mcpServer.Status != constant.RuntimeBuildIng {
+			mcpServer.Status = constant.RuntimeStopped
+		}
+	}
+	return mcpServerRepo.Save(mcpServer)
+}
+
+func GetWebsiteID() uint {
+	websiteID, _ := settingRepo.Get(settingRepo.WithByKey("MCP_WEBSITE_ID"))
+	if websiteID.Value == "" {
+		return 0
+	}
+	websiteIDUint, _ := strconv.ParseUint(websiteID.Value, 10, 64)
+	return uint(websiteIDUint)
+}

backend/app/service/website.go

@@ -496,6 +496,10 @@ func (w WebsiteService) DeleteWebsite(req request.WebsiteDelete) error {
 	if err := websiteDomainRepo.DeleteBy(ctx, websiteDomainRepo.WithWebsiteId(req.ID)); err != nil {
 		return err
 	}
+	websiteID := GetWebsiteID()
+	if req.ID == websiteID {
+		_ = settingRepo.Update("MCP_WEBSITE_ID", "0")
+	}
 	tx.Commit()
 
 	uploadDir := path.Join(global.CONF.System.BaseDir, fmt.Sprintf("1panel/uploads/website/%s", website.Alias))

backend/app/service/website_utils.go

@@ -642,9 +642,15 @@ func applySSL(website model.Website, websiteSSL model.WebsiteSSL, req request.We
 		}
 		if param.Name == "ssl_protocols" {
 			nginxParams[i].Params = req.SSLProtocol
+			if len(req.SSLProtocol) == 0 {
+				nginxParams[i].Params = []string{"TLSv1.3", "TLSv1.2", "TLSv1.1", "TLSv1"}
+			}
 		}
 		if param.Name == "ssl_ciphers" {
 			nginxParams[i].Params = []string{req.Algorithm}
+			if len(req.Algorithm) == 0 {
+				nginxParams[i].Params = []string{"ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:!aNULL:!eNULL:!EXPORT:!DSS:!DES:!RC4:!3DES:!MD5:!PSK:!KRB5:!SRP:!CAMELLIA:!SEED"}
+			}
 		}
 	}
 	if req.Hsts {
@@ -1106,3 +1112,55 @@ func getResourceContent(fileOp files.FileOp, resourcePath string) (string, error
 	}
 	return "", nil
 }
+
+func ConfigAllowIPs(ips []string, website model.Website) error {
+	nginxFull, err := getNginxFull(&website)
+	if err != nil {
+		return err
+	}
+	nginxConfig := nginxFull.SiteConfig
+	config := nginxFull.SiteConfig.Config
+	server := config.FindServers()[0]
+	server.RemoveDirective("allow", nil)
+	server.RemoveDirective("deny", nil)
+	if len(ips) > 0 {
+		server.UpdateAllowIPs(ips)
+	}
+	if err := nginx.WriteConfig(config, nginx.IndentedStyle); err != nil {
+		return err
+	}
+	return nginxCheckAndReload(nginxConfig.OldContent, config.FilePath, nginxFull.Install.ContainerName)
+}
+
+func GetAllowIps(website model.Website) []string {
+	nginxFull, err := getNginxFull(&website)
+	if err != nil {
+		return nil
+	}
+	config := nginxFull.SiteConfig.Config
+	server := config.FindServers()[0]
+	dirs := server.GetDirectives()
+	var ips []string
+	for _, dir := range dirs {
+		if dir.GetName() == "allow" {
+			ips = append(ips, dir.GetParameters()...)
+		}
+	}
+	return ips
+}
+
+func ConfigAIProxy(website model.Website) error {
+	nginxFull, err := getNginxFull(&website)
+	if err != nil {
+		return nil
+	}
+	config := nginxFull.SiteConfig.Config
+	server := config.FindServers()[0]
+	dirs := server.GetDirectives()
+	for _, dir := range dirs {
+		if dir.GetName() == "location" && dir.GetParameters()[0] == "/" {
+			server.UpdateRootProxyForAi([]string{fmt.Sprintf("http://%s", website.Proxy)})
+		}
+	}
+	return nil
+}

backend/configs/system.go

@@ -23,6 +23,7 @@ type System struct {
 	Language           string `mapstructure:"language"`
 	IsDemo             bool   `mapstructure:"is_demo"`
 	IsIntl             bool   `mapstructure:"is_intl"`
+	LicenseVerify      string `mapstructure:"license_verify"`
 	AppRepo            string `mapstructure:"app_repo"`
 	ChangeUserInfo     string `mapstructure:"change_user_info"`
 	OneDriveID         string `mapstructure:"one_drive_id"`

backend/constant/common.go

@@ -32,6 +32,11 @@ var WebUrlMap = map[string]struct{}{
 	"/apps/installed": {},
 	"/apps/upgrade":   {},
 
+	"/ai":       {},
+	"/ai/model": {},
+	"/ai/gpu":   {},
+	"/ai/mcp":   {},
+
 	"/containers":           {},
 	"/containers/container": {},
 	"/containers/image":     {},
@@ -113,11 +118,11 @@ var WebUrlMap = map[string]struct{}{
 	"/xpack/monitor/rank":      {},
 	"/xpack/monitor/log":       {},
 	"/xpack/tamper":            {},
-	"/xpack/gpu":               {},
 	"/xpack/alert/dashboard":   {},
 	"/xpack/alert/log":         {},
 	"/xpack/alert/setting":     {},
 	"/xpack/setting":           {},
+	"/xpack/app":               {},
 }
 
 var DynamicRoutes = []string{

backend/constant/dir.go

@@ -17,4 +17,5 @@ var (
 	RuntimeDir           = path.Join(DataDir, "runtime")
 	RecycleBinDir        = "/.1panel_clash"
 	SSLLogDir            = path.Join(global.CONF.System.DataDir, "log", "ssl")
+	McpDir               = path.Join(DataDir, "mcp")
 )

backend/constant/errs.go

@@ -182,3 +182,10 @@ var (
 	ErrAlertSync   = "ErrAlertSync"
 	ErrAlertRemote = "ErrAlertRemote"
 )
+
+// mobile app
+var (
+	ErrVerifyToken  = "ErrVerifyToken"
+	ErrInvalidToken = "ErrInvalidToken"
+	ErrExpiredToken = "ErrExpiredToken"
+)

backend/constant/runtime.go

@@ -13,6 +13,7 @@ const (
 	RuntimeStopped    = "stopped"
 	RuntimeUnhealthy  = "unhealthy"
 	RuntimeCreating   = "creating"
+	RuntimeReStarting = "restarting"
 
 	RuntimePHP    = "php"
 	RuntimeNode   = "node"

backend/constant/status.go

@@ -6,6 +6,8 @@ const (
 	StatusWaiting   = "Waiting"
 	StatusSuccess   = "Success"
 	StatusFailed    = "Failed"
+	StatusDeleted   = "Deleted"
+	StatusCanceled  = "Canceled"
 	StatusUploading = "Uploading"
 	StatusEnable    = "Enable"
 	StatusDisable   = "Disable"

backend/cron/job/app.go

@@ -13,8 +13,10 @@ func NewAppStoreJob() *app {
 
 func (a *app) Run() {
 	global.LOG.Info("AppStore scheduled task in progress ...")
-	if err := service.NewIAppService().SyncAppListFromRemote(); err != nil {
+	appService := service.NewIAppService()
+	if err := appService.SyncAppListFromRemote(); err != nil {
 		global.LOG.Errorf("AppStore sync failed %s", err.Error())
 	}
+	appService.SyncAppListFromLocal()
 	global.LOG.Info("AppStore scheduled task has completed")
 }

backend/i18n/lang/en.yaml

@@ -284,3 +284,13 @@ UserInfoPassHelp: "Tip: To change the password, you can execute the command: "
 DBConnErr: "Error: Failed to initialize database connection, {{ .err }}"
 SystemVersion: "version: "
 SystemMode: "mode: "
+
+#ai-tool
+ErrOpenrestyInstall: 'Please install Openresty first'
+ErrSSL: "Certificate content is empty, please check the certificate!"
+ErrSsePath: "SSE path is duplicated"
+
+#mobile app
+ErrVerifyToken: 'Token verification error, please reset and scan again.'
+ErrInvalidToken: 'Invalid token, please reset and scan again.'
+ErrExpiredToken: 'Token has expired, please reset and scan again.'

backend/i18n/lang/fa.yaml

@@ -1,63 +0,0 @@
-#cmd
-AppVersion: "Lotfan noskhe-ye barname ra vared konid"
-AppCommands: "Dasturat-e marbut be barname"
-AppInit: "Barname ra shoru' konid"
-AppKeyVal: "Kelid-e barname (faghat az zabane englisi poshtibani mikonad)"
-AppCreateFileErr: "Khalgh-e file {{ .name }} namovaffagh bud {{ .err }}"
-AppCreateDirErr: "Khalgh-e folder {{ .name }} namovaffagh bud {{ .err }}"
-AppMissKey: "Kelid-e barname mojood nist, az -k estefade konid"
-AppMissVersion: "Noskhe-ye barname mojood nist, az -v estefade konid"
-AppVersionExist: "Noskhe ghablan mojood ast!"
-AppCreateSuccessful: "Khalgh ba movaffaghiat anjam shod!"
-AppWriteErr: "Neveshtan file {{ .name }} namovaffagh bud {{ .err }}"
-SudoHelper: "Lotfan in eskript ra be onvane karbare root ya ba mojavez sudo ejra konid"
-ListenIPCommands: "IP goosh dadan ra taghir dahid"
-ListenIPv4: "Goosh dadan bar IPv4"
-ListenIPv6: "Goosh dadan bar IPv6"
-ListenChangeSuccessful: "Taghir movaffagh! Hala bar {{ .value }} goosh midahad"
-ResetCommands: "E'ade setadad etela'at-e system"
-ResetMFA: "Fa'al-sazi do marhale'i 1Panel ra laghv konid"
-ResetHttps: "Voroud HTTPS baraye 1Panel ra laghv konid"
-ResetEntrance: "Voroud amin 1Panel ra laghv konid"
-ResetIPs: "Mahdudiyat IP-haye mojaz 1Panel ra laghv konid"
-ResetDomain: "Sazgari domain 1Panel ra laghv konid"
-RestoreCommands: "Bargasht be khadamate 1Panel va data"
-RestoreNoSuchFile: "Hich file mojood baraye bargasht nist"
-RestoreStep1: "(1/5) Shoru' bargasht be khadamate 1Panel va data az directory {{ .name }} ..."
-RestoreStep2: "(2/5) Bargasht be binary 1Panel ba movaffaghiat anjam shod"
-RestoreStep3: "(3/5) Bargasht be script 1Panel ba movaffaghiat anjam shod"
-RestoreStep4: "(4/5) Bargasht be khadamat 1Panel ba movaffaghiat anjam shod"
-RestoreStep5: "(5/5) Bargasht be data 1Panel ba movaffaghiat anjam shod"
-RestoreSuccessful: "Bargasht ba movaffaghiat anjam shod! Khadamat dar hale restart ast, lotfan montazer bashid..."
-UpdateCommands: "Be'rooz resani etela'at-e panel"
-UpdateUser: "Be'rooz resani karbare panel"
-UpdatePassword: "Be'rooz resani ramz-e panel"
-UpdatePort: "Be'rooz resani port-e panel"
-UpdateUserNull: "Khatta: karbare panel khalist!"
-UpdateUserBlank: "Khatta: karbare panel shamel faseleh ast!"
-UpdateUserFormat: "Khatta: format-e karbare panel na dorost ast! Faghat az englisi, chine'i, adad va _, ba tool-e 3-30 poshtibani mikonad"
-UpdateUserErr: "Khatta: be'rooz resani karbare panel namovaffagh bud, {{ .err }}"
-UpdateSuccessful: "Be'rooz resani ba movaffaghiat anjam shod!"
-UpdateUserResult: "Karbare panel: {{ .name }}"
-UpdatePasswordRead: "Khatta: khatayi dar khandan etela'at-e ramz-e panel, {{ .err }}"
-UpdatePasswordNull: "Khatta: ramz-e panel khalist!"
-UpdateUPasswordBlank: "Khatta: ramz-e panel shamel faseleh ast!"
-UpdatePasswordFormat: "Khatta: ramz-e panel faghat az harf, adad, karakter-haye vizhe !@#$%*_,.? ba tool-e 8-30 poshtibani mikonad!"
-UpdatePasswordLen: "Khatta: lotfan ramzi bishtar az 6 karakter vared konid!"
-UpdatePasswordRe: "Teyid-e ramz:"
-UpdatePasswordErr: "Khatta: be'rooz resani ramz-e panel namovaffagh bud, {{ .err }}"
-UpdatePasswordSame: "Khatta: do ramz ba ham yeksan nistand, lotfan barrasi konid va dobare talash konid!"
-UpdatePasswordResult: "Ramz-e panel: {{ .name }}"
-UpdatePortFormat: "Khatta: shomareye port bayad bein 1 ta 65535 bashad!"
-UpdatePortUsed: "Khatta: shomareye port ghablan estefade shode ast, lotfan barrasi konid va dobare talash konid!"
-UpdatePortErr: "Khatta: be'rooz resani port-e panel namovaffagh bud, {{ .err }}"
-UpdatePortResult: "Port-e panel: {{ .name }}"
-UpdatePortFirewallAdd: "Ezafe kardane ghanoun-e port firewall namovaffagh bud, {{ .err }}, lotfan port {{ .name }} ra be dast az qavaneen firewall ezafe konid."
-UpdatePortFirewallDel: "Khatta: hazf-e port firewall namovaffagh bud, {{ .err }}"
-UpdatePortFirewallReload: "Reload firewall namovaffagh bud, {{ .err }}, lotfan firewall ra be dast reload konid."
-UserInfo: "Daryaft etela'at-e panel"
-UserInfoAddr: "Address-e panel: "
-UserInfoPassHelp: "Nokte: baraye taghiri ramz, mitavanid dastur zir ra anjam dahid: "
-DBConnErr: "Khatta: etesal be database namovaffagh bud, {{ .err }}"
-SystemVersion: "noskhe: "
-SystemMode: "halat: "

backend/i18n/lang/ja.yaml

@@ -1,17 +1,17 @@
-ErrInvalidParams: "リクエストパラメーターエラー：{{.Detail}}"
-ErrTokenParse: "トークン生成エラー：{{.Detail}}"
+ErrInvalidParams: "リクエストパラメーターエラー: {{.Detail}}"
+ErrTokenParse: "トークン生成エラー: {{.Detail}}"
 ErrInitialPassword: "初期パスワードエラー"
-ErrInternalServer: "サービス内部エラー：{{.Detail}}"
+ErrInternalServer: "サービス内部エラー: {{.Detail}}"
 ErrRecordExist: "レコードはすでに存在します"
 ErrRecordNotFound: "記録が見つかりません"
-ErrStructTransform: "タイプ変換障害：{{.Detail}}"
-ErrNotLogin: "ユーザーはログインしません：{{.Detail}}"
-ErrPasswordExpired: "現在のパスワードが期限切れになっています：{{.Detail}}"
-ErrNotSupportType: "システムは現在のタイプをサポートしていません：{{.Detail}}"
-ErrApiConfigStatusInvalid: "APIインターフェイスアクセス禁止：{{.Detail}}"
-ErrApiConfigKeyInvalid: "APIインターフェイスキーエラー：{{.Detail}}"
-ErrApiConfigIPInvalid: "APIインターフェイスIPはホワイトリストにありません：{{.Detail}}"
-ErrApiConfigDisable: "このインターフェイスは、APIインターフェイスコールの使用を禁止しています：{{.Detail}}"
+ErrStructTransform: "タイプ変換障害: {{.Detail}}"
+ErrNotLogin: "ユーザーはログインしません: {{.Detail}}"
+ErrPasswordExpired: "現在のパスワードが期限切れになっています: {{.Detail}}"
+ErrNotSupportType: "システムは現在のタイプをサポートしていません: {{.Detail}}"
+ErrApiConfigStatusInvalid: "APIインターフェイスアクセス禁止: {{.Detail}}"
+ErrApiConfigKeyInvalid: "APIインターフェイスキーエラー: {{.Detail}}"
+ErrApiConfigIPInvalid: "APIインターフェイスIPはホワイトリストにありません: {{.Detail}}"
+ErrApiConfigDisable: "このインターフェイスは、APIインターフェイスコールの使用を禁止しています: {{.Detail}}"
 
 #common
 ErrNameIsExist: "名前はすでに存在しています"
@@ -92,10 +92,10 @@ ErrDomainIsExist: "ドメインはすでに存在しています"
 ErrAliasIsExist: "エイリアスはすでに存在しています"
 ErrAppDelete: '他のウェブサイトはこのアプリを使用します'
 ErrGroupIsUsed: "グループは使用されており、削除することはできません"
-ErrBackupMatch: "バックアップファイルは、ウェブサイトの現在の部分的なデータと一致しません：{{.Detail}}"
+ErrBackupMatch: "バックアップファイルは、ウェブサイトの現在の部分的なデータと一致しません: {{.Detail}}"
 ErrBackupExist: 'バックアップファイルは、存在しない元のデータの一部に対応しています。{{.Detail}}'
 ErrPHPResource: 'ローカルランタイムはスイッチングをサポートしません！'
-ErrPathPermission: 'インデックスディレクトリで1000：1000以外のアクセス許可を持つフォルダーが検出されたため、Webサイトにアクセスするとアクセスが拒否された場合があります。上の[保存]ボタンをクリックしてください'
+ErrPathPermission: 'インデックスディレクトリで1000: 1000以外のアクセス許可を持つフォルダーが検出されたため、Webサイトにアクセスするとアクセスが拒否された場合があります。上の[保存]ボタンをクリックしてください'
 ErrDomainIsUsed: "ドメインはすでにWebサイトで使用されています{{.Name}}"
 ErrDomainFormat: "{{.name}}ドメイン形式エラー"
 ErrDefaultAlias: "デフォルトは予約済みのコード名です。別のコード名を使用してください"
@@ -124,7 +124,7 @@ ErrDeleteCAWithSSL: "現在の組織の下に発行された証明書があり
 ErrDeleteWithPanelSSL: "パネルSSL構成はこの証明書を使用しており、削除できません"
 ErrDefaultCA: "デフォルトの証明書当局は削除できません"
 ApplyWebSiteSSLLog: "{{.name}} Webサイト証明書の更新を開始します"
-ErrUpdateWebsiteSSL: "{{.name}}ウェブサイトは証明書の更新に失敗しました：{{.err}}"
+ErrUpdateWebsiteSSL: "{{.name}}ウェブサイトは証明書の更新に失敗しました: {{.err}}"
 ApplyWebSiteSSLSuccess: "ウェブサイトの証明書を正常に更新します"
 ErrExecShell: "スクリプトの実行に失敗した{{.err}}"
 ExecShellStart: "スクリプトの実行を開始します"
@@ -146,7 +146,7 @@ ErrTypeOfRedis: "回復ファイルのタイプは、現在の永続性モード
 ErrInUsed: "{{.Detail}}が使用されており、削除できません"
 ErrObjectInUsed: "このオブジェクトは使用されており、削除することはできません"
 ErrPortRules: "ポートの数が一致しません。再入力してください！"
-ErrPgImagePull: "画像プルタイムアウト。画像の加速を構成するか、Postgres：16.0-Alpine画像を手動で引いて、再試行してください"
+ErrPgImagePull: "画像プルタイムアウト。画像の加速を構成するか、Postgres: 16.0-Alpine画像を手動で引いて、再試行してください"
 
 #runtime
 ErrDirNotFound: "ビルドフォルダーは存在しません！ファイルの整合性を確認してください！"
@@ -253,31 +253,42 @@ UpdateCommands: "パネル情報を更新します"
 UpdateUser: "パネルユーザーを更新します"
 UpdatePassword: "パスワードを更新します"
 UpdatePort: "パネルポートを更新します"
-UpdateUserNull: "エラー：パネルユーザーは空です！"
-UpdateUserBlank: "エラー：パネルユーザーにはスペースが含まれています！"
-UpdateUserFormat: "エラー：無効なパネルユーザー形式！英語、中国語、数字、_、長さ3〜30のみをサポートしています"
-UpdateUserErr: "エラー：パネルユーザーの更新に失敗しました{{.err}}"
+UpdateUserNull: "エラー: パネルユーザーは空です！"
+UpdateUserBlank: "エラー: パネルユーザーにはスペースが含まれています！"
+UpdateUserFormat: "エラー: 無効なパネルユーザー形式！英語、中国語、数字、_、長さ3〜30のみをサポートしています"
+UpdateUserErr: "エラー: パネルユーザーの更新に失敗しました{{.err}}"
 UpdateSuccessful: "更新成功！"
-UpdateUserResult: "パネルユーザー：{{.name}}"
-UpdatePasswordRead: "エラー：パネルパスワード情報の読み取りに失敗しました、{{.err}}"
-UpdatePasswordNull: "エラー：パネルパスワードは空です！"
-UpdateUPasswordBlank: "エラー：パスワードにはスペースが含まれています！"
-UpdatePasswordFormat: "エラー：パネルパスワードは、文字、数字、特殊文字のみをサポートします！@＃$％*_、。、、長さ8-30！"
-UpdatePasswordLen: "エラー：6文字より長くパスワードを入力してください！"
-UpdatePasswordRe: "パスワードを認証する："
-UpdatePasswordErr: "エラー：{{.err}}のパスワードの更新に失敗しました"
-UpdatePasswordSame: "エラー：2つのパスワードが一致しません。チェックして再試行してください！"
-UpdatePasswordResult: "パネルパスワード：{{.name}}"
-UpdatePortFormat: "エラー：入力ポート番号は1〜65535でなければなりません！"
-UpdatePortUsed: "エラー：ポート番号はすでに使用されています。チェックして再試行してください！"
-UpdatePortErr: "エラー：パネルポートの更新に失敗しました{{.err}}"
-UpdatePortResult: "パネルポート：{{.name}}"
+UpdateUserResult: "パネルユーザー: {{.name}}"
+UpdatePasswordRead: "エラー: パネルパスワード情報の読み取りに失敗しました、{{.err}}"
+UpdatePasswordNull: "エラー: パネルパスワードは空です！"
+UpdateUPasswordBlank: "エラー: パスワードにはスペースが含まれています！"
+UpdatePasswordFormat: "エラー: パネルパスワードは、文字、数字、特殊文字のみをサポートします！@＃$％*_、。、、長さ8-30！"
+UpdatePasswordLen: "エラー: 6文字より長くパスワードを入力してください！"
+UpdatePasswordRe: "パスワードを認証する: "
+UpdatePasswordErr: "エラー: {{.err}}のパスワードの更新に失敗しました"
+UpdatePasswordSame: "エラー: 2つのパスワードが一致しません。チェックして再試行してください！"
+UpdatePasswordResult: "パネルパスワード: {{.name}}"
+UpdatePortFormat: "エラー: 入力ポート番号は1〜65535でなければなりません！"
+UpdatePortUsed: "エラー: ポート番号はすでに使用されています。チェックして再試行してください！"
+UpdatePortErr: "エラー: パネルポートの更新に失敗しました{{.err}}"
+UpdatePortResult: "パネルポート: {{.name}}"
 UpdatePortFirewallAdd: "ファイアウォールポートルールの追加に失敗した{{.err}}、ファイアウォールルールに{{.name}}ポートを手動で追加してください。"
-UpdatePortFirewallDel: "エラー：ファイアウォールポートの削除に失敗しました、{{.err}}"
+UpdatePortFirewallDel: "エラー: ファイアウォールポートの削除に失敗しました、{{.err}}"
 UpdatePortFirewallReload: "ファイアウォールのリロードに失敗しました{{.err}}、ファイアウォールを手動でリロードしてください。"
 UserInfo: "パネル情報を取得します"
-UserInfoAddr: "パネルアドレス："
-UserInfoPassHelp: "ヒント：パスワードを変更するには、コマンドを実行できます。"
-DBConnErr: "エラー：データベース接続の初期化に失敗しました、{{.err}}"
-SystemVersion: "バージョン："
-SystemMode: "モード："
+UserInfoAddr: "パネルアドレス: "
+UserInfoPassHelp: "ヒント: パスワードを変更するには、コマンドを実行できます。"
+DBConnErr: "エラー: データベース接続の初期化に失敗しました、{{.err}}"
+SystemVersion: "バージョン: "
+SystemMode: "モード: "
+
+#ai-tool
+ErrOpenrestyInstall: 'まず Openresty をインストールしてください'
+ErrSSL: "証明書の内容が空です。証明書を確認してください！"
+ErrSsePath: "SSE パスが重複しています"
+
+
+#mobile app
+ErrVerifyToken: 'トークンの検証エラーです。リセット後、再度QRコードをスキャンしてください。'
+ErrInvalidToken: '無効なトークンです。リセット後、再度QRコードをスキャンしてください。'
+ErrExpiredToken: 'トークンの有効期限が切れました。リセット後、再度QRコードをスキャンしてください。'

backend/i18n/lang/ko.yaml

@@ -284,3 +284,14 @@ UserInfoPassHelp: "팁: 비밀번호를 변경하려면 다음 명령어를 실
 DBConnErr: "오류: 데이터베이스 연결 초기화 실패 {{ .err }}"
 SystemVersion: "버전: "
 SystemMode: "모드: "
+
+#ai-tool
+ErrOpenrestyInstall: '먼저 Openresty를 설치하세요'
+ErrSSL: "인증서 내용이 비어 있습니다. 인증서를 확인하세요!"
+ErrSsePath: "SSE 경로가 중복되었습니다"
+
+
+#mobile app
+ErrVerifyToken: '토큰 검증 오류가 발생했습니다. 재설정 후 다시 스캔해 주세요.'
+ErrInvalidToken: '유효하지 않은 토큰입니다. 재설정 후 다시 스캔해 주세요.'
+ErrExpiredToken: '토큰이 만료되었습니다. 재설정 후 다시 스캔해 주세요.'

backend/i18n/lang/ms.yml

@@ -283,3 +283,13 @@ UserInfoPassHelp: "Petua: Untuk menukar kata laluan, anda boleh menjalankan arah
 DBConnErr: "Ralat: Gagal memulakan sambungan pangkalan data, {{ .err }}"
 SystemVersion: "Versi: "
 SystemMode: "Mod: "
+
+#ai-tool
+ErrOpenrestyInstall: 'Sila pasang Openresty terlebih dahulu'
+ErrSSL: "Kandungan sijil kosong, sila periksa sijil!"
+ErrSsePath: "Laluan SSE bertindan"
+
+#mobile app
+ErrVerifyToken: 'Ralat pengesahan token, sila tetapkan semula dan imbas semula.'
+ErrInvalidToken: 'Token tidak sah, sila tetapkan semula dan imbas semula.'
+ErrExpiredToken: 'Token telah tamat tempoh, sila tetapkan semula dan imbas semula.'

backend/i18n/lang/pt-BR.yaml

@@ -280,4 +280,14 @@ UserInfoAddr: "Endereço do painel: "
 UserInfoPassHelp: "Dica: Para alterar a senha, você pode executar o comando: "
 DBConnErr: "Erro: Falha ao inicializar a conexão com o banco de dados, {{ .err }}"
 SystemVersion: "versão: "
-SystemMode: "modo: "
+SystemMode: "modo: "
+
+#ai-tool
+ErrOpenrestyInstall: 'Por favor, instale o Openresty primeiro'
+ErrSSL: "O conteúdo do certificado está vazio, por favor, verifique o certificado!"
+ErrSsePath: "Caminho SSE duplicado"
+
+#mobile app
+ErrVerifyToken: 'Erro de verificação do token, por favor, reinicie e escaneie novamente.'
+ErrInvalidToken: 'Token inválido, por favor, reinicie e escaneie novamente.'
+ErrExpiredToken: 'O token expirou, por favor, reinicie e escaneie novamente.'

backend/i18n/lang/pt.yaml

@@ -1,63 +0,0 @@
-#cmd
-AppVersion: "Versão do aplicativo"
-AppCommands: "Comandos relacionados ao aplicativo"
-AppInit: "Inicializar aplicativo"
-AppKeyVal: "Chave do aplicativo (suporta apenas inglês)"
-AppCreateFileErr: "Falha na criação do arquivo {{ .name }} {{ .err }}"
-AppCreateDirErr: "Falha na criação da pasta {{ .name }} {{ .err }}"
-AppMissKey: "Chave do aplicativo ausente, use -k para especificar"
-AppMissVersion: "Versão do aplicativo ausente, use -v para especificar"
-AppVersionExist: "Versão já existente!"
-AppCreateSuccessful: "Criação bem-sucedida!"
-AppWriteErr: "Falha na gravação do arquivo {{ .name }} {{ .err }}"
-SudoHelper: "Por favor, use {{ .cmd }} ou troque para o usuário root"
-ListenIPCommands: "Alterar IP de escuta"
-ListenIPv4: "Escutar no IPv4"
-ListenIPv6: "Escutar no IPv6"
-ListenChangeSuccessful: "Alteração bem-sucedida! Agora escutando em {{ .value }}"
-ResetCommands: "Redefinir informações do sistema"
-ResetMFA: "Cancelar autenticação de dois fatores do 1Panel"
-ResetHttps: "Cancelar login HTTPS do 1Panel"
-ResetEntrance: "Cancelar entrada segura do 1Panel"
-ResetIPs: "Cancelar restrições de IP autorizados do 1Panel"
-ResetDomain: "Cancelar vinculação de domínio do 1Panel"
-RestoreCommands: "Restaurar serviço e dados do 1Panel"
-RestoreNoSuchFile: "Nenhum arquivo disponível para restauração"
-RestoreStep1: "(1/5) Iniciando a restauração do serviço e dados do 1Panel a partir do diretório {{ .name }}..."
-RestoreStep2: "(2/5) Restauração do binário do 1Panel bem-sucedida"
-RestoreStep3: "(3/5) Restauração do script do 1Panel bem-sucedida"
-RestoreStep4: "(4/5) Restauração do serviço do 1Panel bem-sucedida"
-RestoreStep5: "(5/5) Restauração dos dados do 1Panel bem-sucedida"
-RestoreSuccessful: "Restauração bem-sucedida! Reiniciando o serviço, aguarde..."
-UpdateCommands: "Atualizar informações do painel"
-UpdateUser: "Atualizar usuário do painel"
-UpdatePassword: "Atualizar senha do painel"
-UpdatePort: "Atualizar porta do painel"
-UpdateUserNull: "Erro: usuário do painel está vazio!"
-UpdateUserBlank: "Erro: usuário do painel contém espaços!"
-UpdateUserFormat: "Erro: Formato de usuário inválido! Aceita apenas inglês, chinês, números e _, comprimento de 3-30"
-UpdateUserErr: "Erro: Falha ao atualizar usuário do painel, {{ .err }}"
-UpdateSuccessful: "Atualização bem-sucedida!"
-UpdateUserResult: "Usuário do painel: {{ .name }}"
-UpdatePasswordRead: "Erro: Falha ao ler informações da senha do painel, {{ .err }}"
-UpdatePasswordNull: "Erro: Senha do painel está vazia!"
-UpdateUPasswordBlank: "Erro: Senha do painel contém espaços!"
-UpdatePasswordFormat: "Erro: A senha do painel aceita apenas letras, números, caracteres especiais !@#$%*_,.?, comprimento de 8-30!"
-UpdatePasswordLen: "Erro: Por favor, insira uma senha com mais de 6 caracteres!"
-UpdatePasswordRe: "Confirmar senha:"
-UpdatePasswordErr: "Erro: Falha ao atualizar senha do painel, {{ .err }}"
-UpdatePasswordSame: "Erro: As duas senhas não coincidem, por favor, verifique e tente novamente!"
-UpdatePasswordResult: "Senha do painel: {{ .name }}"
-UpdatePortFormat: "Erro: O número da porta deve estar entre 1 e 65535!"
-UpdatePortUsed: "Erro: O número da porta já está em uso, por favor, verifique e tente novamente!"
-UpdatePortErr: "Erro: Falha ao atualizar a porta do painel, {{ .err }}"
-UpdatePortResult: "Porta do painel: {{ .name }}"
-UpdatePortFirewallAdd: "Falha ao adicionar regra de porta no firewall, {{ .err }}, adicione manualmente a porta {{ .name }} às regras do firewall."
-UpdatePortFirewallDel: "Erro: Falha ao excluir porta do firewall, {{ .err }}"
-UpdatePortFirewallReload: "Falha ao recarregar o firewall, {{ .err }}, recarregue o firewall manualmente."
-UserInfo: "Obter informações do painel"
-UserInfoAddr: "Endereço do painel: "
-UserInfoPassHelp: "Dica: Para alterar a senha, execute o comando: "
-DBConnErr: "Erro: Falha ao inicializar conexão com o banco de dados, {{ .err }}"
-SystemVersion: "versão: "
-SystemMode: "modo: "

backend/i18n/lang/ru.yaml

@@ -284,3 +284,13 @@ UserInfoPassHelp: "Подсказка: чтобы изменить пароль,
 DBConnErr: "Ошибка: не удалось инициализировать подключение к базе данных, {{ .err }}"
 SystemVersion: "версия: "
 SystemMode: "режим: "
+
+#ai-tool
+ErrOpenrestyInstall: "Пожалуйста, установите Openresty сначала"
+ErrSSL: "Содержимое сертификата пустое, пожалуйста, проверьте сертификат!"
+ErrSsePath: "Путь SSE дублируется"
+
+#mobile app
+ErrVerifyToken: 'шибка проверки токена, пожалуйста, сбросьте и отсканируйте снова.'
+ErrInvalidToken: 'Неверный токен, пожалуйста, сбросьте и отсканируйте снова.'
+ErrExpiredToken: 'Токен истек, пожалуйста, сбросьте и отсканируйте снова.'

backend/i18n/lang/zh-Hant.yaml

@@ -8,7 +8,7 @@ ErrStructTransform: "類型轉換失敗: {{ .detail }}"
 ErrNotLogin: "用戶未登入: {{ .detail }}"
 ErrPasswordExpired: "目前密碼已過期: {{ .detail }}"
 ErrNotSupportType: "系統暫不支援目前類型: {{ .detail }}"
-ErrApiConfigStatusInvalid: "API 介面禁止訪問: {{ .detail }}"
+ErrApiConfigStatusInvalid: "API 介面禁止瀏覽: {{ .detail }}"
 ErrApiConfigKeyInvalid: "API 介面金鑰錯誤: {{ .detail }}"
 ErrApiConfigIPInvalid: "呼叫 API 介面 IP 不在白名單: {{ .detail }}"
 ErrApiConfigDisable: "此介面禁止使用 API 介面呼叫: {{ .detail }}"
@@ -243,7 +243,7 @@ ResetMFA: "取消 1Panel 兩步驗證"
 ResetHttps: "取消 1Panel https 方式登入"
 ResetEntrance: "取消 1Panel 安全入口"
 ResetIPs: "取消 1Panel 授權 IP 限制"
-ResetDomain: "取消 1Panel 訪問域名綁定"
+ResetDomain: "取消 1Panel 瀏覽域名綁定"
 RestoreCommands: "轉返 1Panel 服務及資料"
 RestoreNoSuchFile: "暫無可轉返文件"
 RestoreStep1: "（1/5）開始從 {{ .name }} 目錄轉返 1Panel 服務及資料... "
@@ -256,31 +256,41 @@ UpdateCommands: "修改面板資訊"
 UpdateUser: "修改面板用戶"
 UpdatePassword: "修改面板密碼"
 UpdatePort: "修改面板埠"
-UpdateUserNull: "錯誤：輸入面板用戶為空！"
-UpdateUserBlank: "錯誤：輸入面板用戶中包含空格字元！"
-UpdateUserFormat: "錯誤：輸入面板用戶錯誤！僅支援英文、中文、數字和_，長度3-30"
-UpdateUserErr: "錯誤：面板用戶修改失敗，{{ .err }}"
+UpdateUserNull: "錯誤: 輸入面板用戶為空！"
+UpdateUserBlank: "錯誤: 輸入面板用戶中包含空格字元！"
+UpdateUserFormat: "錯誤: 輸入面板用戶錯誤！僅支援英文、中文、數字和_，長度3-30"
+UpdateUserErr: "錯誤: 面板用戶修改失敗，{{ .err }}"
 UpdateSuccessful: "修改成功！"
-UpdateUserResult: "面板用戶：{{ .name }}"
-UpdatePasswordRead: "錯誤：面板密碼資訊讀取錯誤，{{ .err }}"
-UpdatePasswordNull: "錯誤：輸入面板密碼為空！"
-UpdateUPasswordBlank: "錯誤：輸入面板密碼中包含空格字元！"
-UpdatePasswordFormat: "錯誤：面板密碼僅支援字母、數字、特殊字元（!@#$%*_,.?），長度 8-30 位！"
-UpdatePasswordLen: "錯誤：請輸入 6 位以上密碼！"
-UpdatePasswordRe: "確認密碼："
-UpdatePasswordErr: "錯誤：面板密碼修改失敗，{{ .err }}"
-UpdatePasswordSame: "錯誤：兩次密碼不匹配，請檢查後重試！"
-UpdatePasswordResult: "面板密碼：{{ .name }}"
-UpdatePortFormat: "錯誤：輸入的埠號必須在 1 到 65535 之間！"
-UpdatePortUsed: "錯誤：該埠號正被佔用，請檢查後重試！"
-UpdatePortErr: "錯誤：面板埠修改失敗，{{ .err }}"
-UpdatePortResult: "面板埠：{{ .name }}"
+UpdateUserResult: "面板用戶: {{ .name }}"
+UpdatePasswordRead: "錯誤: 面板密碼資訊讀取錯誤，{{ .err }}"
+UpdatePasswordNull: "錯誤: 輸入面板密碼為空！"
+UpdateUPasswordBlank: "錯誤: 輸入面板密碼中包含空格字元！"
+UpdatePasswordFormat: "錯誤: 面板密碼僅支援字母、數字、特殊字元（!@#$%*_,.?），長度 8-30 位！"
+UpdatePasswordLen: "錯誤: 請輸入 6 位以上密碼！"
+UpdatePasswordRe: "確認密碼: "
+UpdatePasswordErr: "錯誤: 面板密碼修改失敗，{{ .err }}"
+UpdatePasswordSame: "錯誤: 兩次密碼不匹配，請檢查後重試！"
+UpdatePasswordResult: "面板密碼: {{ .name }}"
+UpdatePortFormat: "錯誤: 輸入的埠號必須在 1 到 65535 之間！"
+UpdatePortUsed: "錯誤: 該埠號正被佔用，請檢查後重試！"
+UpdatePortErr: "錯誤: 面板埠修改失敗，{{ .err }}"
+UpdatePortResult: "面板埠: {{ .name }}"
 UpdatePortFirewallAdd: "新增防火牆埠規則失敗，{{ .err }}，請您手動將 {{ .name }} 埠新增至防火牆規則中。"
-UpdatePortFirewallDel: "錯誤：防火牆埠刪除失敗，{{ .err }}"
+UpdatePortFirewallDel: "錯誤: 防火牆埠刪除失敗，{{ .err }}"
 UpdatePortFirewallReload: "防火牆重載失敗，{{ .err }}，請您手動重載防火牆。"
 UserInfo: "取得面板資訊"
-UserInfoAddr: "面板地址："
-UserInfoPassHelp: "提示：修改密碼可執行指令："
-DBConnErr: "錯誤：初始化資料庫連線失敗，{{ .err }}"
-SystemVersion: "版本："
-SystemMode: "模式："
+UserInfoAddr: "面板地址: "
+UserInfoPassHelp: "提示: 修改密碼可執行指令: "
+DBConnErr: "錯誤: 初始化資料庫連線失敗，{{ .err }}"
+SystemVersion: "版本: "
+SystemMode: "模式: "
+
+#ai-tool
+ErrOpenrestyInstall: "請先安裝 Openresty"
+ErrSSL: "證書內容為空，請檢查證書！"
+ErrSsePath: "SSE 路徑重複"
+
+#mobile app
+ErrVerifyToken: '令牌驗證錯誤，請重置後再次掃碼'
+ErrInvalidToken: '無效的令牌，請重置後再次掃碼'
+ErrExpiredToken: '令牌過期，請重置後再次掃碼'

backend/i18n/lang/zh.yaml

@@ -256,31 +256,41 @@ UpdateCommands: "修改面板信息"
 UpdateUser: "修改面板用户"
 UpdatePassword: "修改面板密码"
 UpdatePort: "修改面板端口"
-UpdateUserNull: "错误：输入面板用户为空！"
-UpdateUserBlank: "错误：输入面板用户中包含空格字符！"
-UpdateUserFormat: "错误：输入面板用户错误！仅支持英文、中文、数字和_，长度3-30"
-UpdateUserErr: "错误：面板用户修改失败，{{ .err }}"
+UpdateUserNull: "错误: 输入面板用户为空！"
+UpdateUserBlank: "错误: 输入面板用户中包含空格字符！"
+UpdateUserFormat: "错误: 输入面板用户错误！仅支持英文、中文、数字和_，长度3-30"
+UpdateUserErr: "错误: 面板用户修改失败，{{ .err }}"
 UpdateSuccessful: "修改成功！"
-UpdateUserResult: "面板用户：{{ .name }}"
-UpdatePasswordRead: "错误：面板密码信息读取错误，{{ .err }}"
-UpdatePasswordNull: "错误：输入面板密码为空！"
-UpdateUPasswordBlank: "错误：输入面板密码中包含空格字符！"
-UpdatePasswordFormat: "错误：面板密码仅支持字母、数字、特殊字符（!@#$%*_,.?），长度 8-30 位！"
-UpdatePasswordLen: "错误：请输入 6 位以上密码！"
-UpdatePasswordRe: "确认密码："
-UpdatePasswordErr: "错误：面板密码修改失败，{{ .err }}"
-UpdatePasswordSame: "错误：两次密码不匹配，请检查后重试！"
-UpdatePasswordResult: "面板密码：{{ .name }}"
-UpdatePortFormat: "错误：输入的端口号必须在 1 到 65535 之间！"
-UpdatePortUsed: "错误：该端口号正被占用，请检查后重试！"
-UpdatePortErr: "错误：面板端口修改失败，{{ .err }}"
-UpdatePortResult: "面板端口：{{ .name }}"
+UpdateUserResult: "面板用户: {{ .name }}"
+UpdatePasswordRead: "错误: 面板密码信息读取错误，{{ .err }}"
+UpdatePasswordNull: "错误: 输入面板密码为空！"
+UpdateUPasswordBlank: "错误: 输入面板密码中包含空格字符！"
+UpdatePasswordFormat: "错误: 面板密码仅支持字母、数字、特殊字符（!@#$%*_,.?），长度 8-30 位！"
+UpdatePasswordLen: "错误: 请输入 6 位以上密码！"
+UpdatePasswordRe: "确认密码: "
+UpdatePasswordErr: "错误: 面板密码修改失败，{{ .err }}"
+UpdatePasswordSame: "错误: 两次密码不匹配，请检查后重试！"
+UpdatePasswordResult: "面板密码: {{ .name }}"
+UpdatePortFormat: "错误: 输入的端口号必须在 1 到 65535 之间！"
+UpdatePortUsed: "错误: 该端口号正被占用，请检查后重试！"
+UpdatePortErr: "错误: 面板端口修改失败，{{ .err }}"
+UpdatePortResult: "面板端口: {{ .name }}"
 UpdatePortFirewallAdd: "添加防火墙端口规则失败，{{ .err }}，请您手动将 {{ .name }} 端口添加至防火墙规则中。"
-UpdatePortFirewallDel: "错误：防火墙端口删除失败，{{ .err }}"
+UpdatePortFirewallDel: "错误: 防火墙端口删除失败，{{ .err }}"
 UpdatePortFirewallReload: "防火墙重载失败，{{ .err }}，请您手动重载防火墙。"
 UserInfo: "获取面板信息"
-UserInfoAddr: "面板地址："
-UserInfoPassHelp: "提示：修改密码可执行命令："
-DBConnErr: "错误：初始化数据库连接失败，{{ .err }}"
-SystemVersion: "版本："
-SystemMode: "模式："
+UserInfoAddr: "面板地址: "
+UserInfoPassHelp: "提示: 修改密码可执行命令: "
+DBConnErr: "错误: 初始化数据库连接失败，{{ .err }}"
+SystemVersion: "版本: "
+SystemMode: "模式: "
+
+#ai-tool
+ErrOpenrestyInstall: '请先安装 Openresty'
+ErrSSL: "证书内容为空，请检查证书!"
+ErrSsePath: "SSE 路径重复"
+
+#mobile app
+ErrVerifyToken: '令牌验证错误，请重置后再次扫码'
+ErrInvalidToken: '无效的令牌，请重置后再次扫码'
+ErrExpiredToken: '令牌过期，请重置后再次扫码'

backend/init/app/app.go

@@ -23,8 +23,11 @@ func Init() {
 
 	constant.SSLLogDir = path.Join(global.CONF.System.DataDir, "log", "ssl")
 
+	constant.McpDir = path.Join(constant.DataDir, "mcp")
+
 	dirs := []string{constant.DataDir, constant.ResourceDir, constant.AppResourceDir, constant.AppInstallDir,
-		global.CONF.System.Backup, constant.RuntimeDir, constant.LocalAppResourceDir, constant.RemoteAppResourceDir, constant.SSLLogDir}
+		global.CONF.System.Backup, constant.RuntimeDir, constant.LocalAppResourceDir, constant.RemoteAppResourceDir,
+		constant.SSLLogDir, constant.McpDir}
 
 	fileOp := files.NewFileOp()
 	for _, dir := range dirs {

backend/init/hook/hook.go

@@ -84,9 +84,19 @@ func Init() {
 		global.CONF.System.ApiKeyValidityTime = apiKeyValidityTimeSetting.Value
 	}
 
+	if global.CONF.System.LicenseVerify == "" {
+		licenseVerify, err := settingRepo.Get(settingRepo.WithByKey("LicenseVerify"))
+		if err != nil {
+			global.LOG.Errorf("load service license verify from setting failed, err: %v", err)
+		}
+		global.CONF.System.LicenseVerify = licenseVerify.Value
+	}
+	handleLicenseVerify(global.CONF.System.LicenseVerify, settingRepo)
+
 	handleUserInfo(global.CONF.System.ChangeUserInfo, settingRepo)
 
 	handleCronjobStatus()
+	handleOllamaModelStatus()
 	handleSnapStatus()
 	loadLocalDir()
 	initDir()
@@ -150,6 +160,11 @@ func handleSnapStatus() {
 	}
 }
 
+func handleOllamaModelStatus() {
+	message := "the task was interrupted due to the restart of the 1panel service"
+	_ = global.DB.Model(&model.OllamaModel{}).Where("status = ?", constant.StatusWaiting).Updates(map[string]interface{}{"status": constant.StatusCanceled, "message": message}).Error
+}
+
 func handleCronjobStatus() {
 	var jobRecords []model.JobRecords
 	_ = global.DB.Where("status = ?", constant.StatusWaiting).Find(&jobRecords).Error
@@ -201,6 +216,12 @@ func loadLocalDir() {
 	global.LOG.Errorf("error type dir: %T", varMap["dir"])
 }
 
+func handleLicenseVerify(licenseVerify string, settingRepo repo.ISettingRepo) {
+	if err := settingRepo.Update("LicenseVerify", licenseVerify); err != nil {
+		global.LOG.Fatalf("init license verify before start failed, err: %v", err)
+	}
+}
+
 func handleUserInfo(tags string, settingRepo repo.ISettingRepo) {
 	if len(tags) == 0 {
 		return

backend/init/migration/migrate.go

@@ -102,6 +102,12 @@ func Init() {
 
 		migrations.UpdateAppTag,
 		migrations.UpdateApp,
+		migrations.AddOllamaModel,
+		migrations.AddAppMenu,
+		migrations.AddAppPanelName,
+		migrations.AddLicenseVerify,
+
+		migrations.AddMcpServer,
 	})
 	if err := m.Migrate(); err != nil {
 		global.LOG.Error(err)

backend/init/migration/migrations/v_1_10.go

@@ -372,7 +372,7 @@ var UpdateAppTag = &gormigrate.Migration{
 }
 
 var UpdateApp = &gormigrate.Migration{
-	ID: "20250114-update-app",
+	ID: "20250213-update-app",
 	Migrate: func(tx *gorm.DB) error {
 		if err := tx.AutoMigrate(&model.App{}); err != nil {
 			return err
@@ -380,3 +380,92 @@ var UpdateApp = &gormigrate.Migration{
 		return nil
 	},
 }
+
+var AddOllamaModel = &gormigrate.Migration{
+	ID: "20250218-add-ollama-model",
+	Migrate: func(tx *gorm.DB) error {
+		if err := tx.AutoMigrate(&model.OllamaModel{}); err != nil {
+			return err
+		}
+		return nil
+	},
+}
+
+var AddAppMenu = &gormigrate.Migration{
+	ID: "20250217-update-xpack-hide-menu",
+	Migrate: func(tx *gorm.DB) error {
+		var (
+			setting model.Setting
+			menu    dto.XpackHideMenu
+		)
+
+		tx.Model(&model.Setting{}).Where("key = ?", "XpackHideMenu").First(&setting)
+
+		if err := json.Unmarshal([]byte(setting.Value), &menu); err != nil {
+			return err
+		}
+
+		var newChildren []dto.XpackHideMenu
+		for _, item := range menu.Children {
+			if item.ID != "4" {
+				newChildren = append(newChildren, item)
+			}
+		}
+		menu.Children = newChildren
+
+		appIsCheck := false
+		for _, item := range menu.Children {
+			if item.IsCheck {
+				appIsCheck = true
+				break
+			}
+		}
+
+		menu.Children = append(menu.Children, dto.XpackHideMenu{
+			ID:      "8",
+			Title:   "xpack.app.app",
+			Path:    "/xpack/app",
+			Label:   "XApp",
+			IsCheck: appIsCheck,
+		})
+
+		data, err := json.Marshal(menu)
+		if err != nil {
+			return err
+		}
+
+		return tx.Model(&model.Setting{}).Where("key = ?", "XpackHideMenu").Updates(map[string]interface{}{"value": string(data)}).Error
+	},
+}
+
+var AddAppPanelName = &gormigrate.Migration{
+	ID: "20250218-add-app-panel-name",
+	Migrate: func(tx *gorm.DB) error {
+
+		if err := tx.Create(&model.Setting{Key: "AppPanelName", Value: ""}).Error; err != nil {
+			return err
+		}
+		return nil
+	},
+}
+
+var AddLicenseVerify = &gormigrate.Migration{
+	ID: "20250226-add-license-verify",
+	Migrate: func(tx *gorm.DB) error {
+
+		if err := tx.Create(&model.Setting{Key: "LicenseVerify", Value: "LX"}).Error; err != nil {
+			return err
+		}
+		return nil
+	},
+}
+
+var AddMcpServer = &gormigrate.Migration{
+	ID: "20250401-add-mcp-server",
+	Migrate: func(tx *gorm.DB) error {
+		if err := tx.AutoMigrate(&model.McpServer{}); err != nil {
+			return err
+		}
+		return nil
+	},
+}

backend/init/router/router.go

@@ -109,6 +109,15 @@ func handleNoRoute(c *gin.Context) {
 	c.Data(statusCode, "text/html; charset=utf-8", data)
 }
 
+func checkSession(c *gin.Context) bool {
+	sId, err := c.Cookie(constant.SessionName)
+	if err != nil {
+		return false
+	}
+	_, err = global.SESSION.Get(sId)
+	return err == nil
+}
+
 func setWebStatic(rootRouter *gin.RouterGroup) {
 	rootRouter.StaticFS("/public", http.FS(web.Favicon))
 	rootRouter.StaticFS("/favicon.ico", http.FS(web.Favicon))
@@ -136,10 +145,15 @@ func setWebStatic(rootRouter *gin.RouterGroup) {
 		})
 	}
 	rootRouter.GET("/", func(c *gin.Context) {
-		if !checkEntrance(c) {
+		if !checkEntrance(c) && !checkSession(c) {
 			handleNoRoute(c)
 			return
 		}
+		entrance = authService.GetSecurityEntrance()
+		if entrance != "" {
+			entranceValue := base64.StdEncoding.EncodeToString([]byte(entrance))
+			c.SetCookie("SecurityEntrance", entranceValue, 0, "", "", false, true)
+		}
 		staticServer := http.FileServer(http.FS(web.IndexHtml))
 		staticServer.ServeHTTP(c.Writer, c.Request)
 	})
@@ -174,7 +188,12 @@ func Routers() *gin.Engine {
 
 	swaggerRouter := Router.Group("1panel")
 	docs.SwaggerInfo.BasePath = "/api/v1"
-	swaggerRouter.Use(middleware.JwtAuth()).Use(middleware.SessionAuth()).GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))
+	swaggerRouter.GET("/swagger/*any", func(c *gin.Context) {
+		if !checkSession(c) {
+			handleNoRoute(c)
+			return
+		}
+	}, ginSwagger.WrapHandler(swaggerfiles.Handler))
 	PublicGroup := Router.Group("")
 	{
 		PublicGroup.GET("/health", func(c *gin.Context) {

backend/init/viper/viper.go

@@ -3,6 +3,7 @@ package viper
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"path"
 	"strings"
 
@@ -103,6 +104,7 @@ func Init() {
 	global.CONF.System.Entrance = entrance
 	global.CONF.System.Language = language
 	global.CONF.System.ChangeUserInfo = loadChangeInfo()
+	global.CONF.System.LicenseVerify = os.Getenv("LXWARE_LICENSE_VERIFY")
 	global.Viper = v
 }
 

backend/middleware/session.go

@@ -7,10 +7,10 @@ import (
 	"github.com/1Panel-dev/1Panel/backend/app/repo"
 	"github.com/1Panel-dev/1Panel/backend/constant"
 	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/common"
 	"github.com/gin-gonic/gin"
 	"net"
 	"strconv"
-	"strings"
 	"time"
 )
 
@@ -71,18 +71,25 @@ func SessionAuth() gin.HandlerFunc {
 func isValid1PanelTimestamp(panelTimestamp string) bool {
 	apiKeyValidityTime := global.CONF.System.ApiKeyValidityTime
 	apiTime, err := strconv.Atoi(apiKeyValidityTime)
-	if err != nil {
+	if err != nil || apiTime < 0 {
+		global.LOG.Errorf("apiTime %d, err: %v", apiTime, err)
 		return false
 	}
+	if apiTime == 0 {
+		return true
+	}
 	panelTime, err := strconv.ParseInt(panelTimestamp, 10, 64)
 	if err != nil {
+		global.LOG.Errorf("panelTimestamp %s, panelTime %d, apiTime %d, err: %v", panelTimestamp, apiTime, panelTime, err)
 		return false
 	}
 	nowTime := time.Now().Unix()
-	if panelTime > nowTime {
+	tolerance := int64(60)
+	if panelTime > nowTime+tolerance {
+		global.LOG.Errorf("Valid Panel Timestamp, apiTime %d, panelTime %d, nowTime %d, err: %v", apiTime, panelTime, nowTime, err)
 		return false
 	}
-	return apiTime == 0 || nowTime-panelTime <= int64(apiTime*60)
+	return nowTime-panelTime <= int64(apiTime)*60+tolerance
 }
 
 func isValid1PanelToken(panelToken string, panelTimestamp string) bool {
@@ -95,27 +102,38 @@ func isValid1PanelToken(panelToken string, panelTimestamp string) bool {
 
 func isIPInWhiteList(clientIP string) bool {
 	ipWhiteString := global.CONF.System.IpWhiteList
-	ipWhiteList := strings.Split(ipWhiteString, "\n")
+	if len(ipWhiteString) == 0 {
+		global.LOG.Error("IP whitelist is empty")
+		return false
+	}
+	ipWhiteList, ipErr := common.HandleIPList(ipWhiteString)
+	if ipErr != nil {
+		global.LOG.Errorf("Failed to handle IP list: %v", ipErr)
+		return false
+	}
+	clientParsedIP := net.ParseIP(clientIP)
+	if clientParsedIP == nil {
+		return false
+	}
+	iPv4 := clientParsedIP.To4()
+	iPv6 := clientParsedIP.To16()
 	for _, cidr := range ipWhiteList {
-		if cidr == "0.0.0.0" {
+		if (iPv4 != nil && (cidr == "0.0.0.0" || cidr == "0.0.0.0/0" || iPv4.String() == cidr)) || (iPv6 != nil && (cidr == "::/0" || iPv6.String() == cidr)) {
 			return true
 		}
 		_, ipNet, err := net.ParseCIDR(cidr)
 		if err != nil {
-			if cidr == clientIP {
-				return true
-			}
 			continue
 		}
-		if ipNet.Contains(net.ParseIP(clientIP)) {
+		if (iPv4 != nil && ipNet.Contains(iPv4)) || (iPv6 != nil && ipNet.Contains(iPv6)) {
 			return true
 		}
 	}
 	return false
 }
 
-func GenerateMD5(input string) string {
+func GenerateMD5(param string) string {
 	hash := md5.New()
-	hash.Write([]byte(input))
+	hash.Write([]byte(param))
 	return hex.EncodeToString(hash.Sum(nil))
 }

backend/router/common.go

@@ -23,5 +23,7 @@ func commonGroups() []CommonRouter {
 		&RuntimeRouter{},
 		&ProcessRouter{},
 		&WebsiteCARouter{},
+		&AIToolsRouter{},
+		&McpServerRouter{},
 	}
 }

backend/router/ro_ai.go

@@ -0,0 +1,39 @@
+package router
+
+import (
+	v1 "github.com/1Panel-dev/1Panel/backend/app/api/v1"
+	"github.com/1Panel-dev/1Panel/backend/middleware"
+	"github.com/gin-gonic/gin"
+)
+
+type AIToolsRouter struct {
+}
+
+func (a *AIToolsRouter) InitRouter(Router *gin.RouterGroup) {
+	aiToolsRouter := Router.Group("ai")
+	aiToolsRouter.Use(middleware.JwtAuth()).Use(middleware.SessionAuth()).Use(middleware.PasswordExpired())
+
+	baseApi := v1.ApiGroupApp.BaseApi
+	{
+		aiToolsRouter.POST("/ollama/close", baseApi.CloseOllamaModel)
+		aiToolsRouter.POST("/ollama/model", baseApi.CreateOllamaModel)
+		aiToolsRouter.POST("/ollama/model/recreate", baseApi.RecreateOllamaModel)
+		aiToolsRouter.POST("/ollama/model/search", baseApi.SearchOllamaModel)
+		aiToolsRouter.POST("/ollama/model/sync", baseApi.SyncOllamaModel)
+		aiToolsRouter.POST("/ollama/model/load", baseApi.LoadOllamaModelDetail)
+		aiToolsRouter.POST("/ollama/model/del", baseApi.DeleteOllamaModel)
+		aiToolsRouter.GET("/gpu/load", baseApi.LoadGpuInfo)
+		aiToolsRouter.POST("/domain/bind", baseApi.BindDomain)
+		aiToolsRouter.POST("/domain/get", baseApi.GetBindDomain)
+		aiToolsRouter.POST("/domain/update", baseApi.UpdateBindDomain)
+
+		aiToolsRouter.POST("/mcp/search", baseApi.PageMcpServers)
+		aiToolsRouter.POST("/mcp/server", baseApi.CreateMcpServer)
+		aiToolsRouter.POST("/mcp/server/update", baseApi.UpdateMcpServer)
+		aiToolsRouter.POST("/mcp/server/del", baseApi.DeleteMcpServer)
+		aiToolsRouter.POST("/mcp/server/op", baseApi.OperateMcpServer)
+		aiToolsRouter.POST("/mcp/domain/bind", baseApi.BindMcpDomain)
+		aiToolsRouter.GET("/mcp/domain/get", baseApi.GetMcpBindDomain)
+		aiToolsRouter.POST("/mcp/domain/update", baseApi.UpdateMcpBindDomain)
+	}
+}

backend/router/ro_container.go

@@ -15,7 +15,7 @@ func (s *ContainerRouter) InitRouter(Router *gin.RouterGroup) {
 		Use(middleware.PasswordExpired())
 	baseApi := v1.ApiGroupApp.BaseApi
 	{
-		baRouter.GET("/exec", baseApi.ContainerWsSsh)
+		baRouter.GET("/exec", baseApi.ContainerWsSSH)
 		baRouter.GET("/stats/:id", baseApi.ContainerStats)
 
 		baRouter.POST("", baseApi.ContainerCreate)

backend/router/ro_database.go

@@ -38,7 +38,6 @@ func (s *DatabaseRouter) InitRouter(Router *gin.RouterGroup) {
 		cmdRouter.POST("/redis/persistence/conf", baseApi.LoadPersistenceConf)
 		cmdRouter.POST("/redis/status", baseApi.LoadRedisStatus)
 		cmdRouter.POST("/redis/conf", baseApi.LoadRedisConf)
-		cmdRouter.GET("/redis/exec", baseApi.RedisWsSsh)
 		cmdRouter.GET("/redis/check", baseApi.CheckHasCli)
 		cmdRouter.POST("/redis/install/cli", baseApi.InstallCli)
 		cmdRouter.POST("/redis/password", baseApi.ChangeRedisPassword)

backend/router/ro_file.go

@@ -27,6 +27,7 @@ func (f *FileRouter) InitRouter(Router *gin.RouterGroup) {
 		fileRouter.POST("/content", baseApi.GetContent)
 		fileRouter.POST("/save", baseApi.SaveContent)
 		fileRouter.POST("/check", baseApi.CheckFile)
+		fileRouter.POST("/batch/check", baseApi.BatchCheckFiles)
 		fileRouter.POST("/upload", baseApi.UploadFiles)
 		fileRouter.POST("/chunkupload", baseApi.UploadChunkFiles)
 		fileRouter.POST("/rename", baseApi.ChangeFileName)

backend/router/ro_mcp.go

@@ -0,0 +1,21 @@
+package router
+
+import (
+	v1 "github.com/1Panel-dev/1Panel/backend/app/api/v1"
+	"github.com/1Panel-dev/1Panel/backend/middleware"
+	"github.com/gin-gonic/gin"
+)
+
+type McpServerRouter struct {
+}
+
+func (m *McpServerRouter) InitRouter(Router *gin.RouterGroup) {
+	mcpRouter := Router.Group("mcp")
+	mcpRouter.Use(middleware.JwtAuth()).Use(middleware.SessionAuth()).Use(middleware.PasswordExpired())
+
+	baseApi := v1.ApiGroupApp.BaseApi
+	{
+		mcpRouter.POST("/search", baseApi.PageMcpServers)
+		mcpRouter.POST("/server", baseApi.CreateMcpServer)
+	}
+}

backend/server/server.go

@@ -47,9 +47,9 @@ func Start() {
 	session.Init()
 	gin.SetMode(gin.DebugMode)
 	cron.Run()
+	hook.Init()
 	InitOthers()
 	business.Init()
-	hook.Init()
 
 	rootRouter := router.Routers()
 

backend/utils/ai_tools/gpu/common/gpu_info.go

@@ -0,0 +1,37 @@
+package common
+
+type GpuInfo struct {
+	CudaVersion   string `json:"cudaVersion"`
+	DriverVersion string `json:"driverVersion"`
+	Type          string `json:"type"`
+
+	GPUs []GPU `json:"gpu"`
+}
+
+type GPU struct {
+	Index           uint   `json:"index"`
+	ProductName     string `json:"productName"`
+	PersistenceMode string `json:"persistenceMode"`
+	BusID           string `json:"busID"`
+	DisplayActive   string `json:"displayActive"`
+	ECC             string `json:"ecc"`
+	FanSpeed        string `json:"fanSpeed"`
+
+	Temperature      string    `json:"temperature"`
+	PerformanceState string    `json:"performanceState"`
+	PowerDraw        string    `json:"powerDraw"`
+	MaxPowerLimit    string    `json:"maxPowerLimit"`
+	MemUsed          string    `json:"memUsed"`
+	MemTotal         string    `json:"memTotal"`
+	GPUUtil          string    `json:"gpuUtil"`
+	ComputeMode      string    `json:"computeMode"`
+	MigMode          string    `json:"migMode"`
+	Processes        []Process `json:"processes"`
+}
+
+type Process struct {
+	Pid         string `json:"pid"`
+	Type        string `json:"type"`
+	ProcessName string `json:"processName"`
+	UsedMemory  string `json:"usedMemory"`
+}

backend/utils/ai_tools/gpu/gpu.go

@@ -0,0 +1,68 @@
+package gpu
+
+import (
+	"bytes"
+	_ "embed"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/gpu/common"
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/gpu/schema"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+)
+
+type NvidiaSMI struct{}
+
+func New() (bool, NvidiaSMI) {
+	return cmd.Which("nvidia-smi"), NvidiaSMI{}
+}
+
+func (n NvidiaSMI) LoadGpuInfo() (*common.GpuInfo, error) {
+	std, err := cmd.ExecWithTimeOut("nvidia-smi -q -x", 5*time.Second)
+	if err != nil {
+		return nil, fmt.Errorf("calling nvidia-smi failed, err: %v", std)
+	}
+	data := []byte(std)
+	version := "v11"
+
+	buf := bytes.NewBuffer(data)
+	decoder := xml.NewDecoder(buf)
+	for {
+		token, err := decoder.Token()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
+			return nil, fmt.Errorf("reading token failed: %w", err)
+		}
+		d, ok := token.(xml.Directive)
+		if !ok {
+			continue
+		}
+		directive := string(d)
+		if !strings.HasPrefix(directive, "DOCTYPE") {
+			continue
+		}
+		parts := strings.Split(directive, " ")
+		s := strings.Trim(parts[len(parts)-1], "\" ")
+		if strings.HasPrefix(s, "nvsmi_device_") && strings.HasSuffix(s, ".dtd") {
+			version = strings.TrimSuffix(strings.TrimPrefix(s, "nvsmi_device_"), ".dtd")
+		} else {
+			global.LOG.Debugf("Cannot find schema version in %q", directive)
+		}
+		break
+	}
+
+	if version == "v12" || version == "v11" {
+		return schema.Parse(data, version)
+	} else {
+		global.LOG.Errorf("don't support such schema version %s", version)
+	}
+
+	return &common.GpuInfo{}, nil
+}

backend/utils/ai_tools/gpu/schema/parser.go

@@ -0,0 +1,63 @@
+package schema
+
+import (
+	"encoding/xml"
+
+	"github.com/1Panel-dev/1Panel/backend/utils/ai_tools/gpu/common"
+)
+
+func Parse(buf []byte, version string) (*common.GpuInfo, error) {
+	var (
+		s    smi
+		info common.GpuInfo
+	)
+	if err := xml.Unmarshal(buf, &s); err != nil {
+		return nil, err
+	}
+
+	info.Type = "nvidia"
+	info.CudaVersion = s.CudaVersion
+	info.DriverVersion = s.DriverVersion
+	if len(s.Gpu) == 0 {
+		return &info, nil
+	}
+	for i := 0; i < len(s.Gpu); i++ {
+		var gpuItem common.GPU
+		gpuItem.Index = uint(i)
+		gpuItem.ProductName = s.Gpu[i].ProductName
+		gpuItem.PersistenceMode = s.Gpu[i].PersistenceMode
+		gpuItem.BusID = s.Gpu[i].ID
+		gpuItem.DisplayActive = s.Gpu[i].DisplayActive
+		gpuItem.ECC = s.Gpu[i].EccMode.CurrentEcc
+		if gpuItem.ECC == "Enabled" {
+			gpuItem.ECC = s.Gpu[i].EccErrors.Volatile.DramUncorrectable
+		}
+		gpuItem.FanSpeed = s.Gpu[i].FanSpeed
+
+		gpuItem.Temperature = s.Gpu[i].Temperature.GpuTemp
+		gpuItem.PerformanceState = s.Gpu[i].PerformanceState
+		if version == "v12" {
+			gpuItem.PowerDraw = s.Gpu[i].GpuPowerReadings.PowerDraw
+			gpuItem.MaxPowerLimit = s.Gpu[i].GpuPowerReadings.MaxPowerLimit
+		} else {
+			gpuItem.PowerDraw = s.Gpu[i].PowerReadings.PowerDraw
+			gpuItem.MaxPowerLimit = s.Gpu[i].PowerReadings.MaxPowerLimit
+		}
+		gpuItem.MemUsed = s.Gpu[i].FbMemoryUsage.Used
+		gpuItem.MemTotal = s.Gpu[i].FbMemoryUsage.Total
+		gpuItem.GPUUtil = s.Gpu[i].Utilization.GpuUtil
+		gpuItem.ComputeMode = s.Gpu[i].ComputeMode
+		gpuItem.MigMode = s.Gpu[i].MigMode.CurrentMig
+
+		for _, process := range s.Gpu[i].Processes.ProcessInfo {
+			gpuItem.Processes = append(gpuItem.Processes, common.Process{
+				Pid:         process.Pid,
+				Type:        process.Type,
+				ProcessName: process.ProcessName,
+				UsedMemory:  process.UsedMemory,
+			})
+		}
+		info.GPUs = append(info.GPUs, gpuItem)
+	}
+	return &info, nil
+}

backend/utils/ai_tools/gpu/schema/types.go

@@ -0,0 +1,294 @@
+package schema
+
+type smi struct {
+	AttachedGpus  string `xml:"attached_gpus"`
+	CudaVersion   string `xml:"cuda_version"`
+	DriverVersion string `xml:"driver_version"`
+	Gpu           []struct {
+		ID                       string   `xml:"id,attr"`
+		AccountedProcesses       struct{} `xml:"accounted_processes"`
+		AccountingMode           string   `xml:"accounting_mode"`
+		AccountingModeBufferSize string   `xml:"accounting_mode_buffer_size"`
+		AddressingMode           string   `xml:"addressing_mode"`
+		ApplicationsClocks       struct {
+			GraphicsClock string `xml:"graphics_clock"`
+			MemClock      string `xml:"mem_clock"`
+		} `xml:"applications_clocks"`
+		Bar1MemoryUsage struct {
+			Free  string `xml:"free"`
+			Total string `xml:"total"`
+			Used  string `xml:"used"`
+		} `xml:"bar1_memory_usage"`
+		BoardID                string `xml:"board_id"`
+		BoardPartNumber        string `xml:"board_part_number"`
+		CcProtectedMemoryUsage struct {
+			Free  string `xml:"free"`
+			Total string `xml:"total"`
+			Used  string `xml:"used"`
+		} `xml:"cc_protected_memory_usage"`
+		ClockPolicy struct {
+			AutoBoost        string `xml:"auto_boost"`
+			AutoBoostDefault string `xml:"auto_boost_default"`
+		} `xml:"clock_policy"`
+		Clocks struct {
+			GraphicsClock string `xml:"graphics_clock"`
+			MemClock      string `xml:"mem_clock"`
+			SmClock       string `xml:"sm_clock"`
+			VideoClock    string `xml:"video_clock"`
+		} `xml:"clocks"`
+		ClocksEventReasons struct {
+			ClocksEventReasonApplicationsClocksSetting string `xml:"clocks_event_reason_applications_clocks_setting"`
+			ClocksEventReasonDisplayClocksSetting      string `xml:"clocks_event_reason_display_clocks_setting"`
+			ClocksEventReasonGpuIdle                   string `xml:"clocks_event_reason_gpu_idle"`
+			ClocksEventReasonHwPowerBrakeSlowdown      string `xml:"clocks_event_reason_hw_power_brake_slowdown"`
+			ClocksEventReasonHwSlowdown                string `xml:"clocks_event_reason_hw_slowdown"`
+			ClocksEventReasonHwThermalSlowdown         string `xml:"clocks_event_reason_hw_thermal_slowdown"`
+			ClocksEventReasonSwPowerCap                string `xml:"clocks_event_reason_sw_power_cap"`
+			ClocksEventReasonSwThermalSlowdown         string `xml:"clocks_event_reason_sw_thermal_slowdown"`
+			ClocksEventReasonSyncBoost                 string `xml:"clocks_event_reason_sync_boost"`
+		} `xml:"clocks_event_reasons"`
+		ComputeMode               string `xml:"compute_mode"`
+		DefaultApplicationsClocks struct {
+			GraphicsClock string `xml:"graphics_clock"`
+			MemClock      string `xml:"mem_clock"`
+		} `xml:"default_applications_clocks"`
+		DeferredClocks struct {
+			MemClock string `xml:"mem_clock"`
+		} `xml:"deferred_clocks"`
+		DisplayActive string `xml:"display_active"`
+		DisplayMode   string `xml:"display_mode"`
+		DriverModel   struct {
+			CurrentDm string `xml:"current_dm"`
+			PendingDm string `xml:"pending_dm"`
+		} `xml:"driver_model"`
+		EccErrors struct {
+			Aggregate struct {
+				DramCorrectable   string `xml:"dram_correctable"`
+				DramUncorrectable string `xml:"dram_uncorrectable"`
+				SramCorrectable   string `xml:"sram_correctable"`
+				SramUncorrectable string `xml:"sram_uncorrectable"`
+			} `xml:"aggregate"`
+			Volatile struct {
+				DramCorrectable   string `xml:"dram_correctable"`
+				DramUncorrectable string `xml:"dram_uncorrectable"`
+				SramCorrectable   string `xml:"sram_correctable"`
+				SramUncorrectable string `xml:"sram_uncorrectable"`
+			} `xml:"volatile"`
+		} `xml:"ecc_errors"`
+		EccMode struct {
+			CurrentEcc string `xml:"current_ecc"`
+			PendingEcc string `xml:"pending_ecc"`
+		} `xml:"ecc_mode"`
+		EncoderStats struct {
+			AverageFps     string `xml:"average_fps"`
+			AverageLatency string `xml:"average_latency"`
+			SessionCount   string `xml:"session_count"`
+		} `xml:"encoder_stats"`
+		Fabric struct {
+			State  string `xml:"state"`
+			Status string `xml:"status"`
+		} `xml:"fabric"`
+		FanSpeed      string `xml:"fan_speed"`
+		FbMemoryUsage struct {
+			Free     string `xml:"free"`
+			Reserved string `xml:"reserved"`
+			Total    string `xml:"total"`
+			Used     string `xml:"used"`
+		} `xml:"fb_memory_usage"`
+		FbcStats struct {
+			AverageFps     string `xml:"average_fps"`
+			AverageLatency string `xml:"average_latency"`
+			SessionCount   string `xml:"session_count"`
+		} `xml:"fbc_stats"`
+		GpuFruPartNumber string `xml:"gpu_fru_part_number"`
+		GpuModuleID      string `xml:"gpu_module_id"`
+		GpuOperationMode struct {
+			CurrentGom string `xml:"current_gom"`
+			PendingGom string `xml:"pending_gom"`
+		} `xml:"gpu_operation_mode"`
+		GpuPartNumber    string `xml:"gpu_part_number"`
+		GpuPowerReadings struct {
+			CurrentPowerLimit   string `xml:"current_power_limit"`
+			DefaultPowerLimit   string `xml:"default_power_limit"`
+			MaxPowerLimit       string `xml:"max_power_limit"`
+			MinPowerLimit       string `xml:"min_power_limit"`
+			PowerDraw           string `xml:"power_draw"`
+			PowerState          string `xml:"power_state"`
+			RequestedPowerLimit string `xml:"requested_power_limit"`
+		} `xml:"gpu_power_readings"`
+		GpuResetStatus struct {
+			DrainAndResetRecommended string `xml:"drain_and_reset_recommended"`
+			ResetRequired            string `xml:"reset_required"`
+		} `xml:"gpu_reset_status"`
+		GpuVirtualizationMode struct {
+			HostVgpuMode       string `xml:"host_vgpu_mode"`
+			VirtualizationMode string `xml:"virtualization_mode"`
+		} `xml:"gpu_virtualization_mode"`
+		GspFirmwareVersion string `xml:"gsp_firmware_version"`
+		Ibmnpu             struct {
+			RelaxedOrderingMode string `xml:"relaxed_ordering_mode"`
+		} `xml:"ibmnpu"`
+		InforomVersion struct {
+			EccObject  string `xml:"ecc_object"`
+			ImgVersion string `xml:"img_version"`
+			OemObject  string `xml:"oem_object"`
+			PwrObject  string `xml:"pwr_object"`
+		} `xml:"inforom_version"`
+		MaxClocks struct {
+			GraphicsClock string `xml:"graphics_clock"`
+			MemClock      string `xml:"mem_clock"`
+			SmClock       string `xml:"sm_clock"`
+			VideoClock    string `xml:"video_clock"`
+		} `xml:"max_clocks"`
+		MaxCustomerBoostClocks struct {
+			GraphicsClock string `xml:"graphics_clock"`
+		} `xml:"max_customer_boost_clocks"`
+		MigDevices struct {
+			MigDevice []struct {
+				Index             string `xml:"index"`
+				GpuInstanceID     string `xml:"gpu_instance_id"`
+				ComputeInstanceID string `xml:"compute_instance_id"`
+				EccErrorCount     struct {
+					Text          string `xml:",chardata" json:"text"`
+					VolatileCount struct {
+						SramUncorrectable string `xml:"sram_uncorrectable"`
+					} `xml:"volatile_count" json:"volatile_count"`
+				} `xml:"ecc_error_count" json:"ecc_error_count"`
+				FbMemoryUsage struct {
+					Total    string `xml:"total"`
+					Reserved string `xml:"reserved"`
+					Used     string `xml:"used"`
+					Free     string `xml:"free"`
+				} `xml:"fb_memory_usage" json:"fb_memory_usage"`
+				Bar1MemoryUsage struct {
+					Total string `xml:"total"`
+					Used  string `xml:"used"`
+					Free  string `xml:"free"`
+				} `xml:"bar1_memory_usage" json:"bar1_memory_usage"`
+			} `xml:"mig_device" json:"mig_device"`
+		} `xml:"mig_devices" json:"mig_devices"`
+		MigMode struct {
+			CurrentMig string `xml:"current_mig"`
+			PendingMig string `xml:"pending_mig"`
+		} `xml:"mig_mode"`
+		MinorNumber         string `xml:"minor_number"`
+		ModulePowerReadings struct {
+			CurrentPowerLimit   string `xml:"current_power_limit"`
+			DefaultPowerLimit   string `xml:"default_power_limit"`
+			MaxPowerLimit       string `xml:"max_power_limit"`
+			MinPowerLimit       string `xml:"min_power_limit"`
+			PowerDraw           string `xml:"power_draw"`
+			PowerState          string `xml:"power_state"`
+			RequestedPowerLimit string `xml:"requested_power_limit"`
+		} `xml:"module_power_readings"`
+		MultigpuBoard string `xml:"multigpu_board"`
+		Pci           struct {
+			AtomicCapsInbound  string `xml:"atomic_caps_inbound"`
+			AtomicCapsOutbound string `xml:"atomic_caps_outbound"`
+			PciBridgeChip      struct {
+				BridgeChipFw   string `xml:"bridge_chip_fw"`
+				BridgeChipType string `xml:"bridge_chip_type"`
+			} `xml:"pci_bridge_chip"`
+			PciBus         string `xml:"pci_bus"`
+			PciBusID       string `xml:"pci_bus_id"`
+			PciDevice      string `xml:"pci_device"`
+			PciDeviceID    string `xml:"pci_device_id"`
+			PciDomain      string `xml:"pci_domain"`
+			PciGpuLinkInfo struct {
+				LinkWidths struct {
+					CurrentLinkWidth string `xml:"current_link_width"`
+					MaxLinkWidth     string `xml:"max_link_width"`
+				} `xml:"link_widths"`
+				PcieGen struct {
+					CurrentLinkGen       string `xml:"current_link_gen"`
+					DeviceCurrentLinkGen string `xml:"device_current_link_gen"`
+					MaxDeviceLinkGen     string `xml:"max_device_link_gen"`
+					MaxHostLinkGen       string `xml:"max_host_link_gen"`
+					MaxLinkGen           string `xml:"max_link_gen"`
+				} `xml:"pcie_gen"`
+			} `xml:"pci_gpu_link_info"`
+			PciSubSystemID        string `xml:"pci_sub_system_id"`
+			ReplayCounter         string `xml:"replay_counter"`
+			ReplayRolloverCounter string `xml:"replay_rollover_counter"`
+			RxUtil                string `xml:"rx_util"`
+			TxUtil                string `xml:"tx_util"`
+		} `xml:"pci"`
+		PerformanceState string `xml:"performance_state"`
+		PersistenceMode  string `xml:"persistence_mode"`
+		PowerReadings    struct {
+			PowerState         string `xml:"power_state"`
+			PowerManagement    string `xml:"power_management"`
+			PowerDraw          string `xml:"power_draw"`
+			PowerLimit         string `xml:"power_limit"`
+			DefaultPowerLimit  string `xml:"default_power_limit"`
+			EnforcedPowerLimit string `xml:"enforced_power_limit"`
+			MinPowerLimit      string `xml:"min_power_limit"`
+			MaxPowerLimit      string `xml:"max_power_limit"`
+		} `xml:"power_readings"`
+		Processes struct {
+			ProcessInfo []struct {
+				Pid         string `xml:"pid"`
+				Type        string `xml:"type"`
+				ProcessName string `xml:"process_name"`
+				UsedMemory  string `xml:"used_memory"`
+			} `xml:"process_info"`
+		} `xml:"processes"`
+		ProductArchitecture string `xml:"product_architecture"`
+		ProductBrand        string `xml:"product_brand"`
+		ProductName         string `xml:"product_name"`
+		RemappedRows        struct {
+			// Manually added
+			Correctable   string `xml:"remapped_row_corr"`
+			Uncorrectable string `xml:"remapped_row_unc"`
+			Pending       string `xml:"remapped_row_pending"`
+			Failure       string `xml:"remapped_row_failure"`
+		} `xml:"remapped_rows"`
+		RetiredPages struct {
+			DoubleBitRetirement struct {
+				RetiredCount    string `xml:"retired_count"`
+				RetiredPagelist string `xml:"retired_pagelist"`
+			} `xml:"double_bit_retirement"`
+			MultipleSingleBitRetirement struct {
+				RetiredCount    string `xml:"retired_count"`
+				RetiredPagelist string `xml:"retired_pagelist"`
+			} `xml:"multiple_single_bit_retirement"`
+			PendingBlacklist  string `xml:"pending_blacklist"`
+			PendingRetirement string `xml:"pending_retirement"`
+		} `xml:"retired_pages"`
+		Serial          string `xml:"serial"`
+		SupportedClocks struct {
+			SupportedMemClock []struct {
+				SupportedGraphicsClock []string `xml:"supported_graphics_clock"`
+				Value                  string   `xml:"value"`
+			} `xml:"supported_mem_clock"`
+		} `xml:"supported_clocks"`
+		SupportedGpuTargetTemp struct {
+			GpuTargetTempMax string `xml:"gpu_target_temp_max"`
+			GpuTargetTempMin string `xml:"gpu_target_temp_min"`
+		} `xml:"supported_gpu_target_temp"`
+		Temperature struct {
+			GpuTargetTemperature   string `xml:"gpu_target_temperature"`
+			GpuTemp                string `xml:"gpu_temp"`
+			GpuTempMaxGpuThreshold string `xml:"gpu_temp_max_gpu_threshold"`
+			GpuTempMaxMemThreshold string `xml:"gpu_temp_max_mem_threshold"`
+			GpuTempMaxThreshold    string `xml:"gpu_temp_max_threshold"`
+			GpuTempSlowThreshold   string `xml:"gpu_temp_slow_threshold"`
+			GpuTempTlimit          string `xml:"gpu_temp_tlimit"`
+			MemoryTemp             string `xml:"memory_temp"`
+		} `xml:"temperature"`
+		Utilization struct {
+			DecoderUtil string `xml:"decoder_util"`
+			EncoderUtil string `xml:"encoder_util"`
+			GpuUtil     string `xml:"gpu_util"`
+			JpegUtil    string `xml:"jpeg_util"`
+			MemoryUtil  string `xml:"memory_util"`
+			OfaUtil     string `xml:"ofa_util"`
+		} `xml:"utilization"`
+		UUID         string `xml:"uuid"`
+		VbiosVersion string `xml:"vbios_version"`
+		Voltage      struct {
+			GraphicsVolt string `xml:"graphics_volt"`
+		} `xml:"voltage"`
+	} `xml:"gpu"`
+	Timestamp string `xml:"timestamp"`
+}

backend/utils/ai_tools/xpu/types.go

@@ -0,0 +1,43 @@
+package xpu
+
+type DeviceUtilByProc struct {
+	DeviceID      int     `json:"device_id"`
+	MemSize       float64 `json:"mem_size"`
+	ProcessID     int     `json:"process_id"`
+	ProcessName   string  `json:"process_name"`
+	SharedMemSize float64 `json:"shared_mem_size"`
+}
+
+type DeviceUtilByProcList struct {
+	DeviceUtilByProcList []DeviceUtilByProc `json:"device_util_by_proc_list"`
+}
+
+type Device struct {
+	DeviceFunctionType string `json:"device_function_type"`
+	DeviceID           int    `json:"device_id"`
+	DeviceName         string `json:"device_name"`
+	DeviceType         string `json:"device_type"`
+	DrmDevice          string `json:"drm_device"`
+	PciBdfAddress      string `json:"pci_bdf_address"`
+	PciDeviceID        string `json:"pci_device_id"`
+	UUID               string `json:"uuid"`
+	VendorName         string `json:"vendor_name"`
+
+	MemoryPhysicalSizeByte string `json:"memory_physical_size_byte"`
+	MemoryFreeSizeByte     string `json:"memory_free_size_byte"`
+	DriverVersion          string `json:"driver_version"`
+}
+
+type DeviceInfo struct {
+	DeviceList []Device `json:"device_list"`
+}
+
+type DeviceLevelMetric struct {
+	MetricsType string  `json:"metrics_type"`
+	Value       float64 `json:"value"`
+}
+
+type DeviceStats struct {
+	DeviceID    int                 `json:"device_id"`
+	DeviceLevel []DeviceLevelMetric `json:"device_level"`
+}

backend/utils/ai_tools/xpu/xpu.go

@@ -0,0 +1,256 @@
+package xpu
+
+import (
+	"encoding/json"
+	"fmt"
+	"sort"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/1Panel-dev/1Panel/backend/global"
+	"github.com/1Panel-dev/1Panel/backend/utils/cmd"
+)
+
+type XpuSMI struct{}
+
+func New() (bool, XpuSMI) {
+	return cmd.Which("xpu-smi"), XpuSMI{}
+}
+
+func (x XpuSMI) loadDeviceData(device Device, wg *sync.WaitGroup, res *[]XPUSimpleInfo, mu *sync.Mutex) {
+	defer wg.Done()
+
+	var xpu XPUSimpleInfo
+	xpu.DeviceID = device.DeviceID
+	xpu.DeviceName = device.DeviceName
+
+	var xpuData, statsData string
+	var xpuErr, statsErr error
+
+	var wgCmd sync.WaitGroup
+	wgCmd.Add(2)
+
+	go func() {
+		defer wgCmd.Done()
+		xpuData, xpuErr = cmd.ExecWithTimeOut(fmt.Sprintf("xpu-smi discovery -d %d -j", device.DeviceID), 5*time.Second)
+	}()
+
+	go func() {
+		defer wgCmd.Done()
+		statsData, statsErr = cmd.ExecWithTimeOut(fmt.Sprintf("xpu-smi stats -d %d -j", device.DeviceID), 5*time.Second)
+	}()
+
+	wgCmd.Wait()
+
+	if xpuErr != nil {
+		global.LOG.Errorf("calling xpu-smi discovery failed for device %d, err: %v\n", device.DeviceID, xpuErr)
+		return
+	}
+
+	var info Device
+	if err := json.Unmarshal([]byte(xpuData), &info); err != nil {
+		global.LOG.Errorf("xpuData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		return
+	}
+
+	bytes, err := strconv.ParseInt(info.MemoryPhysicalSizeByte, 10, 64)
+	if err != nil {
+		global.LOG.Errorf("Error parsing memory size for device %d, err: %v\n", device.DeviceID, err)
+		return
+	}
+	xpu.Memory = fmt.Sprintf("%.1f MB", float64(bytes)/(1024*1024))
+
+	if statsErr != nil {
+		global.LOG.Errorf("calling xpu-smi stats failed for device %d, err: %v\n", device.DeviceID, statsErr)
+		return
+	}
+
+	var stats DeviceStats
+	if err := json.Unmarshal([]byte(statsData), &stats); err != nil {
+		global.LOG.Errorf("statsData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		return
+	}
+
+	for _, stat := range stats.DeviceLevel {
+		switch stat.MetricsType {
+		case "XPUM_STATS_POWER":
+			xpu.Power = fmt.Sprintf("%.1fW", stat.Value)
+		case "XPUM_STATS_GPU_CORE_TEMPERATURE":
+			xpu.Temperature = fmt.Sprintf("%.1f°C", stat.Value)
+		case "XPUM_STATS_MEMORY_USED":
+			xpu.MemoryUsed = fmt.Sprintf("%.1fMB", stat.Value)
+		case "XPUM_STATS_MEMORY_UTILIZATION":
+			xpu.MemoryUtil = fmt.Sprintf("%.1f%%", stat.Value)
+		}
+	}
+
+	mu.Lock()
+	*res = append(*res, xpu)
+	mu.Unlock()
+}
+
+func (x XpuSMI) LoadDashData() ([]XPUSimpleInfo, error) {
+	data, err := cmd.ExecWithTimeOut("xpu-smi discovery -j", 5*time.Second)
+	if err != nil {
+		return nil, fmt.Errorf("calling xpu-smi failed, err: %w", err)
+	}
+
+	var deviceInfo DeviceInfo
+	if err := json.Unmarshal([]byte(data), &deviceInfo); err != nil {
+		return nil, fmt.Errorf("deviceInfo json unmarshal failed, err: %w", err)
+	}
+
+	var res []XPUSimpleInfo
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+
+	for _, device := range deviceInfo.DeviceList {
+		wg.Add(1)
+		go x.loadDeviceData(device, &wg, &res, &mu)
+	}
+
+	wg.Wait()
+
+	sort.Slice(res, func(i, j int) bool {
+		return res[i].DeviceID < res[j].DeviceID
+	})
+	return res, nil
+}
+
+func (x XpuSMI) LoadGpuInfo() (*XpuInfo, error) {
+	data, err := cmd.ExecWithTimeOut("xpu-smi discovery -j", 5*time.Second)
+	if err != nil {
+		return nil, fmt.Errorf("calling xpu-smi  failed, err: %w", err)
+	}
+
+	var deviceInfo DeviceInfo
+	if err := json.Unmarshal([]byte(data), &deviceInfo); err != nil {
+		return nil, fmt.Errorf("deviceInfo json unmarshal failed, err: %w", err)
+	}
+
+	res := &XpuInfo{
+		Type: "xpu",
+	}
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+
+	for _, device := range deviceInfo.DeviceList {
+		wg.Add(1)
+		go x.loadDeviceInfo(device, &wg, res, &mu)
+	}
+
+	wg.Wait()
+
+	processData, err := cmd.ExecWithTimeOut("xpu-smi ps -j", 5*time.Second)
+	if err != nil {
+		return nil, fmt.Errorf("calling xpu-smi ps failed, err: %w", err)
+	}
+	var psList DeviceUtilByProcList
+	if err := json.Unmarshal([]byte(processData), &psList); err != nil {
+		return nil, fmt.Errorf("processData json unmarshal failed, err: %w", err)
+	}
+	for _, ps := range psList.DeviceUtilByProcList {
+		process := Process{
+			PID:     ps.ProcessID,
+			Command: ps.ProcessName,
+		}
+		if ps.SharedMemSize > 0 {
+			process.SHR = fmt.Sprintf("%.1f MB", ps.SharedMemSize/1024)
+		}
+		if ps.MemSize > 0 {
+			process.Memory = fmt.Sprintf("%.1f MB", ps.MemSize/1024)
+		}
+		for index, xpu := range res.Xpu {
+			if xpu.Basic.DeviceID == ps.DeviceID {
+				res.Xpu[index].Processes = append(res.Xpu[index].Processes, process)
+			}
+		}
+	}
+
+	return res, nil
+}
+
+func (x XpuSMI) loadDeviceInfo(device Device, wg *sync.WaitGroup, res *XpuInfo, mu *sync.Mutex) {
+	defer wg.Done()
+
+	xpu := Xpu{
+		Basic: Basic{
+			DeviceID:      device.DeviceID,
+			DeviceName:    device.DeviceName,
+			VendorName:    device.VendorName,
+			PciBdfAddress: device.PciBdfAddress,
+		},
+	}
+
+	var xpuData, statsData string
+	var xpuErr, statsErr error
+
+	var wgCmd sync.WaitGroup
+	wgCmd.Add(2)
+
+	go func() {
+		defer wgCmd.Done()
+		xpuData, xpuErr = cmd.ExecWithTimeOut(fmt.Sprintf("xpu-smi discovery -d %d -j", device.DeviceID), 5*time.Second)
+	}()
+
+	go func() {
+		defer wgCmd.Done()
+		statsData, statsErr = cmd.ExecWithTimeOut(fmt.Sprintf("xpu-smi stats -d %d -j", device.DeviceID), 5*time.Second)
+	}()
+
+	wgCmd.Wait()
+
+	if xpuErr != nil {
+		global.LOG.Errorf("calling xpu-smi discovery failed for device %d, err: %v\n", device.DeviceID, xpuErr)
+		return
+	}
+
+	var info Device
+	if err := json.Unmarshal([]byte(xpuData), &info); err != nil {
+		global.LOG.Errorf("xpuData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		return
+	}
+
+	res.DriverVersion = info.DriverVersion
+	xpu.Basic.DriverVersion = info.DriverVersion
+
+	bytes, err := strconv.ParseInt(info.MemoryPhysicalSizeByte, 10, 64)
+	if err != nil {
+		global.LOG.Errorf("Error parsing memory size for device %d, err: %v\n", device.DeviceID, err)
+		return
+	}
+	xpu.Basic.Memory = fmt.Sprintf("%.1f MB", float64(bytes)/(1024*1024))
+	xpu.Basic.FreeMemory = info.MemoryFreeSizeByte
+
+	if statsErr != nil {
+		global.LOG.Errorf("calling xpu-smi stats failed for device %d, err: %v\n", device.DeviceID, statsErr)
+		return
+	}
+
+	var stats DeviceStats
+	if err := json.Unmarshal([]byte(statsData), &stats); err != nil {
+		global.LOG.Errorf("statsData json unmarshal failed for device %d, err: %v\n", device.DeviceID, err)
+		return
+	}
+
+	for _, stat := range stats.DeviceLevel {
+		switch stat.MetricsType {
+		case "XPUM_STATS_POWER":
+			xpu.Stats.Power = fmt.Sprintf("%.1fW", stat.Value)
+		case "XPUM_STATS_GPU_FREQUENCY":
+			xpu.Stats.Frequency = fmt.Sprintf("%.1fMHz", stat.Value)
+		case "XPUM_STATS_GPU_CORE_TEMPERATURE":
+			xpu.Stats.Temperature = fmt.Sprintf("%.1f°C", stat.Value)
+		case "XPUM_STATS_MEMORY_USED":
+			xpu.Stats.MemoryUsed = fmt.Sprintf("%.1fMB", stat.Value)
+		case "XPUM_STATS_MEMORY_UTILIZATION":
+			xpu.Stats.MemoryUtil = fmt.Sprintf("%.1f%%", stat.Value)
+		}
+	}
+
+	mu.Lock()
+	res.Xpu = append(res.Xpu, xpu)
+	mu.Unlock()
+}

backend/utils/ai_tools/xpu/xpu_info.go

@@ -0,0 +1,49 @@
+package xpu
+
+type XpuInfo struct {
+	Type          string `json:"type"`
+	DriverVersion string `json:"driverVersion"`
+
+	Xpu []Xpu `json:"xpu"`
+}
+
+type Xpu struct {
+	Basic     Basic     `json:"basic"`
+	Stats     Stats     `json:"stats"`
+	Processes []Process `json:"processes"`
+}
+
+type Basic struct {
+	DeviceID      int    `json:"deviceID"`
+	DeviceName    string `json:"deviceName"`
+	VendorName    string `json:"vendorName"`
+	DriverVersion string `json:"driverVersion"`
+	Memory        string `json:"memory"`
+	FreeMemory    string `json:"freeMemory"`
+	PciBdfAddress string `json:"pciBdfAddress"`
+}
+
+type Stats struct {
+	Power       string `json:"power"`
+	Frequency   string `json:"frequency"`
+	Temperature string `json:"temperature"`
+	MemoryUsed  string `json:"memoryUsed"`
+	MemoryUtil  string `json:"memoryUtil"`
+}
+
+type Process struct {
+	PID     int    `json:"pid"`
+	Command string `json:"command"`
+	SHR     string `json:"shr"`
+	Memory  string `json:"memory"`
+}
+
+type XPUSimpleInfo struct {
+	DeviceID    int    `json:"deviceID"`
+	DeviceName  string `json:"deviceName"`
+	Memory      string `json:"memory"`
+	Temperature string `json:"temperature"`
+	MemoryUsed  string `json:"memoryUsed"`
+	Power       string `json:"power"`
+	MemoryUtil  string `json:"memoryUtil"`
+}

backend/utils/cloud_storage/client/cos.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"regexp"
 
 	cosSDK "github.com/tencentyun/cos-go-sdk-v5"
 )
@@ -18,6 +19,7 @@ type cosClient struct {
 
 func NewCosClient(vars map[string]interface{}) (*cosClient, error) {
 	region := loadParamFromVars("region", vars)
+	endpoint := loadParamFromVars("endpoint", vars)
 	accessKey := loadParamFromVars("accessKey", vars)
 	secretKey := loadParamFromVars("secretKey", vars)
 	bucket := loadParamFromVars("bucket", vars)
@@ -26,7 +28,16 @@ func NewCosClient(vars map[string]interface{}) (*cosClient, error) {
 		scType = "Standard"
 	}
 
-	u, _ := url.Parse(fmt.Sprintf("https://cos.%s.myqcloud.com", region))
+	// 允许使用对象存储双栈域名
+	endpointType := "cos"
+	if len(endpoint) != 0 {
+		re := regexp.MustCompile(`.*cos-dualstack\..*`)
+		if re.MatchString(endpoint) {
+			endpointType = "cos-dualstack"
+		}
+	}
+
+	u, _ := url.Parse(fmt.Sprintf("https://%s.%s.myqcloud.com", endpointType, region))
 	b := &cosSDK.BaseURL{BucketURL: u}
 	client := cosSDK.NewClient(b, &http.Client{
 		Transport: &cosSDK.AuthorizationTransport{
@@ -36,7 +47,7 @@ func NewCosClient(vars map[string]interface{}) (*cosClient, error) {
 	})
 
 	if len(bucket) != 0 {
-		u2, _ := url.Parse(fmt.Sprintf("https://%s.cos.%s.myqcloud.com", bucket, region))
+		u2, _ := url.Parse(fmt.Sprintf("https://%s.%s.%s.myqcloud.com", bucket, endpointType, region))
 		b2 := &cosSDK.BaseURL{BucketURL: u2}
 		clientWithBucket := cosSDK.NewClient(b2, &http.Client{
 			Transport: &cosSDK.AuthorizationTransport{

backend/utils/common/common.go

@@ -3,6 +3,7 @@ package common
 import (
 	"crypto/rand"
 	"fmt"
+	"github.com/1Panel-dev/1Panel/backend/buserr"
 	"github.com/gin-gonic/gin"
 	"io"
 	mathRand "math/rand"
@@ -351,3 +352,22 @@ func GetLang(c *gin.Context) string {
 	}
 	return lang
 }
+
+func HandleIPList(content string) ([]string, error) {
+	ipList := strings.Split(content, "\n")
+	var res []string
+	for _, ip := range ipList {
+		if ip == "" {
+			continue
+		}
+		if net.ParseIP(ip) != nil {
+			res = append(res, ip)
+			continue
+		}
+		if _, _, err := net.ParseCIDR(ip); err != nil {
+			return nil, buserr.New("ErrParseIP")
+		}
+		res = append(res, ip)
+	}
+	return res, nil
+}

backend/utils/firewall/client/iptables.go

@@ -133,10 +133,10 @@ func (iptables *Iptables) NatAdd(protocol, srcPort, dest, destPort string, save
 
 		// 非本机转发, 按公网流程走
 		if err := iptables.runf(NatTab, fmt.Sprintf(
-			"-A %s -p %s -d %s --dport %s -j MASQUERADE",
+			"-A %s -d %s -p %s --dport %s -j MASQUERADE",
 			PostRoutingChain,
-			protocol,
 			dest,
+			protocol,
 			destPort,
 		)); err != nil {
 			return err
@@ -192,7 +192,7 @@ func (iptables *Iptables) NatRemove(num string, protocol, srcPort, dest, destPor
 	// 删除公网转发规则
 	if dest != "" && dest != "127.0.0.1" && dest != "localhost" {
 		if err := iptables.runf(NatTab, fmt.Sprintf(
-			"-D %s -p %s -d %s --dport %s -j MASQUERADE",
+			"-D %s -d %s -p %s --dport %s -j MASQUERADE",
 			PostRoutingChain,
 			dest,
 			protocol,

backend/utils/mysql/client/local.go

@@ -188,18 +188,19 @@ func (r *Local) ChangeAccess(info AccessChangeInfo) error {
 		info.Name = "*"
 		info.Password = r.Password
 	}
-	if info.Permission != info.OldPermission {
-		if err := r.Delete(DeleteInfo{
-			Version:     info.Version,
-			Username:    info.Username,
-			Permission:  info.OldPermission,
-			ForceDelete: true,
-			Timeout:     300}); err != nil {
-			return err
-		}
-		if info.Username == "root" {
-			return nil
-		}
+	if info.Permission == info.OldPermission {
+		return nil
+	}
+	if err := r.Delete(DeleteInfo{
+		Version:     info.Version,
+		Username:    info.Username,
+		Permission:  info.OldPermission,
+		ForceDelete: true,
+		Timeout:     300}); err != nil {
+		return err
+	}
+	if info.Username == "root" {
+		return nil
 	}
 	if err := r.CreateUser(CreateInfo{
 		Name:       info.Name,

backend/utils/mysql/client/remote.go

@@ -199,18 +199,19 @@ func (r *Remote) ChangeAccess(info AccessChangeInfo) error {
 		info.Name = "*"
 		info.Password = r.Password
 	}
-	if info.Permission != info.OldPermission {
-		if err := r.Delete(DeleteInfo{
-			Version:     info.Version,
-			Username:    info.Username,
-			Permission:  info.OldPermission,
-			ForceDelete: true,
-			Timeout:     300}); err != nil {
-			return err
-		}
-		if info.Username == "root" {
-			return nil
-		}
+	if info.Permission == info.OldPermission {
+		return nil
+	}
+	if err := r.Delete(DeleteInfo{
+		Version:     info.Version,
+		Username:    info.Username,
+		Permission:  info.OldPermission,
+		ForceDelete: true,
+		Timeout:     300}); err != nil {
+		return err
+	}
+	if info.Username == "root" {
+		return nil
 	}
 	if err := r.CreateUser(CreateInfo{
 		Name:       info.Name,

backend/utils/nginx/components/location.go

@@ -46,7 +46,9 @@ func NewLocation(directive IDirective) *Location {
 				location.Host = params[1]
 			}
 		case "proxy_cache":
-			location.Cache = true
+			if params[0] != "off" {
+				location.Cache = true
+			}
 		case "if":
 			if params[0] == "(" && params[1] == "$uri" && params[2] == "~*" {
 				dirs := dir.GetBlock().GetDirectives()

backend/utils/nginx/components/server.go

@@ -265,6 +265,53 @@ func (s *Server) UpdateRootProxy(proxy []string) {
 	s.UpdateDirectiveBySecondKey("location", "/", newDir)
 }
 
+func (s *Server) UpdateRootProxyForAi(proxy []string) {
+	newDir := Directive{
+		Name:       "location",
+		Parameters: []string{"/"},
+		Block:      &Block{},
+	}
+	block := &Block{}
+	block.Directives = []IDirective{
+		&Directive{
+			Name: "proxy_buffering",
+			Parameters: []string{
+				"off",
+			},
+		},
+		&Directive{
+			Name: "proxy_cache",
+			Parameters: []string{
+				"off",
+			},
+		},
+		&Directive{
+			Name: "proxy_http_version",
+			Parameters: []string{
+				"1.1",
+			},
+		},
+		&Directive{
+			Name: "proxy_set_header",
+			Parameters: []string{
+				"Connection", "''",
+			},
+		},
+		&Directive{
+			Name: "chunked_transfer_encoding",
+			Parameters: []string{
+				"off",
+			},
+		},
+	}
+	block.Directives = append(block.Directives, &Directive{
+		Name:       "proxy_pass",
+		Parameters: proxy,
+	})
+	newDir.Block = block
+	s.UpdateDirectiveBySecondKey("location", "/", newDir)
+}
+
 func (s *Server) UpdatePHPProxy(proxy []string, localPath string) {
 	newDir := Directive{
 		Name:       "location",
@@ -369,3 +416,30 @@ func (s *Server) AddHTTP2HTTPS() {
 	newDir.Block = block
 	s.UpdateDirectiveBySecondKey("if", "($scheme", newDir)
 }
+
+func (s *Server) UpdateAllowIPs(ips []string) {
+	index := -1
+	for i, directive := range s.Directives {
+		if directive.GetName() == "location" && directive.GetParameters()[0] == "/" {
+			index = i
+			break
+		}
+	}
+	ipDirectives := make([]IDirective, 0)
+	for _, ip := range ips {
+		ipDirectives = append(ipDirectives, &Directive{
+			Name:       "allow",
+			Parameters: []string{ip},
+		})
+	}
+	ipDirectives = append(ipDirectives, &Directive{
+		Name:       "deny",
+		Parameters: []string{"all"},
+	})
+	if index != -1 {
+		newDirectives := append(ipDirectives, s.Directives[index:]...)
+		s.Directives = append(s.Directives[:index], newDirectives...)
+	} else {
+		s.Directives = append(s.Directives, ipDirectives...)
+	}
+}

backend/utils/ssh/ssh.go

@@ -1,11 +1,8 @@
 package ssh
 
 import (
-	"bytes"
 	"fmt"
-	"io"
 	"strings"
-	"sync"
 	"time"
 
 	gossh "golang.org/x/crypto/ssh"
@@ -82,58 +79,6 @@ func (c *ConnInfo) Close() {
 	_ = c.Client.Close()
 }
 
-type SshConn struct {
-	StdinPipe   io.WriteCloser
-	ComboOutput *wsBufferWriter
-	Session     *gossh.Session
-}
-
-func (c *ConnInfo) NewSshConn(cols, rows int) (*SshConn, error) {
-	sshSession, err := c.Client.NewSession()
-	if err != nil {
-		return nil, err
-	}
-
-	stdinP, err := sshSession.StdinPipe()
-	if err != nil {
-		return nil, err
-	}
-
-	comboWriter := new(wsBufferWriter)
-	sshSession.Stdout = comboWriter
-	sshSession.Stderr = comboWriter
-
-	modes := gossh.TerminalModes{
-		gossh.ECHO:          1,
-		gossh.TTY_OP_ISPEED: 14400,
-		gossh.TTY_OP_OSPEED: 14400,
-	}
-	if err := sshSession.RequestPty("xterm", rows, cols, modes); err != nil {
-		return nil, err
-	}
-	if err := sshSession.Shell(); err != nil {
-		return nil, err
-	}
-	return &SshConn{StdinPipe: stdinP, ComboOutput: comboWriter, Session: sshSession}, nil
-}
-
-func (s *SshConn) Close() {
-	if s.Session != nil {
-		s.Session.Close()
-	}
-}
-
-type wsBufferWriter struct {
-	buffer bytes.Buffer
-	mu     sync.Mutex
-}
-
-func (w *wsBufferWriter) Write(p []byte) (int, error) {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-	return w.buffer.Write(p)
-}
-
 func makePrivateKeySigner(privateKey []byte, passPhrase []byte) (gossh.Signer, error) {
 	if len(passPhrase) != 0 {
 		return gossh.ParsePrivateKeyWithPassphrase(privateKey, passPhrase)

backend/utils/ssl/client.go

@@ -3,11 +3,14 @@ package ssl
 import (
 	"crypto"
 	"encoding/json"
-	"github.com/go-acme/lego/v4/providers/dns/rainyun"
+	"github.com/go-acme/lego/v4/providers/dns/westcn"
 	"os"
 	"strings"
 	"time"
 
+	"github.com/go-acme/lego/v4/providers/dns/freemyip"
+	"github.com/go-acme/lego/v4/providers/dns/rainyun"
+
 	"github.com/1Panel-dev/1Panel/backend/app/model"
 	"github.com/go-acme/lego/v4/acme"
 	"github.com/go-acme/lego/v4/acme/api"
@@ -18,6 +21,7 @@ import (
 	"github.com/go-acme/lego/v4/providers/dns/alidns"
 	"github.com/go-acme/lego/v4/providers/dns/clouddns"
 	"github.com/go-acme/lego/v4/providers/dns/cloudflare"
+	"github.com/go-acme/lego/v4/providers/dns/cloudns"
 	"github.com/go-acme/lego/v4/providers/dns/dnspod"
 	"github.com/go-acme/lego/v4/providers/dns/godaddy"
 	"github.com/go-acme/lego/v4/providers/dns/huaweicloud"
@@ -73,6 +77,8 @@ const (
 	Volcengine   DnsType = "Volcengine"
 	CloudFlare   DnsType = "CloudFlare"
 	CloudDns     DnsType = "CloudDns"
+	ClouDNS      DnsType = "ClouDNS"
+	FreeMyIP     DnsType = "FreeMyIP"
 	NameSilo     DnsType = "NameSilo"
 	NameCheap    DnsType = "NameCheap"
 	NameCom      DnsType = "NameCom"
@@ -80,21 +86,26 @@ const (
 	TencentCloud DnsType = "TencentCloud"
 	HuaweiCloud  DnsType = "HuaweiCloud"
 	RainYun      DnsType = "RainYun"
+	WestCN       DnsType = "WestCN"
 )
 
 type DNSParam struct {
-	ID        string `json:"id"`
-	Token     string `json:"token"`
-	AccessKey string `json:"accessKey"`
-	SecretKey string `json:"secretKey"`
-	Email     string `json:"email"`
-	APIkey    string `json:"apiKey"`
-	APIUser   string `json:"apiUser"`
-	APISecret string `json:"apiSecret"`
-	SecretID  string `json:"secretID"`
-	Region    string `json:"region"`
-	ClientID  string `json:"clientID"`
-	Password  string `json:"password"`
+	ID           string `json:"id"`
+	Token        string `json:"token"`
+	AccessKey    string `json:"accessKey"`
+	SecretKey    string `json:"secretKey"`
+	Email        string `json:"email"`
+	APIkey       string `json:"apiKey"`
+	APIUser      string `json:"apiUser"`
+	APISecret    string `json:"apiSecret"`
+	SecretID     string `json:"secretID"`
+	Region       string `json:"region"`
+	ClientID     string `json:"clientID"`
+	Password     string `json:"password"`
+	AuthID       string `json:"authID"`
+	SubAuthID    string `json:"subAuthID"`
+	AuthPassword string `json:"authPassword"`
+	Username     string `json:"username"`
 }
 
 var (
@@ -155,6 +166,21 @@ func (c *AcmeClient) UseDns(dnsType DnsType, params string, websiteSSL model.Web
 		clouddnsConfig.PollingInterval = pollingInterval
 		clouddnsConfig.TTL = ttl
 		p, err = clouddns.NewDNSProviderConfig(clouddnsConfig)
+	case ClouDNS:
+		cloudnsConfig := cloudns.NewDefaultConfig()
+		cloudnsConfig.AuthID = param.AuthID
+		cloudnsConfig.SubAuthID = param.SubAuthID
+		cloudnsConfig.AuthPassword = param.AuthPassword
+		cloudnsConfig.PropagationTimeout = propagationTimeout
+		cloudnsConfig.PollingInterval = pollingInterval
+		cloudnsConfig.TTL = ttl
+		p, err = cloudns.NewDNSProviderConfig(cloudnsConfig)
+	case FreeMyIP:
+		freeMyIpConfig := freemyip.NewDefaultConfig()
+		freeMyIpConfig.Token = param.Token
+		freeMyIpConfig.PropagationTimeout = propagationTimeout
+		freeMyIpConfig.PollingInterval = pollingInterval
+		p, err = freemyip.NewDNSProviderConfig(freeMyIpConfig)
 	case NameCheap:
 		namecheapConfig := namecheap.NewDefaultConfig()
 		namecheapConfig.APIKey = param.APIkey
@@ -210,6 +236,14 @@ func (c *AcmeClient) UseDns(dnsType DnsType, params string, websiteSSL model.Web
 		rainyunConfig.PollingInterval = pollingInterval
 		rainyunConfig.TTL = ttl
 		p, err = rainyun.NewDNSProviderConfig(rainyunConfig)
+	case WestCN:
+		westcnConfig := westcn.NewDefaultConfig()
+		westcnConfig.Username = param.Username
+		westcnConfig.Password = param.Password
+		westcnConfig.PropagationTimeout = propagationTimeout
+		westcnConfig.PollingInterval = pollingInterval
+		westcnConfig.TTL = ttl
+		p, err = westcn.NewDNSProviderConfig(westcnConfig)
 	}
 	if err != nil {
 		return err

backend/utils/terminal/local_cmd.go

@@ -25,8 +25,13 @@ type LocalCommand struct {
 	pty *os.File
 }
 
-func NewCommand(commands []string) (*LocalCommand, error) {
-	cmd := exec.Command("docker", commands...)
+func NewCommand(initCmd []string) (*LocalCommand, error) {
+	cmd := exec.Command("docker", initCmd...)
+	if term := os.Getenv("TERM"); term != "" {
+		cmd.Env = append(os.Environ(), "TERM="+term)
+	} else {
+		cmd.Env = append(os.Environ(), "TERM=xterm")
+	}
 
 	pty, err := pty.Start(cmd)
 	if err != nil {
@@ -90,4 +95,5 @@ func (lcmd *LocalCommand) Wait(quitChan chan bool) {
 		global.LOG.Errorf("ssh session wait failed, err: %v", err)
 		setQuit(quitChan)
 	}
+	setQuit(quitChan)
 }

backend/utils/terminal/ws_local_session.go

@@ -53,6 +53,11 @@ func (sws *LocalWsSession) handleSlaveEvent(exitCh chan bool) {
 }
 
 func (sws *LocalWsSession) masterWrite(data []byte) error {
+	defer func() {
+		if r := recover(); r != nil {
+			global.LOG.Errorf("A panic occurred during write ws message to master, error message: %v", r)
+		}
+	}()
 	sws.writeMutex.Lock()
 	defer sws.writeMutex.Unlock()
 	wsData, err := json.Marshal(WsMsg{
@@ -72,6 +77,7 @@ func (sws *LocalWsSession) masterWrite(data []byte) error {
 func (sws *LocalWsSession) receiveWsMsg(exitCh chan bool) {
 	defer func() {
 		if r := recover(); r != nil {
+			setQuit(exitCh)
 			global.LOG.Errorf("A panic occurred during receive ws message, error message: %v", r)
 		}
 	}()

backend/utils/xpack/xpack.go

@@ -29,14 +29,6 @@ func LoadRequestTransport() *http.Transport {
 	}
 }
 
-func LoadGpuInfo() []interface{} {
-	return nil
-}
-
-func LoadXpuInfo() []interface{} {
-	return nil
-}
-
 func StartClam(startClam model.Clam, isUpdate bool) (int, error) {
 	return 0, buserr.New(constant.ErrXpackNotFound)
 }

ci/script.sh

@@ -18,11 +18,11 @@ if [ ! -f "install.sh" ]; then
 fi
 
 if [ ! -f "GeoIP.mmdb" ]; then 
-  wget https://resource.1panel.hk/geo/GeoIP.mmdb
+  wget https://resource.1panel.pro/geo/GeoIP.mmdb
 fi
 
 if [ ! -f "lang.tar.gz" ]; then 
-  wget https://resource.1panel.hk/language/lang.tar.gz
+  wget https://resource.1panel.pro/language/lang.tar.gz
   tar zxvf lang.tar.gz
   rm -rf lang.tar.gz
 fi