perf(appstore): reduce resource requests during synchronization

agent/app/api/v2/app.go

@@ -207,6 +207,7 @@ func (b *BaseApi) GetAppListUpdate(c *gin.Context) {
 // @Accept json
 // @Param key path string true "app key"
 // @Success 200 {file} file "app icon"
+// @Success 302 "redirect to the official icon URL"
 // @Security ApiKeyAuth
 // @Security Timestamp
 // @Router /apps/icon/:key [get]
@@ -216,12 +217,18 @@ func (b *BaseApi) GetAppIcon(c *gin.Context) {
 		helper.BadRequest(c, err)
 		return
 	}
-	iconBytes, filename, etag, err := appService.GetAppIcon(appKey)
+	iconBytes, source, etag, err := appService.GetAppIcon(appKey)
 	if err != nil {
 		helper.InternalServer(c, err)
 		return
 	}
 
+	if appicon.IsRemoteURL(source) {
+		c.Header("Cache-Control", "no-cache")
+		c.Redirect(http.StatusFound, source)
+		return
+	}
+
 	if len(iconBytes) == 0 {
 		c.Status(http.StatusNoContent)
 		return
@@ -229,7 +236,7 @@ func (b *BaseApi) GetAppIcon(c *gin.Context) {
 
 	c.Header("Cache-Control", "public, max-age=2592000")
 
-	if etag != "" && filename != "" {
+	if etag != "" && source != "" {
 		c.Header("ETag", etag)
 		if c.GetHeader("If-None-Match") == etag {
 			c.Status(http.StatusNotModified)

agent/app/api/v2/app_icon_test.go

@@ -0,0 +1,109 @@
+package v2
+
+import (
+	"encoding/base64"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"sync/atomic"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/appicon"
+	"github.com/gin-gonic/gin"
+	"github.com/glebarez/sqlite"
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func TestAppIconEndpointPreservesRemoteAndHistoricalSources(t *testing.T) {
+	db, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "icons.db")), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(&model.App{}, &model.AppDetail{}, &model.AppTag{}); err != nil {
+		t.Fatal(err)
+	}
+	oldDB, oldDir, oldLog := global.DB, global.Dir, global.LOG
+	global.DB = db
+	global.Dir.IconCacheDir = t.TempDir()
+	global.LOG = logrus.New()
+	global.LOG.SetOutput(io.Discard)
+	t.Cleanup(func() {
+		global.DB, global.Dir, global.LOG = oldDB, oldDir, oldLog
+		sqlDB, _ := db.DB()
+		_ = sqlDB.Close()
+	})
+
+	var imageRequests atomic.Int32
+	cdn := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		imageRequests.Add(1)
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}))
+	t.Cleanup(cdn.Close)
+	remoteURL := cdn.URL + "/icon.png?token=a%2Bb&v=42#image"
+	image := "\x89PNG\r\n\x1a\noriginal-icon"
+	fileName := "app_php.png"
+	if err := os.WriteFile(filepath.Join(global.Dir.IconCacheDir, fileName), []byte(image), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	app := model.App{Key: "php", Resource: constant.AppResourceRemote}
+	if err := db.Create(&app).Error; err != nil {
+		t.Fatal(err)
+	}
+	router := gin.New()
+	router.GET("/api/v2/apps/icon/:key", (&BaseApi{}).GetAppIcon)
+	for _, tc := range []struct {
+		name        string
+		icon        string
+		ifNoneMatch string
+		status      int
+		body        string
+		etag        string
+	}{
+		{"remote URL", remoteURL, "", http.StatusFound, "", ""},
+		{"remote URL ignores legacy etag", remoteURL, `"old"`, http.StatusFound, "", ""},
+		{"historical file", appicon.BuildIconField(fileName, `"42"`), "", http.StatusOK, image, `"42"`},
+		{"historical file cached", appicon.BuildIconField(fileName, `"42"`), `"42"`, http.StatusNotModified, "", `"42"`},
+		{"historical file changed", appicon.BuildIconField(fileName, `"42"`), `"old"`, http.StatusOK, image, `"42"`},
+		{"historical base64", base64.StdEncoding.EncodeToString([]byte(image)), "", http.StatusOK, image, ""},
+		{"missing file", "app_missing.png?etag=old", "", http.StatusNoContent, "", ""},
+		{"invalid base64", "not-an-icon", "", http.StatusNoContent, "", ""},
+		{"invalid URL", "javascript:alert(1)", "", http.StatusNoContent, "", ""},
+		{"empty icon", "", "", http.StatusNoContent, "", ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if err := db.Model(&app).UpdateColumn("icon", tc.icon).Error; err != nil {
+				t.Fatal(err)
+			}
+			req := httptest.NewRequest(http.MethodGet, "/api/v2/apps/icon/php?operateNode=child", nil)
+			req.Header.Set("If-None-Match", tc.ifNoneMatch)
+			res := httptest.NewRecorder()
+			router.ServeHTTP(res, req)
+			if res.Code != tc.status {
+				t.Fatalf("status = %d, want %d; body = %s", res.Code, tc.status, res.Body.String())
+			}
+			if res.Header().Get("ETag") != tc.etag {
+				t.Fatalf("etag = %q, want %q", res.Header().Get("ETag"), tc.etag)
+			}
+			if tc.status == http.StatusFound {
+				if res.Header().Get("Location") != remoteURL || res.Header().Get("Cache-Control") != "no-cache" {
+					t.Fatalf("redirect URL or cache policy was changed: %v", res.Header())
+				}
+			} else if res.Body.String() != tc.body {
+				t.Fatalf("body = %q, want %q", res.Body.String(), tc.body)
+			}
+			if imageRequests.Load() != 0 {
+				t.Fatalf("icon endpoint fetched the image %d times", imageRequests.Load())
+			}
+		})
+	}
+}

agent/app/api/v2/app_install.go

@@ -203,6 +203,7 @@ func (b *BaseApi) GetServices(c *gin.Context) {
 // @Tags App
 // @Summary Search app update version by install id
 // @Accept json
+// @Param request body request.AppUpdateVersion true "request"
 // @Success 200 {array} dto.AppVersion
 // @Security ApiKeyAuth
 // @Security Timestamp

agent/app/api/v2/container_image_check_update.go

@@ -1,43 +0,0 @@
-package v2
-
-import (
-	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
-	"github.com/1Panel-dev/1Panel/agent/app/service"
-	"github.com/gin-gonic/gin"
-)
-
-func (b *BaseApi) GetContainerImageCheckUpdateStatus(c *gin.Context) {
-	status, err := service.GetContainerImageCheckUpdateStatus()
-	if err != nil {
-		helper.InternalServer(c, err)
-		return
-	}
-	helper.SuccessWithData(c, status)
-}
-func (b *BaseApi) ContainerImageCheckUpdate(c *gin.Context) {
-	taskID, err := service.StartContainerImageCheckUpdate()
-	if err != nil {
-		helper.InternalServer(c, err)
-		return
-	}
-	status, err := service.GetContainerImageCheckUpdateStatus()
-	if err != nil {
-		helper.InternalServer(c, err)
-		return
-	}
-	status.TaskID = taskID
-	helper.SuccessWithData(c, status)
-}
-func (b *BaseApi) SetContainerImageCheckUpdateSchedule(c *gin.Context) {
-	var req struct {
-		Enabled *bool `json:"enabled" validate:"required"`
-	}
-	if err := helper.CheckBindAndValidate(&req, c); err != nil {
-		return
-	}
-	if err := service.SetContainerImageCheckUpdateSchedule(*req.Enabled); err != nil {
-		helper.InternalServer(c, err)
-		return
-	}
-	b.GetContainerImageCheckUpdateStatus(c)
-}

agent/app/api/v2/image_remote.go

@@ -1,16 +0,0 @@
-package v2
-
-import (
-	"github.com/1Panel-dev/1Panel/agent/app/api/v2/helper"
-	"github.com/1Panel-dev/1Panel/agent/app/service"
-	"github.com/gin-gonic/gin"
-)
-
-func (b *BaseApi) GetImageRemoteCheckStatus(c *gin.Context) {
-	status, err := service.GetImageRemoteCheckStatus()
-	if err != nil {
-		helper.InternalServer(c, err)
-		return
-	}
-	helper.SuccessWithData(c, status)
-}

agent/app/dto/container.go

@@ -21,16 +21,13 @@ type InspectReq struct {
 }
 
 type ContainerInfo struct {
-	LatestVersion string `json:"latestVersion"`
+	ContainerID string `json:"containerID"`
-	TargetImage   string `json:"targetImage"`
+	Name        string `json:"name"`
-	HasUpdate     bool   `json:"hasUpdate"`
+	ImageId     string `json:"imageID"`
-	ContainerID   string `json:"containerID"`
+	ImageName   string `json:"imageName"`
-	Name          string `json:"name"`
+	CreateTime  string `json:"createTime"`
-	ImageId       string `json:"imageID"`
+	State       string `json:"state"`
-	ImageName     string `json:"imageName"`
+	RunTime     string `json:"runTime"`
-	CreateTime    string `json:"createTime"`
-	State         string `json:"state"`
-	RunTime       string `json:"runTime"`
 
 	Network []string `json:"network"`
 	Ports   []string `json:"ports"`

agent/app/dto/request/app.go

@@ -156,6 +156,7 @@ type PortUpdate struct {
 type AppUpdateVersion struct {
 	AppInstallID  uint   `json:"appInstallID" validate:"required"`
 	UpdateVersion string `json:"updateVersion"`
+	LoadCompose   *bool  `json:"loadCompose,omitempty"`
 }
 
 type AppInstallSortItem struct {

agent/app/dto/response/app.go

@@ -31,6 +31,7 @@ type AppDTO struct {
 type AppItem struct {
 	Name                string   `json:"name"`
 	Key                 string   `json:"key"`
+	Icon                string   `json:"icon,omitempty"`
 	ID                  uint     `json:"id"`
 	Description         string   `json:"description"`
 	Status              string   `json:"status"`
@@ -194,5 +195,6 @@ type AppConfig struct {
 	ModelAccountBaseURL     string     `json:"modelAccountBaseURL"`
 	Params                  []AppParam `json:"params"`
 	RawCompose              string     `json:"rawCompose"`
+	IsEdit                  bool       `json:"isEdit"`
 	request.AppContainerConfig
 }

agent/app/model/container_image_check_update.go

@@ -1,20 +0,0 @@
-package model
-
-import "time"
-
-// ContainerImageCheckUpdate is a cache tied to the exact image used by a container.
-type ContainerImageCheckUpdate struct {
-	ContainerID   string    `gorm:"primaryKey" json:"containerID"`
-	ImageID       string    `json:"imageID"`
-	ImageName     string    `json:"imageName"`
-	LatestVersion string    `json:"latestVersion"`
-	TargetImage   string    `json:"targetImage"`
-	TargetImageID string    `json:"-"`
-	HasUpdate     bool      `gorm:"not null;default:false" json:"hasUpdate"`
-	CheckedAt     time.Time `json:"checkedAt"`
-	CheckStatus   string    `json:"checkStatus"`
-	CheckError    string    `json:"checkError"`
-}
-
-// TableName preserves the table created by the original migration.
-func (ContainerImageCheckUpdate) TableName() string { return "container_image_updates" }

agent/app/repo/app.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 )
@@ -30,6 +31,7 @@ type IAppRepo interface {
 	BatchCreate(ctx context.Context, apps []model.App) error
 	Create(ctx context.Context, app *model.App) error
 	Save(ctx context.Context, app *model.App) error
+	UpdateIcon(id uint, icon string) error
 	BatchDelete(ctx context.Context, apps []model.App) error
 	DeleteByIDs(ctx context.Context, ids []uint) error
 	DeleteBy(opts ...DBOption) error
@@ -41,6 +43,10 @@ func NewIAppRepo() IAppRepo {
 	return &AppRepo{}
 }
 
+func (a AppRepo) UpdateIcon(id uint, icon string) error {
+	return getDb(WithByID(id), a.WithResource(constant.AppResourceRemote)).Model(&model.App{}).UpdateColumn("icon", icon).Error
+}
+
 func (a AppRepo) WithByLikeName(name string) DBOption {
 	return func(g *gorm.DB) *gorm.DB {
 		if len(name) == 0 {

agent/app/repo/app_detail.go

@@ -17,6 +17,8 @@ type IAppDetailRepo interface {
 	WithIgnored() DBOption
 	GetFirst(opts ...DBOption) (model.AppDetail, error)
 	Update(ctx context.Context, detail model.AppDetail) error
+	CacheCompose(detail model.AppDetail, compose string) (bool, error)
+	MarkDownloaded(detail model.AppDetail) (bool, error)
 	BatchCreate(ctx context.Context, details []model.AppDetail) error
 	DeleteByAppIds(ctx context.Context, appIds []uint) error
 	DeleteByIDs(ctx context.Context, appIds []uint) error
@@ -57,6 +59,20 @@ func (a AppDetailRepo) Update(ctx context.Context, detail model.AppDetail) error
 	return getTx(ctx).Save(&detail).Error
 }
 
+func (a AppDetailRepo) CacheCompose(detail model.AppDetail, compose string) (bool, error) {
+	result := getDb().Model(&model.AppDetail{}).
+		Where("id = ? AND last_modified = ? AND params = ? AND download_url = ?", detail.ID, detail.LastModified, detail.Params, detail.DownloadUrl).
+		UpdateColumn("docker_compose", compose)
+	return result.RowsAffected > 0, result.Error
+}
+
+func (a AppDetailRepo) MarkDownloaded(detail model.AppDetail) (bool, error) {
+	result := getDb().Model(&model.AppDetail{}).
+		Where("id = ? AND last_modified = ? AND params = ? AND download_url = ?", detail.ID, detail.LastModified, detail.Params, detail.DownloadUrl).
+		UpdateColumn("update", false)
+	return result.RowsAffected > 0, result.Error
+}
+
 func (a AppDetailRepo) BatchCreate(ctx context.Context, details []model.AppDetail) error {
 	return getTx(ctx).Model(&model.AppDetail{}).Create(&details).Error
 }

agent/app/service/app.go

@@ -135,6 +135,7 @@ func (a AppService) PageApp(ctx *gin.Context, req request.AppSearch) (*response.
 			ID:                  ap.ID,
 			Name:                ap.Name,
 			Key:                 ap.Key,
+			Icon:                appicon.RemoteURL(ap.Icon),
 			Limit:               ap.Limit,
 			GpuSupport:          ap.GpuSupport,
 			Recommend:           ap.Recommend,
@@ -262,10 +263,20 @@ func (a AppService) GetAppDetail(appID uint, version, appType string) (response.
 		if err = downloadApp(app, detail, nil, nil); err != nil && !fileOp.Stat(versionPath) {
 			return appDetailDTO, err
 		}
-		if err == nil && app.Resource == constant.AppResourceRemote {
+		packageReady := err == nil
+		if packageReady && app.Resource == constant.AppResourceRemote {
 			detail.Update = false
 			appDetailDTO.Update = false
 		}
+		if packageReady && strings.TrimSpace(detail.DockerCompose) == "" {
+			compose, err := fileOp.GetContent(filepath.Join(versionPath, "docker-compose.yml"))
+			if err != nil {
+				return appDetailDTO, err
+			}
+			if err := cacheAppDetailCompose(&detail, compose); err != nil {
+				return appDetailDTO, err
+			}
+		}
 		switch app.Type {
 		case constant.RuntimePHP:
 			paramMap := make(map[string]interface{})
@@ -296,15 +307,17 @@ func (a AppService) GetAppDetail(appID uint, version, appType string) (response.
 			if err != nil {
 				return appDetailDTO, err
 			}
-			composeMap := make(map[string]interface{})
+			if err := validateAppDetailCompose(compose); err != nil {
+				return appDetailDTO, err
+			}
+			var composeMap struct {
+				Services map[string]interface{} `yaml:"services"`
+			}
 			if err := yaml.Unmarshal(compose, &composeMap); err != nil {
 				return appDetailDTO, err
 			}
-			if service, ok := composeMap["services"]; ok {
+			for k := range composeMap.Services {
-				servicesMap := service.(map[string]interface{})
+				appDetailDTO.Image = k
-				for k := range servicesMap {
-					appDetailDTO.Image = k
-				}
 			}
 		}
 	} else {
@@ -315,29 +328,10 @@ func (a AppService) GetAppDetail(appID uint, version, appType string) (response.
 		appDetailDTO.Params = paramMap
 	}
 
-	if appDetailDTO.DockerCompose == "" {
+	if err := ensureAppDetailCompose(app, &detail); err != nil {
-		filename := filepath.Base(appDetailDTO.DownloadUrl)
+		return appDetailDTO, err
-		dockerComposeUrl := fmt.Sprintf("%s%s", strings.TrimSuffix(appDetailDTO.DownloadUrl, filename), "docker-compose.yml")
-		if app.Resource == constant.AppResourceRemote {
-			dockerComposeUrl, err = currentAppDownloadURL(dockerComposeUrl)
-			if err != nil {
-				return appDetailDTO, err
-			}
-		}
-		statusCode, composeRes, err := req_helper.HandleRequest(dockerComposeUrl, http.MethodGet, constant.TimeOut20s)
-		if statusCode == http.StatusNotFound {
-			return appDetailDTO, buserr.New("ErrAppVersionUnavailable")
-		}
-		if err != nil {
-			return appDetailDTO, buserr.WithDetail("ErrGetCompose", err.Error(), err)
-		}
-		if statusCode > 200 {
-			return appDetailDTO, buserr.WithDetail("ErrGetCompose", string(composeRes), err)
-		}
-		detail.DockerCompose = string(composeRes)
-		_ = appDetailRepo.Update(context.Background(), detail)
-		appDetailDTO.DockerCompose = string(composeRes)
 	}
+	appDetailDTO.DockerCompose = detail.DockerCompose
 
 	appDetailDTO.HostMode = isHostModel(appDetailDTO.DockerCompose)
 
@@ -355,6 +349,13 @@ func (a AppService) GetAppDetailByID(id uint) (*response.AppDetailDTO, error) {
 	if err != nil {
 		return nil, err
 	}
+	app, err := appRepo.GetFirst(repo.WithByID(appDetail.AppId))
+	if err != nil {
+		return nil, err
+	}
+	if err := ensureAppDetailCompose(app, &appDetail); err != nil {
+		return nil, err
+	}
 	res.AppDetail = appDetail
 	paramMap := make(map[string]interface{})
 	if err := json.Unmarshal([]byte(appDetail.Params), &paramMap); err != nil {
@@ -442,31 +443,13 @@ func (a AppService) installWithHooks(req request.AppInstallCreate, executeScript
 		App:         app,
 	}
 	composeMap := make(map[string]interface{})
-	var composeRes []byte
 	if req.EditCompose {
 		if err = yaml.Unmarshal([]byte(req.DockerCompose), &composeMap); err != nil {
 			return
 		}
 	} else {
-		if appDetail.DockerCompose == "" {
+		if err = ensureAppDetailCompose(app, &appDetail); err != nil {
-			dockerComposeUrl := fmt.Sprintf("%s/%s/1panel/%s/%s/docker-compose.yml", global.AppRepoURL(), global.CONF.Base.Mode, app.Key, appDetail.Version)
+			return
-			if app.Resource == constant.AppResourceRemote {
-				dockerComposeUrl, err = currentAppDownloadURL(dockerComposeUrl)
-				if err != nil {
-					return
-				}
-			}
-			var statusCode int
-			statusCode, composeRes, err = req_helper.HandleRequest(dockerComposeUrl, http.MethodGet, constant.TimeOut20s)
-			if statusCode == http.StatusNotFound {
-				err = buserr.New("ErrAppVersionUnavailable")
-				return
-			}
-			if err != nil {
-				return
-			}
-			appDetail.DockerCompose = string(composeRes)
-			_ = appDetailRepo.Update(context.Background(), appDetail)
 		}
 		if err = yaml.Unmarshal([]byte(appDetail.DockerCompose), &composeMap); err != nil {
 			return
@@ -922,22 +905,10 @@ func (a AppService) GetAppUpdate() (*response.AppUpdateRes, error) {
 		res.CanUpdate = true
 		return res, err
 	}
-	apps, _ := appRepo.GetBy(appRepo.WithResource(constant.AppResourceRemote))
+	list, err := readAppList()
-	for _, app := range apps {
+	if err != nil || list.LastModified != lastModified {
-		if app.Icon == "" {
+		list, err = getAppList()
-			res.CanUpdate = true
-			return res, err
-		}
-		if appicon.IsIconFile(app.Icon) {
-			fileName, _ := appicon.ParseIconField(app.Icon)
-			if fileName == "" || !appicon.IconFileExists(fileName) {
-				res.CanUpdate = true
-				return res, err
-			}
-		}
 	}
-
-	list, err := getAppList()
 	if err != nil {
 		return res, err
 	}
@@ -968,29 +939,26 @@ func getAppFromRepo(downloadPath string) error {
 }
 
 func getAppList() (*dto.AppList, error) {
-	list := &dto.AppList{}
 	if err := getAppFromRepo(fmt.Sprintf("%s/%s/1panel.json.zip", global.AppRepoURL(), global.CONF.Base.Mode)); err != nil {
 		return nil, err
 	}
+	return readAppList()
+}
+
+func readAppList() (*dto.AppList, error) {
 	listFile := filepath.Join(global.Dir.ResourceDir, "1panel.json")
-	file, err := os.Open(listFile)
+	data, err := os.ReadFile(listFile)
 	if err != nil {
 		return nil, err
 	}
-	defer file.Close()
+	list := &dto.AppList{}
-	if err = json.NewDecoder(file).Decode(list); err != nil {
+	if err = json.Unmarshal(data, list); err != nil {
 		return nil, err
 	}
 
 	return list, nil
 }
 
-var InitTypes = map[string]struct{}{
-	"runtime": {},
-	"php":     {},
-	"node":    {},
-}
-
 func deleteCustomApp() {
 	installs, err := appInstallRepo.ListBy(context.Background())
 	if err != nil {
@@ -1088,6 +1056,10 @@ func (a AppService) GetAppIcon(key string) ([]byte, string, string, error) {
 		return nil, "", "", err
 	}
 
+	if appicon.IsRemoteURL(app.Icon) {
+		return nil, app.Icon, "", nil
+	}
+
 	if appicon.IsIconFile(app.Icon) {
 		fileName, etag := appicon.ParseIconField(app.Icon)
 		iconBytes, err := appicon.ReadIconFile(fileName)

agent/app/service/app_cache_test.go

@@ -0,0 +1,341 @@
+package service
+
+import (
+	"archive/tar"
+	"bytes"
+	"compress/gzip"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sync/atomic"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/glebarez/sqlite"
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/logger"
+)
+
+func appCacheTestDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	db, err := gorm.Open(sqlite.Open(filepath.Join(t.TempDir(), "cache.db")), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.AutoMigrate(&model.App{}, &model.AppDetail{}, &model.AppTag{}, &model.Setting{}); err != nil {
+		t.Fatal(err)
+	}
+	oldDB, oldDir, oldLog := global.DB, global.Dir, global.LOG
+	global.DB = db
+	global.Dir = global.SystemDir{AppResourceDir: t.TempDir()}
+	global.Dir.RemoteAppResourceDir = filepath.Join(global.Dir.AppResourceDir, constant.AppResourceRemote)
+	global.Dir.LocalAppResourceDir = filepath.Join(global.Dir.AppResourceDir, constant.AppResourceLocal)
+	global.Dir.CustomAppResourceDir = filepath.Join(global.Dir.AppResourceDir, constant.AppResourceCustom)
+	global.LOG = logrus.New()
+	global.LOG.SetOutput(io.Discard)
+	t.Cleanup(func() {
+		global.DB, global.Dir, global.LOG = oldDB, oldDir, oldLog
+		sqlDB, err := db.DB()
+		if err == nil {
+			_ = sqlDB.Close()
+		}
+	})
+	if err := db.Create(&model.Setting{Key: "AppStoreLastModified", Value: "42"}).Error; err != nil {
+		t.Fatal(err)
+	}
+	return db
+}
+
+func appCacheTestArchive(t *testing.T, name, content string) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	gz := gzip.NewWriter(&buf)
+	tw := tar.NewWriter(gz)
+	if err := tw.WriteHeader(&tar.Header{Name: name, Mode: 0644, Size: int64(len(content))}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := io.WriteString(tw, content); err != nil {
+		t.Fatal(err)
+	}
+	if err := tw.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := gz.Close(); err != nil {
+		t.Fatal(err)
+	}
+	return buf.Bytes()
+}
+
+func appCacheTestWrite(t *testing.T, name, content string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(name), 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(name, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestAppDownloadURLPreservesSourceQuery(t *testing.T) {
+	for _, rawURL := range []string{
+		"https://apps.1panel.pro/php/8/php-8.tar.gz",
+		"https://apps.1panel.pro/php/8/php-8.tar.gz?token=a%2Bb&region=intl&v=old#archive",
+	} {
+		t.Run(rawURL, func(t *testing.T) {
+			got, err := appDownloadURL(rawURL, "42 /next")
+			if err != nil {
+				t.Fatal(err)
+			}
+			parsed, err := url.Parse(got)
+			if err != nil {
+				t.Fatal(err)
+			}
+			original, _ := url.Parse(rawURL)
+			wantQuery := original.Query()
+			wantQuery.Set("v", "42 /next")
+			if !reflect.DeepEqual(parsed.Query(), wantQuery) || parsed.Path != original.Path || parsed.Fragment != original.Fragment {
+				t.Fatalf("download URL lost source fields: %s", got)
+			}
+		})
+	}
+	if _, err := appDownloadURL("https://apps.1panel.pro/%zz", "42"); err == nil {
+		t.Fatal("invalid source URL was accepted")
+	}
+}
+
+func TestDownloadAppRefreshesAllOfficialCachedPackages(t *testing.T) {
+	db := appCacheTestDB(t)
+	app := model.App{Key: "mysql", Name: "MySQL", Type: "website", Resource: constant.AppResourceRemote}
+	versionDir := filepath.Join(app.GetAppResourcePath(), "8")
+	dataPath := filepath.Join(versionDir, "data.yml")
+	stampPath := filepath.Join(versionDir, ".1panel-appstore-version")
+	appCacheTestWrite(t, dataPath, "stale")
+	archives := map[string][]byte{
+		"42": appCacheTestArchive(t, "mysql/8/data.yml", "fresh-42"),
+		"43": appCacheTestArchive(t, "mysql/8/data.yml", "fresh-43"),
+	}
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		if r.URL.Query().Get("token") != "a+b" || r.URL.Query().Get("region") != "intl" {
+			t.Errorf("source query was lost: %s", r.URL.RawQuery)
+		}
+		version := r.URL.Query().Get("v")
+		if version != "42" && version != "43" {
+			t.Errorf("unexpected app store version: %q", version)
+		}
+		_, _ = w.Write(archives[version])
+	}))
+	t.Cleanup(server.Close)
+	detail := model.AppDetail{Version: "8", DownloadUrl: server.URL + "/mysql-8.tar.gz?token=a%2Bb&region=intl", Update: false}
+	if err := db.Create(&detail).Error; err != nil {
+		t.Fatal(err)
+	}
+	for _, step := range []struct {
+		version string
+		calls   int32
+		update  bool
+	}{
+		{"42", 1, false}, // An existing directory without a stamp must be refreshed.
+		{"42", 1, false},
+		{"43", 2, false},
+		{"43", 3, true},
+	} {
+		if err := db.Model(&model.Setting{}).Where("key = ?", "AppStoreLastModified").Update("value", step.version).Error; err != nil {
+			t.Fatal(err)
+		}
+		detail.Update = step.update
+		if err := db.Model(&detail).UpdateColumn("update", detail.Update).Error; err != nil {
+			t.Fatal(err)
+		}
+		if err := downloadApp(app, detail, nil, nil); err != nil {
+			t.Fatal(err)
+		}
+		if calls.Load() != step.calls {
+			t.Fatalf("version %s: HTTP calls = %d, want %d", step.version, calls.Load(), step.calls)
+		}
+		for name, want := range map[string]string{dataPath: "fresh-" + step.version, stampPath: step.version} {
+			data, err := os.ReadFile(name)
+			if err != nil || string(data) != want {
+				t.Fatalf("%s = %q, %v; want %q", name, data, err, want)
+			}
+		}
+		var stored model.AppDetail
+		if err := db.First(&stored, detail.ID).Error; err != nil {
+			t.Fatal(err)
+		}
+		if stored.Update || stored.DownloadUrl != detail.DownloadUrl {
+			t.Fatalf("refresh altered source URL or left update flag: %+v", stored)
+		}
+	}
+}
+
+func TestDownloadAppFailureKeepsCacheVersionAndUpdateFlag(t *testing.T) {
+	for _, failure := range []string{"download", "decompress"} {
+		t.Run(failure, func(t *testing.T) {
+			db := appCacheTestDB(t)
+			app := model.App{Key: "mysql", Resource: constant.AppResourceRemote}
+			stampPath := filepath.Join(app.GetAppResourcePath(), "8", ".1panel-appstore-version")
+			appCacheTestWrite(t, stampPath, "41")
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if failure == "download" {
+					w.WriteHeader(http.StatusServiceUnavailable)
+					return
+				}
+				_, _ = io.WriteString(w, "not an archive")
+			}))
+			t.Cleanup(server.Close)
+			detail := model.AppDetail{Version: "8", DownloadUrl: server.URL + "/mysql-8.tar.gz", Update: true}
+			if err := db.Create(&detail).Error; err != nil {
+				t.Fatal(err)
+			}
+			install := model.AppInstall{}
+			if err := downloadApp(app, detail, &install, nil); err == nil {
+				t.Fatal("failed refresh was accepted")
+			}
+			if install.Status != constant.StatusDownloadErr || install.Message == "" {
+				t.Fatalf("installation did not report refresh failure: %+v", install)
+			}
+			stamp, err := os.ReadFile(stampPath)
+			if err != nil || string(stamp) != "41" {
+				t.Fatalf("failed refresh updated stamp: %q, %v", stamp, err)
+			}
+			var stored model.AppDetail
+			if err := db.First(&stored, detail.ID).Error; err != nil {
+				t.Fatal(err)
+			}
+			if !stored.Update || stored.DownloadUrl != detail.DownloadUrl {
+				t.Fatalf("failed refresh changed database state: %+v", stored)
+			}
+		})
+	}
+}
+
+func TestGetPHPAppDetailUsesSynchronizedOfficialParams(t *testing.T) {
+	const oldYAML = "additionalProperties:\n  formFields:\n    - envKey: PHP_VERSION\n      type: select\n      default: 8.1.34\n"
+	const newJSON = `{"formFields":[{"envKey":"PHP_VERSION","type":"select","default":"8.1.35"}]}`
+	const compose = "services:\n  php:\n    image: php:test\n"
+	for _, tc := range []struct {
+		name, resource, compose string
+		update                  bool
+	}{
+		{"remote", constant.AppResourceRemote, compose, false},
+		{"local", constant.AppResourceLocal, compose, false},
+		{"custom", constant.AppResourceCustom, compose, false},
+		{"remote-fetches-compose", constant.AppResourceRemote, "", true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			db := appCacheTestDB(t)
+			app := model.App{Key: "php", Name: "PHP", Type: constant.RuntimePHP, Resource: tc.resource}
+			if err := db.Omit(clause.Associations).Create(&app).Error; err != nil {
+				t.Fatal(err)
+			}
+			versionDir := filepath.Join(app.GetAppResourcePath(), "8")
+			appCacheTestWrite(t, filepath.Join(versionDir, "data.yml"), oldYAML)
+			appCacheTestWrite(t, filepath.Join(versionDir, "docker-compose.yml"), compose)
+			archive := appCacheTestArchive(t, "php/8/data.yml", oldYAML)
+			var calls atomic.Int32
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				calls.Add(1)
+				if r.URL.Query().Get("v") != "42" {
+					t.Errorf("missing app store version: %s", r.URL.RawQuery)
+				}
+				if r.URL.Path == "/docker-compose.yml" {
+					_, _ = io.WriteString(w, compose)
+					return
+				}
+				_, _ = w.Write(archive)
+			}))
+			t.Cleanup(server.Close)
+			detail := model.AppDetail{AppId: app.ID, Version: "8", Params: newJSON, DockerCompose: tc.compose, Update: tc.update, DownloadUrl: server.URL + "/php-8.tar.gz"}
+			if err := db.Create(&detail).Error; err != nil {
+				t.Fatal(err)
+			}
+			got, err := (AppService{}).GetAppDetail(app.ID, "8", "runtime")
+			if err != nil {
+				t.Fatal(err)
+			}
+			wantVersion, wantCalls := "8.1.34", int32(0)
+			if tc.resource == constant.AppResourceRemote {
+				wantVersion, wantCalls = "8.1.35", 1
+			}
+			want := map[string]interface{}{"formFields": []interface{}{map[string]interface{}{
+				"envKey": "PHP_VERSION", "type": "select", "default": wantVersion,
+			}}}
+			if !reflect.DeepEqual(got.Params, want) || got.Image != "php" || calls.Load() != wantCalls {
+				encoded, _ := json.Marshal(got.Params)
+				t.Fatalf("params=%s, image=%s, HTTP calls=%d; want version %s, calls %d", encoded, got.Image, calls.Load(), wantVersion, wantCalls)
+			}
+			var stored model.AppDetail
+			if err := db.First(&stored, detail.ID).Error; err != nil {
+				t.Fatal(err)
+			}
+			if stored.Update || got.Update {
+				t.Fatal("fetching the compose file restored a stale update flag")
+			}
+		})
+	}
+}
+
+func TestProcessOneAppDefersComposeUntilRequested(t *testing.T) {
+	db := appCacheTestDB(t)
+	const compose = "services:\n  php:\n    image: php:test\n"
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		if r.URL.Path != "/php/8/docker-compose.yml" || r.URL.Query().Get("v") != "42" {
+			t.Errorf("unversioned initial compose request: %s", r.URL.String())
+		}
+		_, _ = io.WriteString(w, compose)
+	}))
+	t.Cleanup(server.Close)
+	app := model.App{Key: "php", Type: constant.RuntimePHP, Resource: constant.AppResourceRemote}
+	if err := db.Create(&app).Error; err != nil {
+		t.Fatal(err)
+	}
+	ctx := appSyncContext{
+		baseRemoteUrl: server.URL,
+		systemVersion: "2.4.0",
+		list:          &dto.AppList{LastModified: 42},
+	}
+	result := ctx.processOneApp(appWorkItem{
+		app: app,
+		appDef: dto.AppDefine{
+			AppProperty: dto.AppProperty{Key: "php", Type: constant.RuntimePHP},
+			Versions: []dto.AppConfigVersion{{Name: "8", AppForm: dto.AppForm{
+				FormFields: []dto.AppFormFields{{EnvKey: "PHP_VERSION", Default: "8.1.35", Type: "select"}},
+			}}},
+		},
+	})
+	if calls.Load() != 0 || len(result.Details) != 1 {
+		t.Fatalf("initial compose refresh failed: calls=%d, result=%+v", calls.Load(), result)
+	}
+	detail := result.Details[0]
+	if detail.DockerCompose != "" || detail.DownloadUrl != server.URL+"/php/8/php-8.tar.gz" {
+		t.Fatalf("sync fetched compose or changed the canonical archive URL: %+v", detail)
+	}
+	detail.AppId = app.ID
+	if err := db.Create(&detail).Error; err != nil {
+		t.Fatal(err)
+	}
+	for range 2 {
+		if err := ensureAppDetailCompose(app, &detail); err != nil {
+			t.Fatal(err)
+		}
+		if calls.Load() != 1 || detail.DockerCompose != compose {
+			t.Fatalf("on-demand compose did not download once and cache: calls=%d, detail=%+v", calls.Load(), detail)
+		}
+	}
+}

agent/app/service/app_compose.go

@@ -0,0 +1,89 @@
+package service
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/buserr"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/req_helper"
+	"gopkg.in/yaml.v3"
+)
+
+func ensureAppDetailCompose(app model.App, detail *model.AppDetail) error {
+	if strings.TrimSpace(detail.DockerCompose) != "" && validateAppDetailCompose([]byte(detail.DockerCompose)) == nil {
+		return nil
+	}
+	var content []byte
+	var err error
+	if app.IsLocalApp() || app.IsCustomApp() {
+		content, err = os.ReadFile(filepath.Join(app.GetAppResourcePath(), detail.Version, "docker-compose.yml"))
+	} else {
+		var composeURL string
+		if detail.DownloadUrl == "" {
+			composeURL = fmt.Sprintf("%s/%s/1panel/%s/%s/docker-compose.yml", global.AppRepoURL(), global.CONF.Base.Mode, app.Key, detail.Version)
+		} else {
+			var source *url.URL
+			source, err = url.Parse(detail.DownloadUrl)
+			if err == nil {
+				source.Path = path.Join(path.Dir(source.Path), "docker-compose.yml")
+				source.RawPath = ""
+				composeURL = source.String()
+			}
+		}
+		if err == nil {
+			composeURL, err = currentAppDownloadURL(composeURL)
+		}
+		if err == nil {
+			var status int
+			status, content, err = req_helper.HandleRequest(composeURL, http.MethodGet, constant.TimeOut20s)
+			if status == http.StatusNotFound {
+				return buserr.New("ErrAppVersionUnavailable")
+			}
+		}
+	}
+	if err != nil {
+		return buserr.WithDetail("ErrGetCompose", err.Error(), err)
+	}
+	return cacheAppDetailCompose(detail, content)
+}
+
+func validateAppDetailCompose(content []byte) error {
+	var compose struct {
+		Services map[string]map[string]interface{} `yaml:"services"`
+	}
+	if err := yaml.Unmarshal(content, &compose); err != nil {
+		return buserr.WithDetail("ErrGetCompose", err.Error(), err)
+	}
+	if len(compose.Services) == 0 {
+		return buserr.WithDetail("ErrGetCompose", "docker-compose.yml has no services", nil)
+	}
+	for name, service := range compose.Services {
+		if strings.TrimSpace(name) == "" || len(service) == 0 {
+			return buserr.WithDetail("ErrGetCompose", "docker-compose.yml has an empty service", nil)
+		}
+	}
+	return nil
+}
+
+func cacheAppDetailCompose(detail *model.AppDetail, content []byte) error {
+	if err := validateAppDetailCompose(content); err != nil {
+		return err
+	}
+	stored, err := appDetailRepo.CacheCompose(*detail, string(content))
+	if err != nil {
+		return buserr.WithDetail("ErrGetCompose", err.Error(), err)
+	}
+	if !stored {
+		return buserr.WithDetail("ErrGetCompose", "application resources changed; retry the operation", nil)
+	}
+	detail.DockerCompose = string(content)
+	return nil
+}

agent/app/service/app_compose_sync_test.go

@@ -0,0 +1,70 @@
+package service
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+)
+
+func TestComposeSyncOnlyInvalidatesChangedVersionResources(t *testing.T) {
+	form := dto.AppForm{FormFields: []dto.AppFormFields{{EnvKey: "PORT", Default: 8080}}}
+	params, err := json.Marshal(form)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		_, _ = io.WriteString(w, "services:\n  demo:\n    image: demo:unexpected\n")
+	}))
+	t.Cleanup(server.Close)
+	for _, appType := range []string{"runtime", "php", "node", "java", "go", "python", "dotnet", "website"} {
+		t.Run(appType, func(t *testing.T) {
+			for _, tc := range []struct {
+				name      string
+				mutate    func(*model.AppDetail, *dto.AppConfigVersion)
+				keepCache bool
+			}{
+				{"unchanged", func(_ *model.AppDetail, _ *dto.AppConfigVersion) {}, true},
+				{"package update flag does not expire compose", func(d *model.AppDetail, _ *dto.AppConfigVersion) { d.Update = true }, true},
+				{"version revision changed", func(_ *model.AppDetail, v *dto.AppConfigVersion) { v.LastModified++ }, false},
+				{"unknown revision", func(_ *model.AppDetail, v *dto.AppConfigVersion) { v.LastModified = 0 }, false},
+				{"negative revision", func(_ *model.AppDetail, v *dto.AppConfigVersion) { v.LastModified = -1 }, false},
+				{"form changed", func(d *model.AppDetail, _ *dto.AppConfigVersion) { d.Params = `{"formFields":[]}` }, false},
+				{"source changed", func(d *model.AppDetail, _ *dto.AppConfigVersion) { d.DownloadUrl += ".old" }, false},
+				{"new version", func(d *model.AppDetail, _ *dto.AppConfigVersion) { *d = model.AppDetail{Version: "1.0"} }, false},
+			} {
+				t.Run(tc.name, func(t *testing.T) {
+					const cached = "services:\n  demo:\n    image: demo:cached\n"
+					old := model.AppDetail{Version: "1.0", LastModified: 42, Params: string(params), DownloadUrl: server.URL + "/demo/1.0/demo-1.0.tar.gz", DockerCompose: cached}
+					version := dto.AppConfigVersion{Name: "1.0", LastModified: 42, AppForm: form}
+					tc.mutate(&old, &version)
+					ctx := appSyncContext{baseRemoteUrl: server.URL, systemVersion: "2.4.0"}
+					app := model.App{Key: "demo", Type: appType, Resource: constant.AppResourceRemote, Details: []model.AppDetail{old}}
+					got := ctx.processOneApp(appWorkItem{app: app, appDef: dto.AppDefine{AppProperty: dto.AppProperty{Key: "demo"}, Versions: []dto.AppConfigVersion{version}}})
+					if len(got.Details) != 1 || calls.Load() != 0 {
+						t.Fatalf("sync fetched compose or lost version: %+v, calls=%d", got, calls.Load())
+					}
+					detail := got.Details[0]
+					want := ""
+					if tc.keepCache {
+						want = cached
+					}
+					if detail.DockerCompose != want || detail.LastModified != version.LastModified || detail.Params != string(params) || !detail.Update {
+						t.Fatalf("cache decision or version metadata changed: %+v", detail)
+					}
+					if app.Details[0].DockerCompose != old.DockerCompose {
+						t.Fatal("sync mutated its input template")
+					}
+				})
+			}
+		})
+	}
+}

agent/app/service/app_compose_test.go

@@ -0,0 +1,253 @@
+package service
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"gorm.io/gorm"
+)
+
+const composeTestTemplate = "services:\n  demo:\n    image: demo:latest\n    network_mode: host\n"
+
+func composeTestDetail(t *testing.T, resource, source string) (*gorm.DB, model.App, model.AppDetail) {
+	t.Helper()
+	db := appCacheTestDB(t)
+	app := model.App{Key: "demo", Name: "Demo", Resource: resource, Type: "website"}
+	if err := db.Create(&app).Error; err != nil {
+		t.Fatal(err)
+	}
+	detail := model.AppDetail{AppId: app.ID, Version: "1.0", LastModified: 42, Params: `{"formFields":[]}`, DownloadUrl: source}
+	if err := db.Create(&detail).Error; err != nil {
+		t.Fatal(err)
+	}
+	return db, app, detail
+}
+
+func TestComposeOnDemandLoadsOnceAndPreservesSource(t *testing.T) {
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		if r.URL.Path != "/demo/1.0/docker-compose.yml" || r.URL.Query().Get("signature") != "a+b" || r.URL.Query().Get("v") != "42" {
+			t.Errorf("unexpected Compose source: %s", r.URL)
+		}
+		_, _ = io.WriteString(w, composeTestTemplate)
+	}))
+	t.Cleanup(server.Close)
+	db, app, detail := composeTestDetail(t, constant.AppResourceRemote, server.URL+"/demo/1.0/demo-1.0.tar.gz?signature=a%2Bb")
+	for i := 0; i < 2; i++ {
+		if err := ensureAppDetailCompose(app, &detail); err != nil {
+			t.Fatal(err)
+		}
+		if calls.Load() != 1 || detail.DockerCompose != composeTestTemplate {
+			t.Fatalf("cache miss after loading: calls=%d, detail=%+v", calls.Load(), detail)
+		}
+	}
+	var stored model.AppDetail
+	if err := db.First(&stored, detail.ID).Error; err != nil {
+		t.Fatal(err)
+	}
+	if stored.DockerCompose != composeTestTemplate || stored.LastModified != 42 || stored.DownloadUrl != detail.DownloadUrl || stored.Params != detail.Params || !stored.UpdatedAt.Equal(detail.UpdatedAt) {
+		t.Fatalf("cache write altered version metadata: %+v", stored)
+	}
+	res, err := (AppService{}).GetAppDetailByID(detail.ID)
+	if err != nil || !res.HostMode || res.DockerCompose != composeTestTemplate || calls.Load() != 1 {
+		t.Fatalf("ID details did not reuse template/HostMode: %+v, %v, calls=%d", res, err, calls.Load())
+	}
+}
+
+func TestComposeOnDemandIDDetailsFillMissingTemplate(t *testing.T) {
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		_, _ = io.WriteString(w, composeTestTemplate)
+	}))
+	t.Cleanup(server.Close)
+	_, _, detail := composeTestDetail(t, constant.AppResourceRemote, server.URL+"/demo.tar.gz")
+	res, err := (AppService{}).GetAppDetailByID(detail.ID)
+	if err != nil || !res.HostMode || res.DockerCompose != composeTestTemplate || calls.Load() != 1 {
+		t.Fatalf("missing template gave wrong ID details: %+v, %v, calls=%d", res, err, calls.Load())
+	}
+}
+
+func TestComposeOnDemandLocalAndCustomUseTheirDirectories(t *testing.T) {
+	for _, resource := range []string{constant.AppResourceLocal, constant.AppResourceCustom} {
+		t.Run(resource, func(t *testing.T) {
+			var calls atomic.Int32
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { calls.Add(1) }))
+			t.Cleanup(server.Close)
+			_, app, detail := composeTestDetail(t, resource, server.URL+"/must-not-fetch.tar.gz")
+			appCacheTestWrite(t, filepath.Join(app.GetAppResourcePath(), detail.Version, "docker-compose.yml"), composeTestTemplate)
+			if err := ensureAppDetailCompose(app, &detail); err != nil {
+				t.Fatal(err)
+			}
+			if detail.DockerCompose != composeTestTemplate || calls.Load() != 0 {
+				t.Fatalf("local resource used remote template: %+v, calls=%d", detail, calls.Load())
+			}
+		})
+	}
+}
+
+func TestComposeOnDemandRejectsDownloadAndTemplateFailures(t *testing.T) {
+	for _, tc := range []struct {
+		name, body string
+		status     int
+	}{
+		{"not found", "missing", http.StatusNotFound},
+		{"server error", "failure", http.StatusServiceUnavailable},
+		{"empty", "", http.StatusOK},
+		{"HTML", "<html>blocked</html>", http.StatusOK},
+		{"malformed YAML", "services: [", http.StatusOK},
+		{"missing services", "version: '3'", http.StatusOK},
+		{"empty services", "services: {}", http.StatusOK},
+		{"empty service", "services:\n  demo:", http.StatusOK},
+		{"string service", "services:\n  demo: blocked", http.StatusOK},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(tc.status)
+				_, _ = io.WriteString(w, tc.body)
+			}))
+			t.Cleanup(server.Close)
+			db, app, detail := composeTestDetail(t, constant.AppResourceRemote, server.URL+"/demo.tar.gz")
+			if err := ensureAppDetailCompose(app, &detail); err == nil {
+				t.Fatal("invalid template was accepted")
+			}
+			var stored model.AppDetail
+			if err := db.First(&stored, detail.ID).Error; err != nil {
+				t.Fatal(err)
+			}
+			if detail.DockerCompose != "" || stored.DockerCompose != "" {
+				t.Fatal("failed response was cached")
+			}
+		})
+	}
+}
+
+func TestComposeCacheRejectsConcurrentMetadataUpdates(t *testing.T) {
+	for _, field := range []string{"last_modified", "params", "download_url"} {
+		t.Run(field, func(t *testing.T) {
+			db, _, detail := composeTestDetail(t, constant.AppResourceRemote, "https://example.com/demo.tar.gz")
+			value := interface{}("new value")
+			if field == "last_modified" {
+				value = 43
+			}
+			if err := db.Model(&model.AppDetail{}).Where("id = ?", detail.ID).Updates(map[string]interface{}{field: value, "docker_compose": "new template"}).Error; err != nil {
+				t.Fatal(err)
+			}
+			if err := cacheAppDetailCompose(&detail, []byte(composeTestTemplate)); err == nil {
+				t.Fatal("stale template overwrote newer metadata")
+			}
+			var stored model.AppDetail
+			if err := db.First(&stored, detail.ID).Error; err != nil {
+				t.Fatal(err)
+			}
+			if stored.DockerCompose != "new template" || detail.DockerCompose != "" {
+				t.Fatalf("stale cache result was retained: %+v", stored)
+			}
+		})
+	}
+}
+
+func TestComposeCachePropagatesWriteFailure(t *testing.T) {
+	db, _, detail := composeTestDetail(t, constant.AppResourceRemote, "https://example.com/demo.tar.gz")
+	if err := db.Exec("CREATE TRIGGER reject_compose BEFORE UPDATE OF docker_compose ON app_details BEGIN SELECT RAISE(FAIL, 'test write failure'); END").Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := cacheAppDetailCompose(&detail, []byte(composeTestTemplate)); err == nil || detail.DockerCompose != "" {
+		t.Fatal("failed cache write was ignored")
+	}
+}
+
+func TestMarkDownloadedPreservesComposeAndRejectsChangedMetadata(t *testing.T) {
+	db, _, detail := composeTestDetail(t, constant.AppResourceRemote, "https://example.com/demo.tar.gz")
+	if err := db.Model(&model.AppDetail{}).Where("id = ?", detail.ID).Updates(map[string]interface{}{"update": true, "docker_compose": composeTestTemplate}).Error; err != nil {
+		t.Fatal(err)
+	}
+	stored, err := appDetailRepo.MarkDownloaded(detail)
+	if err != nil || !stored {
+		t.Fatalf("matching download marker failed: stored=%v err=%v", stored, err)
+	}
+	var fresh model.AppDetail
+	if err := db.First(&fresh, detail.ID).Error; err != nil || fresh.Update || fresh.DockerCompose != composeTestTemplate {
+		t.Fatalf("download marker overwrote Compose: %+v, %v", fresh, err)
+	}
+	for _, field := range []string{"last_modified", "params", "download_url"} {
+		t.Run(field, func(t *testing.T) {
+			var snapshot model.AppDetail
+			if err := db.First(&snapshot, detail.ID).Error; err != nil {
+				t.Fatal(err)
+			}
+			value := interface{}("new metadata")
+			if field == "last_modified" {
+				value = snapshot.LastModified + 1
+			}
+			if err := db.Model(&model.AppDetail{}).Where("id = ?", detail.ID).Updates(map[string]interface{}{field: value, "update": true}).Error; err != nil {
+				t.Fatal(err)
+			}
+			stored, err := appDetailRepo.MarkDownloaded(snapshot)
+			if err != nil || stored {
+				t.Fatalf("stale download marked new resources ready: stored=%v err=%v", stored, err)
+			}
+			if err := db.First(&fresh, detail.ID).Error; err != nil || !fresh.Update || fresh.DockerCompose != composeTestTemplate {
+				t.Fatalf("stale marker overwrote template or update flag: %+v, %v", fresh, err)
+			}
+		})
+	}
+}
+
+func TestRuntimeDetailUsesValidPackageComposeWithoutAnotherGET(t *testing.T) {
+	var calls atomic.Int32
+	archive := appCacheTestArchive(t, "demo/1.0/docker-compose.yml", composeTestTemplate)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		if !strings.HasSuffix(r.URL.Path, ".tar.gz") {
+			t.Errorf("runtime requested Compose after obtaining a valid package: %s", r.URL)
+		}
+		_, _ = w.Write(archive)
+	}))
+	t.Cleanup(server.Close)
+	_, app, detail := composeTestDetail(t, constant.AppResourceRemote, server.URL+"/demo.tar.gz")
+	app.Type = constant.RuntimeNode
+	if err := global.DB.Model(&app).UpdateColumn("type", app.Type).Error; err != nil {
+		t.Fatal(err)
+	}
+	res, err := (AppService{}).GetAppDetail(app.ID, detail.Version, "runtime")
+	if err != nil || res.DockerCompose != composeTestTemplate || !res.HostMode || calls.Load() != 1 {
+		t.Fatalf("package Compose was not reused: %+v, %v, calls=%d", res, err, calls.Load())
+	}
+}
+
+func TestRuntimeDetailDoesNotCacheStaleTemplateAfterPackageFailure(t *testing.T) {
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		if strings.HasSuffix(r.URL.Path, ".tar.gz") {
+			w.WriteHeader(http.StatusServiceUnavailable)
+			return
+		}
+		_, _ = io.WriteString(w, composeTestTemplate)
+	}))
+	t.Cleanup(server.Close)
+	db, app, detail := composeTestDetail(t, constant.AppResourceRemote, server.URL+"/demo.tar.gz")
+	app.Type = constant.RuntimeNode
+	if err := db.Model(&app).UpdateColumn("type", app.Type).Error; err != nil {
+		t.Fatal(err)
+	}
+	appCacheTestWrite(t, filepath.Join(app.GetAppResourcePath(), detail.Version, "docker-compose.yml"), "services:\n  stale:\n    image: stale:old\n")
+	res, err := (AppService{}).GetAppDetail(app.ID, detail.Version, "runtime")
+	if err != nil || res.DockerCompose != composeTestTemplate || calls.Load() != 2 {
+		t.Fatalf("failed package download reused a stale local template: %+v, %v, calls=%d", res, err, calls.Load())
+	}
+	var stored model.AppDetail
+	if err := db.First(&stored, detail.ID).Error; err != nil || stored.DockerCompose != composeTestTemplate {
+		t.Fatalf("stale package contents were cached: %+v, %v", stored, err)
+	}
+}

agent/app/service/app_compose_upgrade_test.go

@@ -0,0 +1,253 @@
+package service
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/task"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+const composeUpgradeCurrent = `services:
+  demo:
+    image: demo:1.0
+    deploy:
+      resources:
+        limits:
+          cpus: ${CPUS}
+          memory: ${MEMORY_LIMIT}
+`
+
+func composeUpgradeDB(t *testing.T, resourceURL string) (*gorm.DB, model.App, model.AppInstall, []model.AppDetail) {
+	t.Helper()
+	db := iconSyncDB(t)
+	if err := db.AutoMigrate(&model.AppIgnoreUpgrade{}); err != nil {
+		t.Fatal(err)
+	}
+	app := model.App{Key: "demo", Name: "Demo", Type: "runtime", Resource: constant.AppResourceRemote, CrossVersionUpdate: true}
+	if err := db.Create(&app).Error; err != nil {
+		t.Fatal(err)
+	}
+	var details []model.AppDetail
+	for _, version := range []string{"1.1", "1.0", "1.3", "1.2"} {
+		detail := model.AppDetail{
+			AppId: app.ID, Version: version, LastModified: 42, Params: `{"formFields":[]}`, Status: constant.AppNormal,
+			DownloadUrl: resourceURL + "/demo/" + version + "/demo-" + version + ".tar.gz",
+		}
+		if err := db.Create(&detail).Error; err != nil {
+			t.Fatal(err)
+		}
+		details = append(details, detail)
+	}
+	if err := db.Create(&model.AppIgnoreUpgrade{AppID: app.ID, AppDetailID: details[2].ID, Scope: "version"}).Error; err != nil {
+		t.Fatal(err)
+	}
+	install := model.AppInstall{
+		AppId: app.ID, AppDetailId: details[1].ID, Name: "demo-install", Version: "1.0", App: app,
+		ServiceName: "demo", ContainerName: "demo-container", Status: constant.StatusRunning,
+		Env: `{"CONTAINER_NAME":"demo-container"}`, DockerCompose: composeUpgradeCurrent,
+	}
+	if err := db.Omit(clause.Associations).Create(&install).Error; err != nil {
+		t.Fatal(err)
+	}
+	return db, app, install, details
+}
+
+func TestUpgradeComposeLoadsOnlyEffectiveTarget(t *testing.T) {
+	var mu sync.Mutex
+	requests := make(map[string]int)
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		mu.Lock()
+		requests[r.URL.Path]++
+		mu.Unlock()
+		if r.URL.Query().Get("v") != "42" {
+			t.Errorf("missing synchronized version: %s", r.URL)
+		}
+		version := strings.Split(r.URL.Path, "/")[2]
+		_, _ = fmt.Fprintf(w, "services:\n  source:\n    image: demo:%s\n", version)
+	}))
+	t.Cleanup(server.Close)
+	db, _, install, details := composeUpgradeDB(t, server.URL)
+	// An unselected bad cached template must not prevent listing or default preview.
+	if err := db.Model(&details[0]).UpdateColumn("docker_compose", "invalid: [").Error; err != nil {
+		t.Fatal(err)
+	}
+	service := NewIAppInstalledService()
+	noCompose := false
+	versions, err := service.GetUpdateVersions(request.AppUpdateVersion{AppInstallID: install.ID, LoadCompose: &noCompose})
+	if err != nil || len(versions) != 2 || versions[0].Version != "1.2" || versions[1].Version != "1.1" {
+		t.Fatalf("pure versions did not preserve filtering/sorting: %+v, %v", versions, err)
+	}
+	for _, version := range versions {
+		if version.DockerCompose != "" {
+			t.Fatal("pure version request returned a rendered template")
+		}
+	}
+	if len(requests) != 0 {
+		t.Fatalf("pure version request fetched templates: %v", requests)
+	}
+	for i := 0; i < 2; i++ {
+		versions, err = service.GetUpdateVersions(request.AppUpdateVersion{AppInstallID: install.ID})
+		if err != nil || len(versions) != 2 || !strings.Contains(versions[0].DockerCompose, "demo:1.2") || versions[1].DockerCompose != "" {
+			t.Fatalf("default target preview = %+v, %v", versions, err)
+		}
+	}
+	if requests["/demo/1.2/docker-compose.yml"] != 1 || len(requests) != 1 {
+		t.Fatalf("default preview did not reuse only its own cache: %v", requests)
+	}
+	if err := db.Model(&details[0]).UpdateColumn("docker_compose", "").Error; err != nil {
+		t.Fatal(err)
+	}
+	versions, err = service.GetUpdateVersions(request.AppUpdateVersion{AppInstallID: install.ID, UpdateVersion: "1.1"})
+	if err != nil || !strings.Contains(versions[1].DockerCompose, "demo:1.1") || versions[0].DockerCompose != "" {
+		t.Fatalf("selected target preview = %+v, %v", versions, err)
+	}
+	if requests["/demo/1.1/docker-compose.yml"] != 1 || len(requests) != 2 {
+		t.Fatalf("selection prefetched other candidates: %v", requests)
+	}
+	if _, err := service.GetUpdateVersions(request.AppUpdateVersion{AppInstallID: install.ID, UpdateVersion: "1.3"}); err == nil {
+		t.Fatal("ignored target was accepted")
+	}
+	if len(requests) != 2 {
+		t.Fatal("invalid target triggered a template request")
+	}
+}
+
+func TestUpgradeComposeFetchFailurePreservesInstanceAndCache(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusServiceUnavailable) }))
+	t.Cleanup(server.Close)
+	db, _, install, details := composeUpgradeDB(t, server.URL)
+	if _, err := NewIAppInstalledService().GetUpdateVersions(request.AppUpdateVersion{AppInstallID: install.ID}); err == nil {
+		t.Fatal("failed target template load was accepted")
+	}
+	var stored model.AppInstall
+	if err := db.First(&stored, install.ID).Error; err != nil || stored.DockerCompose != install.DockerCompose || stored.Status != install.Status || stored.Version != install.Version {
+		t.Fatalf("preview modified installed instance: %+v, %v", stored, err)
+	}
+	var detail model.AppDetail
+	if err := db.First(&detail, details[3].ID).Error; err != nil || detail.DockerCompose != "" {
+		t.Fatalf("failed response cached a template: %+v, %v", detail, err)
+	}
+}
+
+func TestUpgradePrepareComposeFailureDoesNotCutover(t *testing.T) {
+	for _, failure := range []string{"package download", "invalid package template"} {
+		t.Run(failure, func(t *testing.T) {
+			archive := appCacheTestArchive(t, "demo/1.2/docker-compose.yml", "services: []")
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if failure == "package download" {
+					w.WriteHeader(http.StatusServiceUnavailable)
+					return
+				}
+				_, _ = w.Write(archive)
+			}))
+			t.Cleanup(server.Close)
+			db, _, install, details := composeUpgradeDB(t, server.URL)
+			upgrade := &appUpgradeContext{original: install, detail: details[3]}
+			if err := upgrade.prepare(&task.Task{Logger: global.LOG}); err == nil {
+				t.Fatal("invalid upgrade resources passed prepare")
+			}
+			if upgrade.stopAttempted || upgrade.downAttempted || upgrade.stageDir != "" {
+				t.Fatal("failed template preparation reached live cutover")
+			}
+			var stored model.AppInstall
+			if err := db.First(&stored, install.ID).Error; err != nil || stored.DockerCompose != install.DockerCompose || stored.Env != install.Env || stored.Version != install.Version || stored.Status != install.Status {
+				t.Fatalf("failed prepare modified the instance: %+v, %v", stored, err)
+			}
+		})
+	}
+}
+
+func TestExplicitConfigComposeDetectsCustomAndReusesCurrentCache(t *testing.T) {
+	for _, tc := range []struct {
+		name    string
+		custom  bool
+		failure bool
+	}{
+		{name: "original"},
+		{name: "custom", custom: true},
+		{name: "fetch failure", failure: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			calls := 0
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				calls++
+				if r.URL.Path != "/demo/1.0/docker-compose.yml" {
+					t.Errorf("configuration loaded a different version: %s", r.URL)
+				}
+				if tc.failure {
+					w.WriteHeader(http.StatusServiceUnavailable)
+					return
+				}
+				_, _ = io.WriteString(w, "services:\n  source:\n    image: demo:1.0\n")
+			}))
+			t.Cleanup(server.Close)
+			db, _, install, _ := composeUpgradeDB(t, server.URL)
+			if tc.custom {
+				install.DockerCompose = strings.Replace(install.DockerCompose, "image: demo:1.0", "image: demo:1.0\n    environment:\n      USER_SETTING: preserve", 1)
+				if err := db.Omit(clause.Associations).Save(&install).Error; err != nil {
+					t.Fatal(err)
+				}
+			}
+			if isEditCompose(install) || calls != 0 {
+				t.Fatal("list-time custom check fetched a missing template")
+			}
+			result, err := NewIAppInstalledService().GetParams(install.ID)
+			if tc.failure {
+				if err == nil || result != nil {
+					t.Fatal("failed current-template load was treated as an unedited configuration")
+				}
+				return
+			}
+			if err != nil || result.RawCompose == "" || result.IsEdit != tc.custom || result.DockerCompose != install.DockerCompose {
+				t.Fatalf("explicit custom state = %+v, %v; want custom=%v", result, err, tc.custom)
+			}
+			if _, err := NewIAppInstalledService().GetParams(install.ID); err != nil || calls != 1 {
+				t.Fatalf("configuration cache was not reused: calls=%d, %v", calls, err)
+			}
+			if isEditCompose(install) != tc.custom || calls != 1 {
+				t.Fatal("cached list-time comparison changed custom state or made network requests")
+			}
+		})
+	}
+}
+
+func TestVllmManagedComposeDoesNotRequireOfficialTemplate(t *testing.T) {
+	var calls atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}))
+	t.Cleanup(server.Close)
+	db, app, install, _ := composeUpgradeDB(t, server.URL)
+	if err := db.Model(&app).UpdateColumn("key", vllmAppKeyForUpgrade).Error; err != nil {
+		t.Fatal(err)
+	}
+	install.DockerCompose = strings.Replace(install.DockerCompose, "image: demo:1.0", "image: demo:1.0\n    command: [--managed-user-option]", 1)
+	if err := db.Omit(clause.Associations).Save(&install).Error; err != nil {
+		t.Fatal(err)
+	}
+	service := NewIAppInstalledService()
+	config, err := service.GetParams(install.ID)
+	if err != nil || config.RawCompose != install.DockerCompose || config.DockerCompose != install.DockerCompose || config.IsEdit {
+		t.Fatalf("managed configuration lost the instance template: %+v, %v", config, err)
+	}
+	versions, err := service.GetUpdateVersions(request.AppUpdateVersion{AppInstallID: install.ID})
+	if err != nil || len(versions) != 2 || versions[0].DockerCompose != install.DockerCompose {
+		t.Fatalf("managed upgrade preview lost the instance template: %+v, %v", versions, err)
+	}
+	if calls.Load() != 0 {
+		t.Fatalf("managed template attempted %d official resource requests", calls.Load())
+	}
+}

agent/app/service/app_icon_sync_test.go

@@ -0,0 +1,265 @@
+package service
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/dto/request"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/app/task"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
+	"github.com/1Panel-dev/1Panel/agent/utils/xpack/providers"
+	"github.com/gin-gonic/gin"
+	goi18n "github.com/nicksnyder/go-i18n/v2/i18n"
+	"golang.org/x/text/language"
+	"gorm.io/gorm"
+)
+
+type iconSyncTransport struct {
+	providers.MultiNodeProvider
+	transport *http.Transport
+}
+
+func (p iconSyncTransport) LoadRequestTransport() *http.Transport { return p.transport }
+
+func iconSyncDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	db := appCacheTestDB(t)
+	if err := db.AutoMigrate(&model.Tag{}, &model.AppInstall{}, &model.AppInstallResource{}); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Create(&[]model.Setting{{Key: "SystemVersion", Value: "2.4.0"}, {Key: "AppStoreSyncStatus", Value: constant.StatusSyncSuccess}}).Error; err != nil {
+		t.Fatal(err)
+	}
+	oldI18n := global.I18n
+	global.I18n = goi18n.NewLocalizer(goi18n.NewBundle(language.English), "en")
+	t.Cleanup(func() { global.I18n = oldI18n })
+	return db
+}
+
+func TestOfficialIconSyncNeverDownloadsImages(t *testing.T) {
+	iconSyncDB(t)
+	var calls atomic.Int32
+	cdn := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		calls.Add(1)
+		w.WriteHeader(http.StatusServiceUnavailable)
+	}))
+	t.Cleanup(cdn.Close)
+	taskLog := &task.Task{Logger: global.LOG}
+	for _, oldIcon := range []string{"", "app_demo.png?etag=old", "b2xk", cdn.URL + "/old.png"} {
+		t.Run(oldIcon, func(t *testing.T) {
+			icon := cdn.URL + "/demo.png?signature=a%2Bb&v=one"
+			def := dto.AppDefine{Icon: icon, AppProperty: dto.AppProperty{Key: "demo", Type: "website"}, Versions: []dto.AppConfigVersion{{Name: "1.0", AppForm: dto.AppForm{}}}}
+			apps := getApps([]model.App{{Key: "demo", Icon: oldIcon}}, []dto.AppDefine{def}, "2.4.0", taskLog)
+			ctx := appSyncContext{baseRemoteUrl: cdn.URL, list: &dto.AppList{LastModified: 42}}
+			result := ctx.processOneApp(appWorkItem{app: apps["demo"], appDef: def})
+			if result.Icon != icon || len(result.Details) != 1 || result.Details[0].Version != "1.0" || calls.Load() != 0 {
+				t.Fatalf("sync changed metadata or fetched a CDN image: %+v, calls=%d", result, calls.Load())
+			}
+		})
+	}
+	for _, invalid := range []string{"", "javascript:alert(1)", "https://user:secret@example.com/a.png", "//example.com/a.png", "https://"} {
+		def := dto.AppDefine{Icon: invalid, AppProperty: dto.AppProperty{Key: "demo"}}
+		apps := getApps([]model.App{{Key: "demo", Icon: "b2xk"}}, []dto.AppDefine{def}, "2.4.0", taskLog)
+		if apps["demo"].Icon != "b2xk" {
+			t.Fatalf("invalid icon %q erased history", invalid)
+		}
+	}
+}
+
+func TestOfficialIconSameRevisionRefreshIsReadOnlyUntilSync(t *testing.T) {
+	db := iconSyncDB(t)
+	apps := []model.App{
+		{Key: "mysql", Type: "website", Status: constant.AppNormal, Icon: "app_mysql.png", BatchInstallSupport: true},
+		{Key: "demo", Name: "original", Type: "website", Status: constant.AppNormal, Icon: "b2xk", LastModified: 7},
+		{Key: "future", Type: "website", Status: constant.AppNormal, Icon: "b2xk"},
+		{Key: "local-demo", Type: "website", Resource: constant.AppResourceLocal, Status: constant.AppNormal, Icon: "bG9jYWw="},
+		{Key: "custom-demo", Type: "website", Resource: constant.AppResourceCustom, Status: constant.AppNormal, Icon: "Y3VzdG9t"},
+		{Key: "down", Type: "website", Status: constant.AppTakeDown, Icon: "b2xk"},
+	}
+	if err := db.Create(&apps).Error; err != nil {
+		t.Fatal(err)
+	}
+	detail := model.AppDetail{AppId: apps[1].ID, Version: "1.0", Params: "keep", DockerCompose: "keep", Update: false}
+	if err := db.Create(&detail).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := db.First(&detail, detail.ID).Error; err != nil {
+		t.Fatal(err)
+	}
+	var imageCalls, indexCalls atomic.Int32
+	var failIndex atomic.Bool
+	list := dto.AppList{LastModified: 42}
+	for _, app := range apps {
+		version := 0.0
+		if app.Key == "future" {
+			version = 9.9
+		}
+		list.Apps = append(list.Apps, dto.AppDefine{Icon: "https://cdn.example/" + app.Key + ".png?signature=a%2Bb", AppProperty: dto.AppProperty{Key: app.Key, Version: version}})
+	}
+	var zipped bytes.Buffer
+	zw := zip.NewWriter(&zipped)
+	w, err := zw.Create("1panel.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.NewEncoder(w).Encode(list); err != nil {
+		t.Fatal(err)
+	}
+	if err := zw.Close(); err != nil {
+		t.Fatal(err)
+	}
+	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "1panel.json.version.txt"):
+			_, _ = io.WriteString(w, "42")
+		case strings.HasSuffix(r.URL.Path, "1panel.json.zip"):
+			indexCalls.Add(1)
+			if failIndex.Load() {
+				w.WriteHeader(http.StatusServiceUnavailable)
+				return
+			}
+			_, _ = w.Write(zipped.Bytes())
+		default:
+			imageCalls.Add(1)
+			w.WriteHeader(http.StatusServiceUnavailable)
+		}
+	}))
+	t.Cleanup(server.Close)
+	transport := server.Client().Transport.(*http.Transport).Clone()
+	transport.TLSClientConfig.InsecureSkipVerify = true
+	transport.DialContext = func(ctx context.Context, network, _ string) (net.Conn, error) {
+		return (&net.Dialer{}).DialContext(ctx, network, server.Listener.Addr().String())
+	}
+	oldProvider := xpack.MultiNodeProvider
+	xpack.MultiNodeProvider = iconSyncTransport{MultiNodeProvider: oldProvider, transport: transport}
+	t.Cleanup(func() { xpack.MultiNodeProvider = oldProvider; transport.CloseIdleConnections() })
+	global.Dir.ResourceDir = t.TempDir()
+	global.Dir.IconCacheDir = t.TempDir()
+	appCacheTestWrite(t, filepath.Join(global.Dir.IconCacheDir, "app_mysql.png"), "keep old image")
+	encodedList, err := json.Marshal(list)
+	if err != nil {
+		t.Fatal(err)
+	}
+	appCacheTestWrite(t, filepath.Join(global.Dir.ResourceDir, "1panel.json"), string(encodedList))
+
+	res, err := (AppService{}).GetAppUpdate()
+	if err != nil || res.CanUpdate || res.AppList == nil || indexCalls.Load() != 0 {
+		t.Fatalf("same revision/missing files forced a full sync: %+v, %v", res, err)
+	}
+	var original model.App
+	if err := db.First(&original, apps[1].ID).Error; err != nil || original.Icon != apps[1].Icon {
+		t.Fatalf("update check modified icon: %+v, %v", original, err)
+	}
+	var writes atomic.Int32
+	if err := db.Callback().Update().After("gorm:update").Register("test:icon-writes", func(tx *gorm.DB) {
+		if values, ok := tx.Statement.Dest.(map[string]interface{}); ok && tx.Statement.Table == "apps" && values["icon"] != nil {
+			writes.Add(1)
+		}
+	}); err != nil {
+		t.Fatal(err)
+	}
+	var shared *appSyncContext
+	for i := 0; i < 2; i++ {
+		if err := (AppService{}).createSyncAppStoreTask(&shared)(&task.Task{Logger: global.LOG}); err != nil {
+			t.Fatal(err)
+		}
+		if shared == nil || !shared.skipMetaSync || writes.Load() != 2 || imageCalls.Load() != 0 || indexCalls.Load() != 0 {
+			t.Fatalf("unexpected same revision sync: writes=%d, image calls=%d, index calls=%d, context=%+v", writes.Load(), imageCalls.Load(), indexCalls.Load(), shared)
+		}
+	}
+	var stored model.App
+	if err := db.First(&stored, apps[1].ID).Error; err != nil {
+		t.Fatal(err)
+	}
+	want := original
+	want.Icon = list.Apps[1].Icon
+	if !reflect.DeepEqual(stored, want) {
+		t.Fatalf("light refresh changed non-icon fields: got %+v, want %+v", stored, want)
+	}
+	for _, original := range apps[2:] {
+		stored = model.App{}
+		if err := db.First(&stored, original.ID).Error; err != nil {
+			t.Fatal(err)
+		}
+		if stored.Icon != original.Icon || stored.Status != original.Status {
+			t.Fatalf("filtered app was changed: %+v", stored)
+		}
+	}
+	var storedDetail model.AppDetail
+	if err := db.First(&storedDetail, detail.ID).Error; err != nil || !reflect.DeepEqual(storedDetail, detail) {
+		t.Fatalf("light refresh touched app details: %+v, %v", storedDetail, err)
+	}
+	failIndex.Store(true)
+	appCacheTestWrite(t, filepath.Join(global.Dir.ResourceDir, "1panel.json"), "{invalid")
+	if err := (AppService{}).createSyncAppStoreTask(&shared)(&task.Task{Logger: global.LOG}); err == nil || writes.Load() != 2 || indexCalls.Load() != 1 {
+		t.Fatal("failed index read was accepted or modified icons")
+	}
+}
+
+func TestAppIconURLsReachListDetailAndInstalled(t *testing.T) {
+	db := iconSyncDB(t)
+	for _, icon := range []string{"https://cdn.example/icon.png?signature=a%2Bb", "app_legacy.png?etag=old", "bG9jYWw="} {
+		app := model.App{Key: "demo-" + icon[:4], Name: "demo", Type: "website", Status: constant.AppNormal, Icon: icon}
+		app.Name = app.Key
+		if err := db.Create(&app).Error; err != nil {
+			t.Fatal(err)
+		}
+		ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
+		ctx.Request = httptest.NewRequest(http.MethodGet, "/", nil)
+		got, err := (AppService{}).PageApp(ctx, request.AppSearch{PageInfo: dto.PageInfo{Page: 1, PageSize: 10}, Name: app.Key})
+		if err != nil || len(got.Items) != 1 {
+			t.Fatalf("list failed: %+v, %v", got, err)
+		}
+		want := ""
+		if strings.HasPrefix(icon, "https:") {
+			want = icon
+		}
+		if got.Items[0].Icon != want {
+			t.Fatalf("list icon = %q, want %q", got.Items[0].Icon, want)
+		}
+		detail, err := (AppService{}).GetApp(ctx, app.Key)
+		if err != nil || detail.Icon != icon {
+			t.Fatalf("detail icon = %+v, %v", detail, err)
+		}
+		installed, err := handleInstalled([]model.AppInstall{{App: app, Status: constant.StatusRunning}}, false, false, false)
+		if err != nil || len(installed) != 1 || installed[0].Icon != want {
+			t.Fatalf("installed icon = %+v, %v", installed, err)
+		}
+	}
+}
+
+func TestLocalAppLogoKeepsBase64Delivery(t *testing.T) {
+	db := iconSyncDB(t)
+	dir := t.TempDir()
+	const image = "\x89PNG\r\n\x1a\nlocal-icon"
+	appCacheTestWrite(t, filepath.Join(dir, "data.yml"), "additionalProperties:\n  key: demo\n  name: Local Demo\n  type: website\n")
+	appCacheTestWrite(t, filepath.Join(dir, "README.md"), "local application")
+	appCacheTestWrite(t, filepath.Join(dir, "logo.png"), image)
+	app, err := handleLocalApp(dir)
+	if err != nil || app.Resource != constant.AppResourceLocal || app.Icon != base64.StdEncoding.EncodeToString([]byte(image)) {
+		t.Fatalf("local logo parsing changed: %+v, %v", app, err)
+	}
+	if err := db.Create(app).Error; err != nil {
+		t.Fatal(err)
+	}
+	data, source, etag, err := (AppService{}).GetAppIcon(app.Key)
+	if err != nil || string(data) != image || source != "" || etag != "" {
+		t.Fatalf("local logo no longer uses historical delivery: %q, %q, %q, %v", data, source, etag, err)
+	}
+}

agent/app/service/app_install.go

@@ -6,10 +6,8 @@ import (
 	"fmt"
 	"maps"
 	"math"
-	"net/http"
 	"os"
 	"path"
-	"path/filepath"
 	"reflect"
 	"sort"
 	"strconv"
@@ -31,7 +29,6 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/utils/env"
 	"github.com/1Panel-dev/1Panel/agent/utils/files"
 	"github.com/1Panel-dev/1Panel/agent/utils/nginx"
-	"github.com/1Panel-dev/1Panel/agent/utils/req_helper"
 	"github.com/docker/docker/api/types/container"
 	"github.com/joho/godotenv"
 	"github.com/pkg/errors"
@@ -743,7 +740,7 @@ func (a *AppInstallService) GetUpdateVersions(req request.AppUpdateVersion) ([]d
 		}
 		if canUpgrade {
 			feishuTarget := app.Key == constant.AppOpenclaw && isOpenclawBundledFeishuVersion(detail.Version)
-			if feishuTarget && !feishuChecked {
+			if feishuTarget && !feishuChecked && (req.LoadCompose == nil || *req.LoadCompose) {
 				conf, readErr := readOpenclawConfig(path.Join(install.GetPath(), "data/conf/openclaw.json"))
 				if readErr != nil {
 					return versions, readErr
@@ -754,33 +751,6 @@ func (a *AppInstallService) GetUpdateVersions(req request.AppUpdateVersion) ([]d
 				}
 				feishuChecked = true
 			}
-			var newCompose string
-			if req.UpdateVersion != "" && req.UpdateVersion == detail.Version && detail.DockerCompose == "" && !app.IsLocalApp() {
-				filename := filepath.Base(detail.DownloadUrl)
-				dockerComposeUrl := fmt.Sprintf("%s%s", strings.TrimSuffix(detail.DownloadUrl, filename), "docker-compose.yml")
-				if app.Resource == constant.AppResourceRemote {
-					dockerComposeUrl, err = currentAppDownloadURL(dockerComposeUrl)
-					if err != nil {
-						return versions, err
-					}
-				}
-				statusCode, composeRes, err := req_helper.HandleRequest(dockerComposeUrl, http.MethodGet, constant.TimeOut20s)
-				if statusCode == http.StatusNotFound {
-					return versions, buserr.New("ErrAppVersionUnavailable")
-				}
-				if err != nil {
-					return versions, err
-				}
-				if statusCode > 200 {
-					return versions, err
-				}
-				detail.DockerCompose = string(composeRes)
-				_ = appDetailRepo.Update(context.Background(), detail)
-			}
-			newCompose, err = getUpgradeCompose(install, detail)
-			if err != nil {
-				return versions, err
-			}
 			if app.Key == constant.AppMysql {
 				majorVersion := getMajorVersion(install.Version)
 				if !strings.HasPrefix(detail.Version, majorVersion) {
@@ -792,13 +762,46 @@ func (a *AppInstallService) GetUpdateVersions(req request.AppUpdateVersion) ([]d
 				FeishuConfigured: feishuTarget && feishuConfigured,
 				Version:          detail.Version,
 				DetailId:         detail.ID,
-				DockerCompose:    newCompose,
 			})
 		}
 	}
 	sort.Slice(versions, func(i, j int) bool {
 		return appVersionSortBefore(app.Key, versions[i].Version, versions[j].Version)
 	})
+	if len(versions) == 0 || (req.LoadCompose != nil && !*req.LoadCompose) {
+		return versions, nil
+	}
+	target := 0
+	if req.UpdateVersion != "" {
+		target = -1
+		for i := range versions {
+			if versions[i].Version == req.UpdateVersion {
+				target = i
+				break
+			}
+		}
+		if target == -1 {
+			return versions, buserr.New("ErrAppVersionUnavailable")
+		}
+	}
+	if app.Key == vllmAppKeyForUpgrade {
+		versions[target].DockerCompose = install.DockerCompose
+		return versions, nil
+	}
+	for _, detail := range details {
+		if detail.ID != versions[target].DetailId {
+			continue
+		}
+		if err := ensureAppDetailCompose(app, &detail); err != nil {
+			return versions, err
+		}
+		content, err := getUpgradeCompose(install, detail)
+		if err != nil {
+			return versions, err
+		}
+		versions[target].DockerCompose = content
+		break
+	}
 	return versions, nil
 }
 
@@ -1007,9 +1010,22 @@ func (a *AppInstallService) GetParams(id uint) (*response.AppConfig, error) {
 	res.RestartPolicy = getRestartPolicy(install.DockerCompose)
 	res.WebUI = install.WebUI
 	res.Type = install.App.Type
-	if rawCompose, err := getUpgradeCompose(install, detail); err == nil {
+	rawCompose := install.DockerCompose
-		res.RawCompose = rawCompose
+	if install.App.Key != vllmAppKeyForUpgrade {
+		if err := ensureAppDetailCompose(install.App, &detail); err != nil {
+			return nil, err
+		}
+		rawCompose, err = getUpgradeCompose(install, detail)
+		if err != nil {
+			return nil, err
+		}
 	}
+	equal, err := composeEqualExceptImage(rawCompose, install.DockerCompose)
+	if err != nil {
+		return nil, err
+	}
+	res.RawCompose = rawCompose
+	res.IsEdit = !equal
 	return &res, nil
 }
 

agent/app/service/app_store_index_test.go

@@ -0,0 +1,128 @@
+package service
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+	"github.com/1Panel-dev/1Panel/agent/global"
+	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
+)
+
+func TestAppStoreIndexUsesCacheUntilRevisionChanges(t *testing.T) {
+	for _, tc := range []struct {
+		name       string
+		cache      string
+		version    int
+		failZIP    bool
+		wantZIP    int32
+		wantUpdate bool
+		wantErr    bool
+	}{
+		{name: "matching cache", cache: `{"lastModified":42}`, version: 42},
+		{name: "missing cache", version: 42, wantZIP: 1},
+		{name: "malformed cache", cache: `{invalid`, version: 42, wantZIP: 1},
+		{name: "null cache", cache: `null`, version: 42, wantZIP: 1},
+		{name: "trailing corrupt data", cache: `{"lastModified":42} garbage`, version: 42, wantZIP: 1},
+		{name: "outdated cache", cache: `{"lastModified":41}`, version: 42, wantZIP: 1},
+		{name: "remote revision changed", cache: `{"lastModified":42}`, version: 43, wantUpdate: true},
+		{name: "download failure", cache: `{invalid`, version: 42, failZIP: true, wantZIP: 1, wantErr: true},
+		{name: "cached minimum panel version", cache: `{"lastModified":42,"additionalProperties":{"version":"9.9.0"}}`, version: 42, wantErr: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			db := iconSyncDB(t)
+			if err := db.Create(&model.App{Key: "mysql", Type: "website", Status: constant.AppNormal, Icon: "app_mysql.png", BatchInstallSupport: true}).Error; err != nil {
+				t.Fatal(err)
+			}
+			global.Dir.ResourceDir = t.TempDir()
+			cachePath := filepath.Join(global.Dir.ResourceDir, "1panel.json")
+			if tc.cache != "" {
+				appCacheTestWrite(t, cachePath, tc.cache)
+			}
+			list := dto.AppList{LastModified: tc.version, Apps: []dto.AppDefine{{Icon: "https://cdn.example/mysql.png", AppProperty: dto.AppProperty{Key: "mysql"}}}}
+			var archive bytes.Buffer
+			zw := zip.NewWriter(&archive)
+			entry, err := zw.Create("1panel.json")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := json.NewEncoder(entry).Encode(list); err != nil {
+				t.Fatal(err)
+			}
+			if err := zw.Close(); err != nil {
+				t.Fatal(err)
+			}
+			var versionCalls, zipCalls atomic.Int32
+			server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				switch {
+				case strings.HasSuffix(r.URL.Path, "1panel.json.version.txt"):
+					versionCalls.Add(1)
+					_, _ = io.WriteString(w, strconv.Itoa(tc.version))
+				case strings.HasSuffix(r.URL.Path, "1panel.json.zip"):
+					zipCalls.Add(1)
+					if tc.failZIP {
+						w.WriteHeader(http.StatusServiceUnavailable)
+						return
+					}
+					_, _ = w.Write(archive.Bytes())
+				default:
+					t.Errorf("unexpected remote resource request: %s", r.URL)
+					w.WriteHeader(http.StatusNotFound)
+				}
+			}))
+			t.Cleanup(server.Close)
+			transport := server.Client().Transport.(*http.Transport).Clone()
+			transport.TLSClientConfig.InsecureSkipVerify = true
+			transport.DialContext = func(ctx context.Context, network, _ string) (net.Conn, error) {
+				return (&net.Dialer{}).DialContext(ctx, network, server.Listener.Addr().String())
+			}
+			oldProvider := xpack.MultiNodeProvider
+			xpack.MultiNodeProvider = iconSyncTransport{MultiNodeProvider: oldProvider, transport: transport}
+			t.Cleanup(func() { xpack.MultiNodeProvider = oldProvider; transport.CloseIdleConnections() })
+
+			res, err := (AppService{}).GetAppUpdate()
+			if (err != nil) != tc.wantErr || res == nil && !tc.wantErr {
+				t.Fatalf("update check = %+v, %v; want error %v", res, err, tc.wantErr)
+			}
+			if zipCalls.Load() != tc.wantZIP || versionCalls.Load() != 1 {
+				t.Fatalf("first check requests: version=%d, ZIP=%d; want 1/%d", versionCalls.Load(), zipCalls.Load(), tc.wantZIP)
+			}
+			if tc.wantErr {
+				if tc.wantZIP == 0 && !strings.Contains(err.Error(), "ErrVersionTooLow") {
+					t.Fatalf("cached panel-version check was lost: %v", err)
+				}
+				return
+			}
+			if res.CanUpdate != tc.wantUpdate {
+				t.Fatalf("CanUpdate=%v, want %v", res.CanUpdate, tc.wantUpdate)
+			}
+			if tc.wantUpdate {
+				// Full synchronization still fetches the new index after detecting a revision change.
+				fresh, err := getAppList()
+				if err != nil || fresh.LastModified != tc.version || zipCalls.Load() != 1 {
+					t.Fatalf("changed revision did not fetch the new index: %+v, %v, ZIP=%d", fresh, err, zipCalls.Load())
+				}
+				return
+			}
+			if res.AppList == nil || res.AppList.LastModified != 42 {
+				t.Fatalf("same-revision icon refresh lost its index: %+v", res)
+			}
+			if _, err := (AppService{}).GetAppUpdate(); err != nil || zipCalls.Load() != tc.wantZIP || versionCalls.Load() != 2 {
+				t.Fatalf("second check redownloaded cached index: %v, version=%d, ZIP=%d", err, versionCalls.Load(), zipCalls.Load())
+			}
+		})
+	}
+}

agent/app/service/app_sync_task.go

@@ -4,12 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"net/http"
 	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
 
 	"github.com/1Panel-dev/1Panel/agent/app/dto"
 	"github.com/1Panel-dev/1Panel/agent/app/model"
@@ -17,15 +12,11 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/i18n"
-	"github.com/1Panel-dev/1Panel/agent/utils/appicon"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
-	"github.com/1Panel-dev/1Panel/agent/utils/req_helper"
-	"github.com/1Panel-dev/1Panel/agent/utils/xpack"
 )
 
 type appSyncContext struct {
 	task           *task.Task
-	httpClient     http.Client
 	baseRemoteUrl  string
 	systemVersion  string
 	appsMap        map[string]model.App
@@ -34,7 +25,6 @@ type appSyncContext struct {
 	oldAppIds      []uint
 	appTags        []*model.AppTag
 	skipMetaSync   bool
-	pendingIcons   map[string]string
 }
 
 func (a AppService) createSyncAppStoreTask(sharedCtx **appSyncContext) func(t *task.Task) error {
@@ -51,6 +41,10 @@ func (a AppService) createSyncAppStoreTask(sharedCtx **appSyncContext) func(t *t
 				t.Log(i18n.GetMsgByKey("AppStoreIsSyncing"))
 				return nil
 			}
+			if err := refreshOfficialAppIcons(updateRes.AppList, t); err != nil {
+				t.LogFailedWithErr(i18n.GetMsgByKey("PersistApps"), err)
+				return err
+			}
 			global.LOG.Infof("[AppStore] Appstore is up to date")
 			t.Log(i18n.GetMsgByKey("AppStoreIsUpToDate"))
 			*sharedCtx = &appSyncContext{skipMetaSync: true}
@@ -82,13 +76,11 @@ func (a AppService) createSyncAppStoreTask(sharedCtx **appSyncContext) func(t *t
 
 		ctx := &appSyncContext{
 			task:           t,
-			httpClient:     http.Client{Timeout: time.Duration(constant.TimeOut20s) * time.Second, Transport: xpack.MultiNodeProvider.LoadRequestTransport()},
 			baseRemoteUrl:  fmt.Sprintf("%s/%s/1panel", global.AppRepoURL(), global.CONF.Base.Mode),
 			systemVersion:  setting.SystemVersion,
 			settingService: settingService,
 			list:           list,
 			appTags:        make([]*model.AppTag, 0),
-			pendingIcons:   make(map[string]string),
 		}
 
 		if err = SyncTags(list.Extra); err != nil {
@@ -107,7 +99,7 @@ func (a AppService) createSyncAppStoreTask(sharedCtx **appSyncContext) func(t *t
 			ctx.oldAppIds = append(ctx.oldAppIds, old.ID)
 		}
 
-		ctx.appsMap, ctx.pendingIcons = getApps(oldApps, list.Apps, setting.SystemVersion, t)
+		ctx.appsMap = getApps(oldApps, list.Apps, setting.SystemVersion, t)
 
 		var addCount, updateCount, deleteCount int
 		if err = ctx.classifyAndPersistAppsWithStats(&addCount, &updateCount, &deleteCount); err != nil {
@@ -129,40 +121,39 @@ func (a AppService) createSyncAppStoreTask(sharedCtx **appSyncContext) func(t *t
 	}
 }
 
-type appWorkItem struct {
+func refreshOfficialAppIcons(list *dto.AppList, t *task.Task) error {
-	appDef  dto.AppDefine
+	if list == nil {
-	app     model.App
+		return nil
-	iconUrl string
-	hadIcon bool
-}
-
-type appWorkResult struct {
-	appKey     string
-	app        model.App
-	iconStatus int
-	hadIcon    bool
-	httpFailed bool
-}
-
-func (c *appSyncContext) processOneApp(item appWorkItem) appWorkResult {
-	app := item.app
-	l := item.appDef
-	result := appWorkResult{
-		appKey:  l.AppProperty.Key,
-		hadIcon: item.hadIcon,
 	}
-
+	apps, err := appRepo.GetBy(appRepo.WithResource(constant.AppResourceRemote))
-	if item.hadIcon {
+	if err != nil {
-		status, iconField := c.downloadAppIcon(item.iconUrl, l.AppProperty.Key, app.Icon)
+		return err
-		result.iconStatus = status
+	}
-		switch status {
+	systemVersion, err := settingRepo.GetValueByKey("SystemVersion")
-		case http.StatusOK:
+	if err != nil {
-			app.Icon = iconField
+		return err
-		case http.StatusNotModified:
+	}
-		default:
+	updated := getApps(apps, list.Apps, systemVersion, t)
-			result.httpFailed = true
+	for _, app := range apps {
+		candidate := updated[app.Key]
+		if app.Status != constant.AppNormal || candidate.Status != constant.AppNormal || candidate.Icon == app.Icon {
+			continue
+		}
+		if err := appRepo.UpdateIcon(app.ID, candidate.Icon); err != nil {
+			return err
 		}
 	}
+	return nil
+}
+
+type appWorkItem struct {
+	appDef dto.AppDefine
+	app    model.App
+}
+
+func (c *appSyncContext) processOneApp(item appWorkItem) model.App {
+	app := item.app
+	l := item.appDef
 
 	app.TagsKey = l.AppProperty.Tags
 	if l.AppProperty.Recommend > 0 {
@@ -189,24 +180,12 @@ func (c *appSyncContext) processOneApp(item appWorkItem) appWorkResult {
 			continue
 		}
 
-		if _, ok := InitTypes[app.Type]; ok {
+		downloadURL := fmt.Sprintf("%s/%s", versionUrl, app.Key+"-"+version+".tar.gz")
-			dockerComposeUrl := fmt.Sprintf("%s/%s", versionUrl, "docker-compose.yml")
+		if v.LastModified <= 0 || detail.LastModified != v.LastModified || detail.Params != string(paramByte) || detail.DownloadUrl != downloadURL {
-			dockerComposeUrl, err := appDownloadURL(dockerComposeUrl, strconv.Itoa(c.list.LastModified))
-			var composeRes []byte
-			if err == nil {
-				_, composeRes, err = req_helper.HandleRequestWithClient(&c.httpClient, dockerComposeUrl, http.MethodGet, constant.TimeOut20s)
-			}
-			if err == nil {
-				detail.DockerCompose = string(composeRes)
-			} else {
-				result.httpFailed = true
-			}
-		} else {
 			detail.DockerCompose = ""
 		}
-
 		detail.Params = string(paramByte)
-		detail.DownloadUrl = fmt.Sprintf("%s/%s", versionUrl, app.Key+"-"+version+".tar.gz")
+		detail.DownloadUrl = downloadURL
 		detail.DownloadCallBackUrl = v.DownloadCallBackUrl
 		detail.Update = true
 		detail.LastModified = v.LastModified
@@ -219,170 +198,25 @@ func (c *appSyncContext) processOneApp(item appWorkItem) appWorkResult {
 	}
 	app.Details = newDetails
 
-	result.app = app
+	return app
-	return result
 }
 
-func (c *appSyncContext) syncAppIconsAndDetails() error {
+func (c *appSyncContext) syncAppDetails() error {
 	total := len(c.list.Apps)
 	global.LOG.Infof("[AppStore] sync app detail start, total apps: %d", total)
-
+	for i, definition := range c.list.Apps {
-	workItems := make([]appWorkItem, 0, total)
+		app, ok := c.appsMap[definition.AppProperty.Key]
-	for _, l := range c.list.Apps {
+		if ok {
-		app, ok := c.appsMap[l.AppProperty.Key]
+			c.appsMap[app.Key] = c.processOneApp(appWorkItem{appDef: definition, app: app})
-		if !ok {
-			continue
 		}
-		iconUrl, hasPending := c.pendingIcons[l.AppProperty.Key]
+		if (i+1)%max(1, total/4) == 0 || i+1 == total {
-		workItems = append(workItems, appWorkItem{
+			c.task.LogWithProgress(i18n.GetMsgByKey("SyncAppDetail"), i+1, total)
-			appDef:  l,
-			app:     app,
-			iconUrl: iconUrl,
-			hadIcon: hasPending,
-		})
-	}
-
-	totalWork := len(workItems)
-	if totalWork == 0 {
-		return nil
-	}
-
-	const maxWorkers = 4
-	var (
-		failFlag atomic.Bool
-		workCh   = make(chan int, maxWorkers)
-		resultCh = make(chan appWorkResult, maxWorkers)
-		wg       sync.WaitGroup
-	)
-
-	wg.Add(maxWorkers)
-	for range maxWorkers {
-		go func() {
-			defer wg.Done()
-			for idx := range workCh {
-				result := c.processOneApp(workItems[idx])
-				resultCh <- result
-				if result.httpFailed {
-					failFlag.Store(true)
-				}
-			}
-		}()
-	}
-	go func() { wg.Wait(); close(resultCh) }()
-
-	var fed atomic.Int32
-	go func() {
-		for i := range workItems {
-			if failFlag.Load() {
-				break
-			}
-			workCh <- i
-			fed.Store(int32(i + 1))
-		}
-		close(workCh)
-	}()
-
-	var (
-		completed     int
-		icon200Count  int
-		icon304Count  int
-		iconFailCount int
-	)
-	milestones := [4]int{totalWork / 4, totalWork / 2, totalWork * 3 / 4, totalWork}
-	nextMS := 0
-	checkProgress := func() {
-		if nextMS < len(milestones) && completed >= milestones[nextMS] {
-			c.task.LogWithProgress(i18n.GetMsgByKey("SyncAppDetail"), completed, totalWork)
-			nextMS++
 		}
 	}
-
+	global.LOG.Infof("[AppStore] app detail sync completed, total: %d", total)
-	applyResult := func(result appWorkResult) {
-		c.appsMap[result.appKey] = result.app
-		if result.hadIcon {
-			switch result.iconStatus {
-			case http.StatusOK:
-				icon200Count++
-			case http.StatusNotModified:
-				icon304Count++
-			default:
-				iconFailCount++
-			}
-		}
-		completed++
-		checkProgress()
-	}
-
-	for result := range resultCh {
-		applyResult(result)
-	}
-
-	fedCount := int(fed.Load())
-	if failFlag.Load() && fedCount < len(workItems) {
-		global.LOG.Warnf("[AppStore] HTTP failure detected, falling back to serial for remaining %d apps", len(workItems)-fedCount)
-		for i := fedCount; i < len(workItems); i++ {
-			result := c.processOneApp(workItems[i])
-			applyResult(result)
-		}
-	}
-
-	global.LOG.Infof("[AppStore] icon download completed - total: %d, success(200): %d, cached(304): %d, failed: %d",
-		total, icon200Count, icon304Count, iconFailCount)
-
 	return nil
 }
 
-func (c *appSyncContext) downloadAppIcon(iconUrl, appKey, oldIcon string) (status int, iconField string) {
-	iconFileName, existingEtag := appicon.ParseIconField(oldIcon)
-
-	reqHeaders := make(map[string]string)
-	if existingEtag != "" && iconFileName != "" && appicon.IconFileExists(iconFileName) {
-		reqHeaders["If-None-Match"] = existingEtag
-	}
-
-	resp, err := req_helper.HandleRequestWithHeaders(&c.httpClient, iconUrl, http.MethodGet, constant.TimeOut20s, reqHeaders)
-	if err != nil {
-		global.LOG.Warnf("[AppStore] request icon failed url=%s, err=%v", iconUrl, err)
-		return 0, ""
-	}
-
-	if resp.StatusCode == http.StatusNotModified {
-		return http.StatusNotModified, ""
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		global.LOG.Warnf("[AppStore] download icon failed url=%s, status=%d", iconUrl, resp.StatusCode)
-		return 0, ""
-	}
-
-	if len(resp.Body) == 0 {
-		global.LOG.Warnf("[AppStore] download icon empty body url=%s", iconUrl)
-		return 0, ""
-	}
-
-	if resp.Body[0] == '<' {
-		global.LOG.Warnf("[AppStore] download icon got HTML response url=%s", iconUrl)
-		return 0, ""
-	}
-
-	contentType := resp.Header.Get("Content-Type")
-	ct := strings.TrimSpace(strings.Split(contentType, ";")[0])
-	if strings.ToLower(ct) != "image/png" {
-		global.LOG.Warnf("[AppStore] unexpected icon content-type: %s, expected image/png, url=%s", ct, iconUrl)
-	}
-
-	fileName, err := appicon.WriteIconFile(appKey, resp.Body)
-	if err != nil {
-		global.LOG.Warnf("[AppStore] write icon file failed appKey=%s, err=%v", appKey, err)
-		return 0, ""
-	}
-
-	newEtag := resp.Header.Get("ETag")
-	iconField = appicon.BuildIconField(fileName, newEtag)
-
-	return http.StatusOK, iconField
-}
-
 func (a AppService) createSyncAppStoreMetaTask(sharedCtx **appSyncContext) func(t *task.Task) error {
 	return func(t *task.Task) (err error) {
 		t.LogStart(i18n.GetMsgByKey("SyncAppDetail"))
@@ -411,7 +245,7 @@ func (a AppService) createSyncAppStoreMetaTask(sharedCtx **appSyncContext) func(
 		ctx.task = t
 		ctx.appTags = make([]*model.AppTag, 0)
 
-		if err = ctx.syncAppIconsAndDetails(); err != nil {
+		if err = ctx.syncAppDetails(); err != nil {
 			t.LogFailedWithErr(i18n.GetMsgByKey("SyncAppDetail"), err)
 			return err
 		}

agent/app/service/app_upgrade.go

@@ -216,8 +216,9 @@ func (u *appUpgradeContext) prepare(t *task.Task) error {
 		if err != nil {
 			return err
 		}
-		u.detail.DockerCompose = string(composeContent)
+		if err := cacheAppDetailCompose(&u.detail, composeContent); err != nil {
-		_ = appDetailRepo.Update(context.Background(), u.detail)
+			return err
+		}
 	}
 	if strings.TrimSpace(u.detail.DockerCompose) == "" && strings.TrimSpace(u.req.DockerCompose) == "" {
 		return buserr.WithName("ErrFileNotFound", "docker-compose.yml")

agent/app/service/app_utils.go

@@ -28,6 +28,7 @@ import (
 	"github.com/1Panel-dev/1Panel/agent/constant"
 	"github.com/1Panel-dev/1Panel/agent/global"
 	"github.com/1Panel-dev/1Panel/agent/i18n"
+	"github.com/1Panel-dev/1Panel/agent/utils/appicon"
 	"github.com/1Panel-dev/1Panel/agent/utils/cmd"
 	"github.com/1Panel-dev/1Panel/agent/utils/common"
 	"github.com/1Panel-dev/1Panel/agent/utils/compose"
@@ -993,8 +994,13 @@ func downloadApp(app model.App, appDetail model.AppDetail, appInstall *model.App
 	if err = os.WriteFile(cacheVersionPath, []byte(storeVersion), constant.FilePerm); err != nil {
 		return err
 	}
-	appDetail.Update = false
+	marked, err := appDetailRepo.MarkDownloaded(appDetail)
-	_ = appDetailRepo.Update(context.Background(), appDetail)
+	if err != nil {
+		return err
+	}
+	if !marked {
+		return buserr.WithDetail("ErrGetCompose", "application resources changed; retry the operation", nil)
+	}
 	return
 }
 
@@ -1268,9 +1274,8 @@ func getAppDetails(details []model.AppDetail, versions []dto.AppConfigVersion) m
 	return appDetails
 }
 
-func getApps(oldApps []model.App, items []dto.AppDefine, systemVersion string, task *task.Task) (map[string]model.App, map[string]string) {
+func getApps(oldApps []model.App, items []dto.AppDefine, systemVersion string, task *task.Task) map[string]model.App {
 	apps := make(map[string]model.App, len(oldApps))
-	pendingIcons := make(map[string]string, len(items))
 	for _, old := range oldApps {
 		old.Status = constant.AppTakeDown
 		apps[old.Key] = old
@@ -1311,12 +1316,14 @@ func getApps(oldApps []model.App, items []dto.AppDefine, systemVersion string, t
 		app.Architectures = strings.Join(config.Architectures, ",")
 		app.GpuSupport = config.GpuSupport
 		app.BatchInstallSupport = config.BatchInstallSupport
-		if item.Icon != "" {
+		if appicon.IsRemoteURL(item.Icon) {
-			pendingIcons[key] = item.Icon
+			app.Icon = item.Icon
+		} else if item.Icon != "" {
+			global.LOG.Warnf("[AppStore] invalid icon URL for app %s, keeping existing icon", key)
 		}
 		apps[key] = app
 	}
-	return apps, pendingIcons
+	return apps
 }
 
 func handleLocalAppDetail(versionDir string, appDetail *model.AppDetail) error {
@@ -1579,6 +1586,7 @@ func handleInstalled(appInstallList []model.AppInstall, updated, sync, checkUpda
 			HttpPort:    installed.HttpPort,
 			HttpsPort:   installed.HttpsPort,
 			AppName:     installed.App.Name,
+			Icon:        appicon.RemoteURL(installed.App.Icon),
 			AppKey:      installed.App.Key,
 			AppType:     installed.App.Type,
 			Path:        installed.GetPath(),

agent/app/service/container.go

@@ -140,29 +140,6 @@ func (u *ContainerService) Page(ctx context.Context, req dto.PageContainer) (int
 		backData = records[start:end]
 	}
 
-	// Batch-load persisted checks; never contact Docker Hub while rendering the list.
-	ids := make([]string, 0, len(backData))
-	for _, row := range backData {
-		ids = append(ids, row.ContainerID)
-	}
-	if len(ids) > 0 {
-		var checks []model.ContainerImageCheckUpdate
-		if err := global.DB.Where("container_id IN ?", ids).Find(&checks).Error; err != nil {
-			return 0, nil, err
-		}
-		byID := make(map[string]model.ContainerImageCheckUpdate, len(checks))
-		for _, check := range checks {
-			byID[check.ContainerID] = check
-		}
-		for i := range backData {
-			check, ok := byID[backData[i].ContainerID]
-			if ok && sameContainerImage(check.ImageID, backData[i].ImageId) && check.ImageName == backData[i].ImageName {
-				backData[i].LatestVersion = check.LatestVersion
-				backData[i].TargetImage = check.TargetImage
-				backData[i].HasUpdate = check.HasUpdate
-			}
-		}
-	}
 	for i := 0; i < len(backData); i++ {
 		install, _ := appInstallRepo.GetFirst(appInstallRepo.WithContainerName(backData[i].Name))
 		if install.ID > 0 {

agent/app/service/container_image_check_update.go

@@ -1,396 +0,0 @@
-package service
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/1Panel-dev/1Panel/agent/app/model"
-	"github.com/1Panel-dev/1Panel/agent/app/task"
-	"github.com/1Panel-dev/1Panel/agent/global"
-	"github.com/1Panel-dev/1Panel/agent/i18n"
-	"github.com/1Panel-dev/1Panel/agent/utils/docker"
-	"github.com/1Panel-dev/1Panel/agent/utils/dockerhub"
-	"github.com/docker/cli/cli/config"
-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/image"
-	"github.com/docker/docker/client"
-	"github.com/docker/docker/errdefs"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-)
-
-const imageCheckUpdateSetting = "ContainerImageUpdateEnabled"
-
-type ImageCheckUpdateStatus struct {
-	TaskID     string `json:"taskID"`
-	Enabled    bool   `json:"enabled"`
-	Running    bool   `json:"running"`
-	Checked    int    `json:"checked"`
-	Updates    int    `json:"updates"`
-	Failed     int    `json:"failed"`
-	Skipped    int    `json:"skipped"`
-	Error      string `json:"error"`
-	FinishedAt int64  `json:"finishedAt"`
-}
-
-var imageCheckUpdateState struct {
-	sync.Mutex
-	status ImageCheckUpdateStatus
-}
-
-func GetContainerImageCheckUpdateStatus() (ImageCheckUpdateStatus, error) {
-	var setting model.Setting
-	if err := global.DB.Where("key = ?", imageCheckUpdateSetting).First(&setting).Error; err != nil {
-		return ImageCheckUpdateStatus{}, err
-	}
-	imageCheckUpdateState.Lock()
-	defer imageCheckUpdateState.Unlock()
-	status := imageCheckUpdateState.status
-	status.Enabled = setting.Value == "Enable"
-	return status, nil
-}
-func SetContainerImageCheckUpdateSchedule(enabled bool) error {
-	value := "Disable"
-	if enabled {
-		httpClient, err := dockerhub.NewHTTPClient()
-		if err != nil {
-			return err
-		}
-		if httpClient.Transport != nil {
-			httpClient.CloseIdleConnections()
-		}
-		value = "Enable"
-	}
-	return global.DB.Model(&model.Setting{}).Where("key = ?", imageCheckUpdateSetting).Update("value", value).Error
-}
-
-// StartContainerImageCheckUpdate coalesces manual and scheduled runs on this node.
-func StartContainerImageCheckUpdate() (string, error) {
-	imageCheckUpdateState.Lock()
-	defer imageCheckUpdateState.Unlock()
-	if imageCheckUpdateState.status.Running {
-		return imageCheckUpdateState.status.TaskID, nil
-	}
-	taskItem, err := task.NewTask(i18n.GetMsgByKey("ContainerImageCheckUpdate"), task.TaskScan, task.TaskScopeImage, "", 0)
-	if err != nil {
-		return "", err
-	}
-	// Persist before returning the ID so the log drawer can immediately find it.
-	if err := global.TaskDB.Save(taskItem.Task).Error; err != nil {
-		_ = taskItem.Logger.Out.(io.Closer).Close()
-		taskItem.DeleteLogFile()
-		if cancel, ok := global.LoadTaskCancel(taskItem.TaskID); ok {
-			cancel()
-		}
-		global.RemoveTaskCancel(taskItem.TaskID)
-		return "", err
-	}
-	imageCheckUpdateState.status = ImageCheckUpdateStatus{Running: true, TaskID: taskItem.TaskID}
-	go func() {
-		result := ImageCheckUpdateStatus{TaskID: taskItem.TaskID}
-		defer func() {
-			result.FinishedAt = time.Now().UnixMilli()
-			imageCheckUpdateState.Lock()
-			imageCheckUpdateState.status = result
-			imageCheckUpdateState.Unlock()
-		}()
-		// The action owns its deadline so the task runner waits for cleanup and logs.
-		taskItem.AddSubTaskWithOps(i18n.GetMsgByKey("ContainerImageCheckUpdate"), func(t *task.Task) (err error) {
-			defer func() {
-				if recovered := recover(); recovered != nil {
-					err = fmt.Errorf("image update check failed: %v", recovered)
-				}
-				t.Log(i18n.GetMsgWithMap("ContainerImageCheckSummary", map[string]interface{}{
-					"checked": result.Checked, "updates": result.Updates, "failed": result.Failed, "skipped": result.Skipped,
-				}))
-			}()
-			ctx, cancel := context.WithTimeout(t.TaskCtx, 30*time.Minute)
-			defer cancel()
-			if err = runContainerImageCheckUpdate(ctx, &result, t.Log); err != nil {
-				return err
-			}
-			if result.Failed > 0 {
-				return fmt.Errorf("%s", i18n.GetMsgWithMap("ContainerImageCheckFailures", map[string]interface{}{"count": result.Failed}))
-			}
-			return nil
-		}, nil, 0, 0)
-		if err := taskItem.Execute(); err != nil {
-			result.Error = err.Error()
-			global.LOG.Errorf("container image check: %s", err)
-		}
-	}()
-	return taskItem.TaskID, nil
-}
-
-// These caches live only for one check. Remote results do not depend on a
-// container's local image ID, which is compared separately for every baseline.
-type imageCheckUpdateRepository struct {
-	client     imageCheckUpdateHubClient
-	err        error
-	tags       []string
-	tagsLoaded bool
-	tagsErr    error
-}
-type imageCheckUpdateTargetKey struct {
-	repository, tag string
-	platform        dockerhub.Platform
-}
-type imageCheckUpdateTargetResult struct {
-	target     dockerhub.Target
-	compatible bool
-	err        error
-}
-type imageCheckUpdateResult struct {
-	record model.ContainerImageCheckUpdate
-	err    error
-}
-type imageCheckUpdateCache struct {
-	username, password string
-	httpClient         *http.Client
-	repositories       map[string]*imageCheckUpdateRepository
-	targets            map[imageCheckUpdateTargetKey]imageCheckUpdateTargetResult
-}
-
-func runContainerImageCheckUpdate(ctx context.Context, result *ImageCheckUpdateStatus, logger func(string)) error {
-	httpClient, err := dockerhub.NewHTTPClient()
-	if err != nil {
-		return err
-	}
-	if httpClient.Transport != nil {
-		defer httpClient.CloseIdleConnections()
-	}
-	log := func(key string, values map[string]interface{}) {
-		if logger != nil {
-			logger(i18n.GetMsgWithMap(key, values))
-		}
-	}
-	cli, err := newImageCheckUpdateDockerClient()
-	if err != nil {
-		return err
-	}
-	defer cli.Close()
-	containers, err := cli.ContainerList(ctx, container.ListOptions{All: true})
-	if err != nil {
-		return err
-	}
-	log("ContainerImageCheckScope", map[string]interface{}{"count": len(containers)})
-	// Load old results once, rather than issuing one SELECT for every failed check.
-	var previousRows []model.ContainerImageCheckUpdate
-	if err := global.DB.WithContext(ctx).Find(&previousRows).Error; err != nil {
-		return err
-	}
-	previous := make(map[string]model.ContainerImageCheckUpdate, len(previousRows))
-	for _, row := range previousRows {
-		previous[row.ContainerID] = row
-	}
-	cache := imageCheckUpdateCache{httpClient: httpClient, repositories: map[string]*imageCheckUpdateRepository{}, targets: map[imageCheckUpdateTargetKey]imageCheckUpdateTargetResult{}}
-	cfg := config.LoadDefaultConfigFile(io.Discard)
-	if cfg != nil {
-		for _, host := range []string{"https://index.docker.io/v1/", "docker.io", "registry-1.docker.io"} {
-			auth, e := cfg.GetAuthConfig(host)
-			if e == nil && auth.Username != "" {
-				cache.username, cache.password = auth.Username, auth.Password
-				break
-			}
-		}
-	}
-	checks := map[string]imageCheckUpdateResult{}
-	ids := make([]string, 0, len(containers))
-	names := make(map[string]string, len(containers))
-	pending := make([]model.ContainerImageCheckUpdate, 0, 100)
-	for _, item := range containers {
-		if err := ctx.Err(); err != nil {
-			return err
-		}
-		ids = append(ids, item.ID)
-		name := item.ID
-		if len(item.Names) > 0 {
-			name = strings.TrimPrefix(item.Names[0], "/")
-		}
-		names[item.ID] = name
-		log("ContainerImageCheckItem", map[string]interface{}{"name": name, "image": item.Image})
-		repository, tag, supported := dockerhub.Reference(item.Image)
-		key := repository + ":" + tag + "@" + item.ImageID
-		entry, found := checks[key]
-		if !found {
-			entry.record, entry.err = checkContainerImageUpdate(ctx, cli, item, repository, tag, supported, &cache)
-			checks[key] = entry
-		}
-		record := entry.record
-		record.ContainerID, record.ImageName = item.ID, item.Image
-		if entry.err != nil {
-			record.CheckStatus, record.CheckError = "failed", entry.err.Error()
-			old := previous[item.ID]
-			if old.ImageID == item.ImageID && old.ImageName == item.Image {
-				record.LatestVersion, record.TargetImage, record.TargetImageID, record.HasUpdate = old.LatestVersion, old.TargetImage, old.TargetImageID, old.HasUpdate
-			}
-		}
-		pending = append(pending, record)
-		if len(pending) == 100 {
-			if err := saveContainerImageCheckUpdates(ctx, cli, pending, names, result, log); err != nil {
-				return err
-			}
-			pending = pending[:0]
-		}
-	}
-	if err := saveContainerImageCheckUpdates(ctx, cli, pending, names, result, log); err != nil {
-		return err
-	}
-	query := global.DB.WithContext(ctx).Where("1 = 1")
-	if len(ids) > 0 {
-		query = query.Where("container_id NOT IN ?", ids)
-	}
-	return query.Delete(&model.ContainerImageCheckUpdate{}).Error
-}
-
-func checkContainerImageUpdate(ctx context.Context, cli imageCheckUpdateDockerClient, item container.Summary, repository, tag string, supported bool, cache *imageCheckUpdateCache) (model.ContainerImageCheckUpdate, error) {
-	record := model.ContainerImageCheckUpdate{ImageID: item.ImageID, ImageName: item.Image, CheckStatus: "success", CheckedAt: time.Now()}
-	if !supported {
-		record.CheckStatus = "skipped"
-		return record, nil
-	}
-	inspected, err := cli.ImageInspect(ctx, item.ImageID)
-	if err != nil {
-		return record, err
-	}
-	repo, loaded := cache.repositories[repository]
-	if !loaded {
-		repo = &imageCheckUpdateRepository{}
-		repo.client, repo.err = newImageCheckUpdateHubClient(ctx, repository, cache.username, cache.password, cache.httpClient)
-		cache.repositories[repository] = repo
-	}
-	if repo.err != nil {
-		return record, repo.err
-	}
-	if dockerhub.NeedsTags(tag) {
-		if !repo.tagsLoaded {
-			repo.tags, repo.tagsErr = repo.client.Tags(ctx)
-			repo.tagsLoaded = true
-		}
-		if repo.tagsErr != nil {
-			return record, repo.tagsErr
-		}
-	}
-	platform := dockerhub.Platform{OS: inspected.Os, Architecture: inspected.Architecture, Variant: inspected.Variant}
-	for _, candidate := range dockerhub.Candidates(tag, repo.tags) {
-		key := imageCheckUpdateTargetKey{repository: repository, tag: candidate, platform: platform}
-		remote, loaded := cache.targets[key]
-		if !loaded {
-			remote.target, remote.compatible, remote.err = repo.client.Resolve(ctx, candidate, platform)
-			cache.targets[key] = remote
-		}
-		if remote.err != nil {
-			return record, remote.err
-		}
-		if !remote.compatible {
-			continue
-		}
-		record.LatestVersion = remote.target.Tag
-		record.TargetImage = "docker.io/" + repository + ":" + remote.target.Tag
-		record.TargetImageID = remote.target.ConfigDigest
-		// Both versioned and floating tags can be republished with new image content.
-		record.HasUpdate = remote.target.Tag != tag || remote.target.ConfigDigest != inspected.ID
-		return record, nil
-	}
-	return record, fmt.Errorf("no compatible image for %s/%s", platform.OS, platform.Architecture)
-}
-
-// Revalidate immediately before each small write batch. Never hold a database
-// transaction open while waiting for Docker or Docker Hub.
-func saveContainerImageCheckUpdates(ctx context.Context, cli imageCheckUpdateDockerClient, pending []model.ContainerImageCheckUpdate, names map[string]string, result *ImageCheckUpdateStatus, log func(string, map[string]interface{})) error {
-	records := make([]model.ContainerImageCheckUpdate, 0, len(pending))
-	for _, record := range pending {
-		current, err := cli.ContainerInspect(ctx, record.ContainerID)
-		if err != nil && !errdefs.IsNotFound(err) {
-			return err
-		}
-		if err != nil || current.Image != record.ImageID {
-			result.Skipped++
-			log("ContainerImageCheckChanged", map[string]interface{}{"name": names[record.ContainerID]})
-			continue
-		}
-		records = append(records, record)
-	}
-	if len(records) == 0 {
-		return nil
-	}
-	if err := global.DB.WithContext(ctx).Clauses(clause.OnConflict{UpdateAll: true}).CreateInBatches(&records, 100).Error; err != nil {
-		return err
-	}
-	// Count and announce only results that were successfully persisted.
-	for _, record := range records {
-		values := map[string]interface{}{"name": names[record.ContainerID], "image": record.ImageName}
-		switch record.CheckStatus {
-		case "failed":
-			result.Failed++
-			values["error"] = record.CheckError
-			log("ContainerImageCheckFailed", values)
-		case "skipped":
-			result.Skipped++
-			log("ContainerImageCheckSkipped", values)
-		default:
-			result.Checked++
-			if record.HasUpdate {
-				result.Updates++
-				values["target"] = record.TargetImage
-				log("ContainerImageCheckAvailable", values)
-			} else {
-				log("ContainerImageCheckCurrent", values)
-			}
-		}
-	}
-	return nil
-}
-
-// sameContainerImage guards cached results after external image changes.
-func sameContainerImage(stored, displayed string) bool {
-	return strings.TrimPrefix(stored, "sha256:") == strings.TrimPrefix(displayed, "sha256:")
-}
-
-// Reconcile only after Docker confirms the replacement container uses the target.
-func reconcileContainerImageCheckUpdate(oldID, newID, imageID, imageName string) error {
-	return global.DB.Transaction(func(tx *gorm.DB) error {
-		var previous model.ContainerImageCheckUpdate
-		if err := tx.Where("container_id = ?", oldID).Find(&previous).Error; err != nil {
-			return err
-		}
-		if previous.ContainerID == "" {
-			return nil
-		}
-		if err := tx.Where("container_id = ?", oldID).Delete(&model.ContainerImageCheckUpdate{}).Error; err != nil {
-			return err
-		}
-		if previous.TargetImageID != imageID {
-			return nil
-		}
-		previous.ContainerID = newID
-		previous.ImageID = imageID
-		previous.ImageName = imageName
-		previous.HasUpdate = false
-		previous.CheckStatus = "success"
-		previous.CheckError = ""
-		previous.CheckedAt = time.Now()
-		return tx.Clauses(clause.OnConflict{UpdateAll: true}).Create(&previous).Error
-	})
-}
-
-type imageCheckUpdateDockerClient interface {
-	ContainerList(context.Context, container.ListOptions) ([]container.Summary, error)
-	ContainerInspect(context.Context, string) (container.InspectResponse, error)
-	ImageInspect(context.Context, string, ...client.ImageInspectOption) (image.InspectResponse, error)
-	Close() error
-}
-type imageCheckUpdateHubClient interface {
-	Tags(context.Context) ([]string, error)
-	Resolve(context.Context, string, dockerhub.Platform) (dockerhub.Target, bool, error)
-}
-
-var newImageCheckUpdateDockerClient = func() (imageCheckUpdateDockerClient, error) { return docker.NewDockerClient() }
-var newImageCheckUpdateHubClient = func(ctx context.Context, repository, username, password string, httpClient *http.Client) (imageCheckUpdateHubClient, error) {
-	return dockerhub.New(ctx, repository, username, password, httpClient)
-}

agent/app/service/container_update.go

@@ -163,11 +163,6 @@ func (u *ContainerService) ContainerUpgrade(req dto.ContainerUpgrade) error {
 				upgradeErrors = append(upgradeErrors, upgradeErr)
 				return upgradeErr
 			}
-			if updated, inspectErr := client.ContainerInspect(ctx, item); inspectErr == nil {
-				if cacheErr := reconcileContainerImageCheckUpdate(oldContainer.ID, updated.ID, updated.Image, updated.Config.Image); cacheErr != nil {
-					global.LOG.Warnf("refresh container image update state: %v", cacheErr)
-				}
-			}
 			if cleanupErr != nil {
 				t.Log(i18n.GetWithNameAndErr("ContainerCleanupWarning", containerSwitchBackupName(oldContainer.ID), cleanupErr))
 			}
@@ -312,6 +307,7 @@ func switchContainer(
 	return switchContainerWithRecovery(ctx, cli, name, oldContainer, createNew, tty, logger, false)
 }
 
+
 const (
 	containerUpgradePullTimeout     = 30 * time.Minute
 	containerUpgradeReplaceTimeout  = 15 * time.Minute

agent/app/service/image_remote.go

@@ -1,29 +0,0 @@
-package service
-
-import (
-	"errors"
-
-	"github.com/1Panel-dev/1Panel/agent/buserr"
-	"github.com/1Panel-dev/1Panel/agent/utils/dockerhub"
-)
-
-type ImageRemoteCheckStatus struct {
-	ProxyRequired bool `json:"proxyRequired"`
-}
-
-// GetImageRemoteCheckStatus validates local settings without contacting Docker Hub.
-// Both image searches and update checks use the same proxy policy.
-func GetImageRemoteCheckStatus() (ImageRemoteCheckStatus, error) {
-	client, err := dockerhub.NewHTTPClient()
-	if err != nil {
-		var business buserr.BusinessError
-		if errors.As(err, &business) && business.Msg == "ErrImageCheckProxyRequired" {
-			return ImageRemoteCheckStatus{ProxyRequired: true}, nil
-		}
-		return ImageRemoteCheckStatus{}, err
-	}
-	if client.Transport != nil {
-		client.CloseIdleConnections()
-	}
-	return ImageRemoteCheckStatus{}, nil
-}

agent/app/service/runtime_get_test.go

@@ -0,0 +1,115 @@
+package service
+
+import (
+	"encoding/json"
+	"reflect"
+	"slices"
+	"testing"
+
+	"github.com/1Panel-dev/1Panel/agent/app/dto"
+	"github.com/1Panel-dev/1Panel/agent/app/model"
+	"github.com/1Panel-dev/1Panel/agent/constant"
+)
+
+func TestGetPHPRuntimeRefreshesVersionOptionsWithoutChangingConfig(t *testing.T) {
+	for _, resource := range []string{constant.AppResourceRemote, constant.AppResourceLocal, constant.AppResourceCustom} {
+		t.Run(resource, func(t *testing.T) {
+			db := appCacheTestDB(t)
+			if err := db.AutoMigrate(&model.Runtime{}); err != nil {
+				t.Fatal(err)
+			}
+			app := model.App{Key: "php", Type: constant.RuntimePHP, Resource: resource}
+			if err := db.Create(&app).Error; err != nil {
+				t.Fatal(err)
+			}
+			oldVersion := dto.AppFormValue{Label: "8.1.34", Value: "8.1.34"}
+			newVersion := dto.AppFormValue{Label: "8.1.35", Value: "8.1.35"}
+			savedForm := dto.AppForm{FormFields: []dto.AppFormFields{
+				{EnvKey: "PHP_VERSION", Type: "select", Default: oldVersion.Value, Values: []dto.AppFormValue{oldVersion}},
+				{EnvKey: "PHP_EXTENSIONS", Type: "select", Multiple: true, Values: []dto.AppFormValue{{Label: "redis", Value: "redis"}}},
+				{EnvKey: "PANEL_APP_PORT_HTTP", Type: "number"},
+				{EnvKey: "CONTAINER_PACKAGE_URL", Type: "select", Values: []dto.AppFormValue{{Label: "custom mirror", Value: "https://mirror.example"}}},
+			}}
+			encode := func(form dto.AppForm) string {
+				t.Helper()
+				data, err := json.Marshal(form)
+				if err != nil {
+					t.Fatal(err)
+				}
+				return string(data)
+			}
+			detail := model.AppDetail{AppId: app.ID, Version: "8.1", Params: encode(savedForm), Update: true}
+			if err := db.Create(&detail).Error; err != nil {
+				t.Fatal(err)
+			}
+			otherMajor := model.AppDetail{AppId: app.ID, Version: "8.2", Params: `{"formFields":[{"envKey":"PHP_VERSION","values":[{"label":"8.2.31","value":"8.2.31"}]}]}`}
+			if err := db.Create(&otherMajor).Error; err != nil {
+				t.Fatal(err)
+			}
+			runtime := model.Runtime{
+				Name: "existing-php", Type: constant.RuntimePHP, Resource: constant.ResourceAppstore,
+				Version: detail.Version, AppDetailID: detail.ID, Image: "custom-php:existing", Params: detail.Params,
+				Env:           "PHP_VERSION=8.1.34\nPHP_EXTENSIONS=redis,custom-extension\nPANEL_APP_PORT_HTTP=9070\nCONTAINER_PACKAGE_URL=https://mirror.example\nCONTAINER_NAME=my-php\nCUSTOM_SETTING=keep-me\n",
+				DockerCompose: "existing compose", Remark: "keep remark",
+			}
+			if err := db.Create(&runtime).Error; err != nil {
+				t.Fatal(err)
+			}
+			service := NewRuntimeService()
+			before, err := service.Get(runtime.ID)
+			if err != nil {
+				t.Fatal(err)
+			}
+			latestForm := dto.AppForm{FormFields: []dto.AppFormFields{
+				{EnvKey: "PHP_VERSION", Type: "select", Default: newVersion.Value, Values: []dto.AppFormValue{newVersion, oldVersion}},
+				{EnvKey: "PHP_EXTENSIONS", Type: "select", Multiple: true, Default: "opcache"},
+				{EnvKey: "PANEL_APP_PORT_HTTP", Default: 9000},
+			}}
+			removedForm := dto.AppForm{FormFields: []dto.AppFormFields{
+				{EnvKey: "PHP_VERSION", Type: "select", Default: newVersion.Value, Values: []dto.AppFormValue{newVersion}},
+			}}
+			for _, tc := range []struct {
+				name   string
+				params string
+				values []dto.AppFormValue
+			}{
+				{"new patch on reopen", encode(latestForm), []dto.AppFormValue{newVersion, oldVersion}},
+				{"selected version removed", encode(removedForm), []dto.AppFormValue{newVersion, oldVersion}},
+				{"invalid metadata", "{invalid", []dto.AppFormValue{oldVersion}},
+				{"missing metadata", "", []dto.AppFormValue{oldVersion}},
+				{"missing version field", `{"formFields":[{"envKey":"PHP_EXTENSIONS"}]}`, []dto.AppFormValue{oldVersion}},
+				{"empty version list", `{"formFields":[{"envKey":"PHP_VERSION","values":[]}]}`, []dto.AppFormValue{oldVersion}},
+			} {
+				t.Run(tc.name, func(t *testing.T) {
+					if err := db.Model(&detail).UpdateColumn("params", tc.params).Error; err != nil {
+						t.Fatal(err)
+					}
+					got, err := service.Get(runtime.ID)
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := *before
+					want.AppParams = slices.Clone(before.AppParams)
+					want.AppParams[0].Values = tc.values
+					if !reflect.DeepEqual(*got, want) {
+						t.Fatalf("edit response changed configuration or returned stale options:\ngot: %+v\nwant: %+v", *got, want)
+					}
+					var stored model.Runtime
+					if err := db.First(&stored, runtime.ID).Error; err != nil {
+						t.Fatal(err)
+					}
+					if stored.Params != runtime.Params || stored.Env != runtime.Env || stored.Image != runtime.Image || stored.DockerCompose != runtime.DockerCompose || stored.AppDetailID != runtime.AppDetailID || stored.Version != runtime.Version {
+						t.Fatal("opening edit mutated the saved runtime")
+					}
+					var storedDetail model.AppDetail
+					if err := db.First(&storedDetail, detail.ID).Error; err != nil {
+						t.Fatal(err)
+					}
+					if !storedDetail.Update {
+						t.Fatal("opening edit cleared the pending template update")
+					}
+				})
+			}
+		})
+	}
+}

agent/cron/cron.go

@@ -77,11 +77,7 @@ func Run() {
 		global.LOG.Errorf("generate random hour failed: %v", err)
 		hourRand = big.NewInt(0)
 	}
-	appSyncSchedule := fmt.Sprintf("%v %v * * *", minuteRand.Int64(), hourRand.Int64())
+	if _, err := global.Cron.AddJob(fmt.Sprintf("%v %v * * *", minuteRand.Int64(), hourRand.Int64()), job.NewAppStoreJob()); err != nil {
-	if _, err := global.Cron.AddJob(appSyncSchedule, job.NewContainerImageCheckUpdateJob()); err != nil {
-		global.LOG.Errorf("cannot add container image update cron job: %v", err)
-	}
-	if _, err := global.Cron.AddJob(appSyncSchedule, job.NewAppStoreJob()); err != nil {
 		global.LOG.Errorf("can not add  appstore corn job: %s", err.Error())
 	}
 	if _, err := global.Cron.AddJob("0 3 */31 * *", job.NewBackupJob()); err != nil {

agent/cron/job/container_image_check_update.go

@@ -1,24 +0,0 @@
-package job
-
-import (
-	"github.com/1Panel-dev/1Panel/agent/app/service"
-	"github.com/1Panel-dev/1Panel/agent/global"
-)
-
-type containerImageCheckUpdate struct{}
-
-func NewContainerImageCheckUpdateJob() *containerImageCheckUpdate {
-	return &containerImageCheckUpdate{}
-}
-func (j *containerImageCheckUpdate) Run() {
-	status, err := service.GetContainerImageCheckUpdateStatus()
-	if err != nil {
-		global.LOG.Errorf("load container image update schedule: %v", err)
-		return
-	}
-	if status.Enabled {
-		if _, err := service.StartContainerImageCheckUpdate(); err != nil {
-			global.LOG.Errorf("start container image update check: %v", err)
-		}
-	}
-}

agent/i18n/lang/en.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "These mounts cannot be fully backed up or restored. Use
 AgentFeishuRecoveryDisabled: "Gateway recovered with Feishu disabled; the original configuration backup is retained."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "Check for image updates"
-ContainerImageCheckScope: "Checking all {{ .count }} containers on this node, regardless of pagination or filters"
-ContainerImageCheckItem: "Checking container {{ .name }}, image {{ .image }}"
-ContainerImageCheckFailed: "Container {{ .name }} check failed: {{ .error }}; retaining previous results matching the current image"
-ContainerImageCheckSkipped: "Skipping {{ .name }}: not a tagged Docker Hub image, a local image, or pinned digest"
-ContainerImageCheckAvailable: "Container {{ .name }} has an update: {{ .image }} -> {{ .target }}"
-ContainerImageCheckCurrent: "No update found for container {{ .name }}"
-ContainerImageCheckChanged: "Container {{ .name }} was removed or its image changed; result was not saved"
-ContainerImageCheckSummary: "Check finished: {{ .checked }} checked, {{ .updates }} upgradable, {{ .failed }} failed, {{ .skipped }} skipped"
-ContainerImageCheckFailures: "{{ .count }} container checks failed; see the task log"
-
-ErrImageCheckProxyRequired: "To check for image updates in the current runtime environment, please configure a proxy server first."

agent/i18n/lang/es-ES.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "Estos montajes no permiten una copia y restauración co
 AgentFeishuRecoveryDisabled: "Puerta de enlace recuperada con Feishu desactivado; se conserva la copia de configuración original."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "Buscar actualizaciones de imágenes"
-ContainerImageCheckScope: "Comprobando los {{ .count }} contenedores de este nodo, sin aplicar paginación ni filtros"
-ContainerImageCheckItem: "Comprobando el contenedor {{ .name }}, imagen {{ .image }}"
-ContainerImageCheckFailed: "Error al comprobar el contenedor {{ .name }}: {{ .error }}; se conservan los resultados anteriores correspondientes a la imagen actual"
-ContainerImageCheckSkipped: "Se omite {{ .name }}: no es una imagen de Docker Hub con etiqueta, es una imagen local o tiene un digest fijo"
-ContainerImageCheckAvailable: "El contenedor {{ .name }} tiene una actualización: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "No se encontraron actualizaciones para el contenedor {{ .name }}"
-ContainerImageCheckChanged: "El contenedor {{ .name }} se eliminó o su imagen cambió; no se guardó el resultado"
-ContainerImageCheckSummary: "Comprobación finalizada: comprobados {{ .checked }}, actualizables {{ .updates }}, fallidos {{ .failed }}, omitidos {{ .skipped }}"
-ContainerImageCheckFailures: "Falló la comprobación de {{ .count }} contenedores; consulte el registro de la tarea"
-
-ErrImageCheckProxyRequired: "Para comprobar actualizaciones de imágenes en el entorno actual, configura primero un servidor proxy."

agent/i18n/lang/fa.yaml

@@ -803,15 +803,3 @@ ErrFeishuUpgradeMounts: "این اتصال‌های ذخیره‌سازی کام
 AgentFeishuRecoveryDisabled: "دروازه بازیابی شد و Feishu غیرفعال است؛ پشتیبان تنظیمات اصلی حفظ شد."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "بررسی به‌روزرسانی ایمیج‌ها"
-ContainerImageCheckScope: "در حال بررسی همه {{ .count }} کانتینر این گره، بدون توجه به صفحه‌بندی و فیلترها"
-ContainerImageCheckItem: "در حال بررسی کانتینر {{ .name }}، ایمیج {{ .image }}"
-ContainerImageCheckFailed: "بررسی کانتینر {{ .name }} ناموفق بود: {{ .error }}؛ نتایج قبلیِ منطبق با ایمیج فعلی حفظ می‌شوند"
-ContainerImageCheckSkipped: "کانتینر {{ .name }} رد شد: ایمیج تگ‌دار Docker Hub نیست، ایمیج محلی است یا digest ثابت دارد"
-ContainerImageCheckAvailable: "برای کانتینر {{ .name }} به‌روزرسانی موجود است: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "به‌روزرسانی برای کانتینر {{ .name }} یافت نشد"
-ContainerImageCheckChanged: "کانتینر {{ .name }} حذف شده یا ایمیج آن تغییر کرده است؛ نتیجه ذخیره نشد"
-ContainerImageCheckSummary: "بررسی پایان یافت: بررسی‌شده {{ .checked }}، قابل ارتقا {{ .updates }}، ناموفق {{ .failed }}، ردشده {{ .skipped }}"
-ContainerImageCheckFailures: "بررسی {{ .count }} کانتینر ناموفق بود؛ گزارش وظیفه را مشاهده کنید"
-
-ErrImageCheckProxyRequired: "برای بررسی به‌روزرسانی تصاویر در محیط فعلی، ابتدا یک سرور پروکسی پیکربندی کنید."

agent/i18n/lang/ja.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "現在のマウントは完全なバックアップ・
 AgentFeishuRecoveryDisabled: "ゲートウェイを復旧しました。Feishu は無効のままで、元の設定のバックアップは保持しています。"
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "イメージの更新を確認"
-ContainerImageCheckScope: "ページ分割やフィルターに関係なく、このノードの全 {{ .count }} コンテナを確認します"
-ContainerImageCheckItem: "コンテナ {{ .name }}、イメージ {{ .image }} を確認しています"
-ContainerImageCheckFailed: "コンテナ {{ .name }} の確認に失敗しました：{{ .error }}。現在のイメージに対応する前回の結果を保持します"
-ContainerImageCheckSkipped: "{{ .name }} をスキップ：タグ付きの Docker Hub イメージではないか、ローカルイメージまたは digest 固定のイメージです"
-ContainerImageCheckAvailable: "コンテナ {{ .name }} は更新可能です：{{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "コンテナ {{ .name }} の更新は見つかりませんでした"
-ContainerImageCheckChanged: "コンテナ {{ .name }} が削除されたか、イメージが変更されたため、結果は保存されませんでした"
-ContainerImageCheckSummary: "確認終了：成功 {{ .checked }}、更新可能 {{ .updates }}、失敗 {{ .failed }}、スキップ {{ .skipped }}"
-ContainerImageCheckFailures: "{{ .count }} コンテナの確認に失敗しました。タスクログを確認してください"
-
-ErrImageCheckProxyRequired: "現在の実行環境でイメージの更新を確認するには、先にプロキシサーバーを設定してください。"

agent/i18n/lang/ko.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "현재 마운트는 전체 백업 및 복원을 지원
 AgentFeishuRecoveryDisabled: "게이트웨이가 복구되었습니다. Feishu는 비활성 상태이며 원본 설정 백업은 유지됩니다."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "이미지 업데이트 확인"
-ContainerImageCheckScope: "페이지 및 필터와 관계없이 현재 노드의 모든 컨테이너 {{ .count }}개를 확인합니다"
-ContainerImageCheckItem: "컨테이너 {{ .name }}, 이미지 {{ .image }} 확인 중"
-ContainerImageCheckFailed: "컨테이너 {{ .name }} 확인 실패: {{ .error }}. 현재 이미지와 일치하는 이전 결과를 유지합니다"
-ContainerImageCheckSkipped: "{{ .name }} 건너뜀: 태그가 있는 Docker Hub 이미지가 아니거나 로컬 이미지 또는 digest가 고정된 이미지입니다"
-ContainerImageCheckAvailable: "컨테이너 {{ .name }} 업데이트 가능: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "컨테이너 {{ .name }}의 업데이트를 찾지 못했습니다"
-ContainerImageCheckChanged: "컨테이너 {{ .name }}이 삭제되었거나 이미지가 변경되어 결과를 저장하지 않았습니다"
-ContainerImageCheckSummary: "확인 종료: 성공 {{ .checked }}, 업데이트 가능 {{ .updates }}, 실패 {{ .failed }}, 건너뜀 {{ .skipped }}"
-ContainerImageCheckFailures: "컨테이너 {{ .count }}개 확인에 실패했습니다. 작업 로그를 확인하세요"
-
-ErrImageCheckProxyRequired: "현재 실행 환경에서 이미지 업데이트를 확인하려면 먼저 프록시 서버를 설정하세요."

agent/i18n/lang/lo.yaml

@@ -793,15 +793,3 @@ ErrFeishuUpgradeMounts: "ຈຸດເຊື່ອມຂໍ້ມູນນີ້
 AgentFeishuRecoveryDisabled: "ເກດເວກູ້ຄືນແລ້ວ ແຕ່ Feishu ຍັງປິດ; ສຳຮອງການຕັ້ງຄ່າເດີມຍັງຖືກເກັບໄວ້."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "ກວດສອບການອັບເດດອິມເມຈ"
-ContainerImageCheckScope: "ກຳລັງກວດສອບທັງໝົດ {{ .count }} ຄອນເທນເນີໃນໂນດນີ້ ໂດຍບໍ່ຂຶ້ນກັບການແບ່ງໜ້າ ຫຼື ຕົວກອງ"
-ContainerImageCheckItem: "ກຳລັງກວດສອບຄອນເທນເນີ {{ .name }}, ອິມເມຈ {{ .image }}"
-ContainerImageCheckFailed: "ກວດສອບຄອນເທນເນີ {{ .name }} ລົ້ມເຫຼວ: {{ .error }}; ເກັບຜົນກ່ອນໜ້າທີ່ກົງກັບອິມເມຈປັດຈຸບັນໄວ້"
-ContainerImageCheckSkipped: "ຂ້າມ {{ .name }}: ບໍ່ແມ່ນອິມເມຈ Docker Hub ທີ່ມີແທັກ, ເປັນອິມເມຈພາຍໃນ ຫຼື ກຳນົດ digest ຄົງທີ່"
-ContainerImageCheckAvailable: "ຄອນເທນເນີ {{ .name }} ມີອັບເດດ: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "ບໍ່ພົບອັບເດດສຳລັບຄອນເທນເນີ {{ .name }}"
-ContainerImageCheckChanged: "ຄອນເທນເນີ {{ .name }} ຖືກລຶບ ຫຼື ອິມເມຈປ່ຽນແປງ; ບໍ່ໄດ້ບັນທຶກຜົນ"
-ContainerImageCheckSummary: "ກວດສອບສິ້ນສຸດ: ກວດແລ້ວ {{ .checked }}, ອັບເກຣດໄດ້ {{ .updates }}, ລົ້ມເຫຼວ {{ .failed }}, ຂ້າມ {{ .skipped }}"
-ContainerImageCheckFailures: "ກວດສອບ {{ .count }} ຄອນເທນເນີລົ້ມເຫຼວ; ກະລຸນາເບິ່ງບັນທຶກວຽກ"
-
-ErrImageCheckProxyRequired: "ເພື່ອກວດສອບການອັບເດດອິມເມຈໃນສະພາບແວດລ້ອມປັດຈຸບັນ ກະລຸນາຕັ້ງຄ່າພຣັອກຊີເຊີບເວີກ່ອນ."

agent/i18n/lang/ms.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "Lekapan ini tidak boleh disandar dan dipulihkan sepenuh
 AgentFeishuRecoveryDisabled: "Gerbang dipulihkan dengan Feishu dinyahaktifkan; sandaran konfigurasi asal dikekalkan."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "Semak kemas kini imej"
-ContainerImageCheckScope: "Menyemak kesemua {{ .count }} kontena pada nod ini tanpa mengira pembahagian halaman atau penapis"
-ContainerImageCheckItem: "Menyemak kontena {{ .name }}, imej {{ .image }}"
-ContainerImageCheckFailed: "Semakan kontena {{ .name }} gagal: {{ .error }}; keputusan terdahulu yang sepadan dengan imej semasa dikekalkan"
-ContainerImageCheckSkipped: "Melangkau {{ .name }}: bukan imej Docker Hub bertag, imej setempat atau digest ditetapkan"
-ContainerImageCheckAvailable: "Kontena {{ .name }} mempunyai kemas kini: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "Tiada kemas kini ditemui untuk kontena {{ .name }}"
-ContainerImageCheckChanged: "Kontena {{ .name }} telah dipadam atau imejnya berubah; keputusan tidak disimpan"
-ContainerImageCheckSummary: "Semakan selesai: disemak {{ .checked }}, boleh dikemas kini {{ .updates }}, gagal {{ .failed }}, dilangkau {{ .skipped }}"
-ContainerImageCheckFailures: "Semakan {{ .count }} kontena gagal; lihat log tugas"
-
-ErrImageCheckProxyRequired: "Untuk menyemak kemas kini imej dalam persekitaran semasa, sila konfigurasikan pelayan proksi terlebih dahulu."

agent/i18n/lang/pt-BR.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "Estas montagens não permitem backup e restauração co
 AgentFeishuRecoveryDisabled: "Gateway recuperado com Feishu desativado; o backup da configuração original foi mantido."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "Verificar atualizações de imagens"
-ContainerImageCheckScope: "Verificando todos os {{ .count }} contêineres deste nó, independentemente da paginação e dos filtros"
-ContainerImageCheckItem: "Verificando o contêiner {{ .name }}, imagem {{ .image }}"
-ContainerImageCheckFailed: "Falha ao verificar o contêiner {{ .name }}: {{ .error }}; os resultados anteriores correspondentes à imagem atual serão mantidos"
-ContainerImageCheckSkipped: "Ignorando {{ .name }}: não é uma imagem do Docker Hub com tag, é uma imagem local ou tem digest fixo"
-ContainerImageCheckAvailable: "O contêiner {{ .name }} tem uma atualização: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "Nenhuma atualização encontrada para o contêiner {{ .name }}"
-ContainerImageCheckChanged: "O contêiner {{ .name }} foi removido ou sua imagem mudou; o resultado não foi salvo"
-ContainerImageCheckSummary: "Verificação concluída: verificados {{ .checked }}, atualizáveis {{ .updates }}, falhas {{ .failed }}, ignorados {{ .skipped }}"
-ContainerImageCheckFailures: "Falha na verificação de {{ .count }} contêineres; consulte o log da tarefa"
-
-ErrImageCheckProxyRequired: "Para verificar atualizações de imagens no ambiente atual, configure primeiro um servidor proxy."

agent/i18n/lang/ru.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "Эти монтирования не поддержив
 AgentFeishuRecoveryDisabled: "Шлюз восстановлен, Feishu отключён; исходная резервная копия конфигурации сохранена."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "Проверить обновления образов"
-ContainerImageCheckScope: "Проверка всех контейнеров на текущем узле ({{ .count }}) независимо от страниц и фильтров"
-ContainerImageCheckItem: "Проверка контейнера {{ .name }}, образ {{ .image }}"
-ContainerImageCheckFailed: "Ошибка проверки контейнера {{ .name }}: {{ .error }}; сохранены предыдущие результаты, соответствующие текущему образу"
-ContainerImageCheckSkipped: "Пропуск {{ .name }}: это не образ Docker Hub с тегом, локальный образ или образ с фиксированным digest"
-ContainerImageCheckAvailable: "Доступно обновление контейнера {{ .name }}: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "Обновлений для контейнера {{ .name }} не найдено"
-ContainerImageCheckChanged: "Контейнер {{ .name }} удалён или его образ изменился; результат не сохранён"
-ContainerImageCheckSummary: "Проверка завершена: проверено {{ .checked }}, доступны обновления {{ .updates }}, ошибок {{ .failed }}, пропущено {{ .skipped }}"
-ContainerImageCheckFailures: "Не удалось проверить контейнеры: {{ .count }}. Подробности в журнале задачи"
-
-ErrImageCheckProxyRequired: "Для проверки обновлений образов в текущей среде сначала настройте прокси-сервер."

agent/i18n/lang/tr.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "Bu bağlamalar tam yedeklenip geri yüklenemiyor. Uygul
 AgentFeishuRecoveryDisabled: "Ağ geçidi kurtarıldı, Feishu kapalı; özgün yapılandırma yedeği korundu."
 
 ContainerUpgradeWaiting: "Waiting for a container upgrade execution slot"
-ContainerImageCheckUpdate: "İmaj güncellemelerini denetle"
-ContainerImageCheckScope: "Sayfalama ve filtrelerden bağımsız olarak bu düğümdeki {{ .count }} konteynerin tümü denetleniyor"
-ContainerImageCheckItem: "Konteyner {{ .name }}, imaj {{ .image }} denetleniyor"
-ContainerImageCheckFailed: "{{ .name }} konteyneri denetlenemedi: {{ .error }}; mevcut imajla eşleşen önceki sonuçlar korunuyor"
-ContainerImageCheckSkipped: "{{ .name }} atlanıyor: etiketli bir Docker Hub imajı değil, yerel bir imaj veya digest değeri sabitlenmiş"
-ContainerImageCheckAvailable: "{{ .name }} konteyneri için güncelleme mevcut: {{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "{{ .name }} konteyneri için güncelleme bulunamadı"
-ContainerImageCheckChanged: "{{ .name }} konteyneri silindi veya imajı değişti; sonuç kaydedilmedi"
-ContainerImageCheckSummary: "Denetim tamamlandı: denetlenen {{ .checked }}, güncellenebilir {{ .updates }}, başarısız {{ .failed }}, atlanan {{ .skipped }}"
-ContainerImageCheckFailures: "{{ .count }} konteyner denetlenemedi; görev günlüğünü inceleyin"
-
-ErrImageCheckProxyRequired: "Geçerli çalışma ortamında imaj güncellemelerini kontrol etmek için önce bir proxy sunucusu yapılandırın."

agent/i18n/lang/zh-Hant.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "目前掛載無法完整備份或還原，請使用應
 AgentFeishuRecoveryDisabled: "閘道已恢復，飛書保持停用；原設定備份已保留。"
 
 ContainerUpgradeWaiting: "等待容器升級任務執行名額"
-ContainerImageCheckUpdate: "檢查更新映像"
-ContainerImageCheckScope: "檢查目前節點全部 {{ .count }} 個容器，不受分頁和篩選影響"
-ContainerImageCheckItem: "檢查容器 {{ .name }}，映像 {{ .image }}"
-ContainerImageCheckFailed: "容器 {{ .name }} 檢查失敗：{{ .error }}；保留符合目前映像的上次結果"
-ContainerImageCheckSkipped: "略過 {{ .name }}：非 Docker Hub 標籤映像、本機映像或固定 digest"
-ContainerImageCheckAvailable: "容器 {{ .name }} 可升級：{{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "容器 {{ .name }} 未發現更新"
-ContainerImageCheckChanged: "容器 {{ .name }} 已刪除或映像已變更，未儲存本次結果"
-ContainerImageCheckSummary: "檢查結束：成功 {{ .checked }}，可升級 {{ .updates }}，失敗 {{ .failed }}，略過 {{ .skipped }}"
-ContainerImageCheckFailures: "{{ .count }} 個容器檢查失敗，請查看任務日誌"
-
-ErrImageCheckProxyRequired: "目前運行環境下，如需檢查映像是否更新，請先設定代理伺服器"

agent/i18n/lang/zh.yaml

@@ -802,15 +802,3 @@ ErrFeishuUpgradeMounts: "当前挂载无法完整备份或恢复，请使用应
 AgentFeishuRecoveryDisabled: "网关已恢复，飞书保持停用；原配置备份已保留。"
 
 ContainerUpgradeWaiting: "等待容器升级任务执行名额"
-ContainerImageCheckUpdate: "检查更新镜像"
-ContainerImageCheckScope: "检查当前节点全部 {{ .count }} 个容器，不受分页和筛选影响"
-ContainerImageCheckItem: "检查容器 {{ .name }}，镜像 {{ .image }}"
-ContainerImageCheckFailed: "容器 {{ .name }} 检查失败：{{ .error }}；保留匹配当前镜像的上次结果"
-ContainerImageCheckSkipped: "跳过 {{ .name }}：非 Docker Hub 标签镜像、本地镜像或固定 digest"
-ContainerImageCheckAvailable: "容器 {{ .name }} 可升级：{{ .image }} → {{ .target }}"
-ContainerImageCheckCurrent: "容器 {{ .name }} 未发现更新"
-ContainerImageCheckChanged: "容器 {{ .name }} 已删除或镜像发生变化，未保存本次结果"
-ContainerImageCheckSummary: "检查结束：成功 {{ .checked }}，可升级 {{ .updates }}，失败 {{ .failed }}，跳过 {{ .skipped }}"
-ContainerImageCheckFailures: "{{ .count }} 个容器检查失败，请查看任务日志"
-
-ErrImageCheckProxyRequired: "当前运行环境下，如需检查镜像是否更新，请优先配置代理服务器"

agent/init/migration/migrate.go

@@ -119,7 +119,6 @@ func agentDBMigrations() []*gormigrate.Migration {
 		migrations.AddQuickDirectory,
 		migrations.AddLocalModelAccountLink,
 		migrations.AddOllamaModelAccountSync,
-		migrations.AddContainerImageCheckUpdates,
 	}
 }
 

agent/init/migration/migrations/container_image_check_update.go

@@ -1,17 +0,0 @@
-package migrations
-
-import (
-	"github.com/1Panel-dev/1Panel/agent/app/model"
-	"github.com/go-gormigrate/gormigrate/v2"
-	"gorm.io/gorm"
-)
-
-var AddContainerImageCheckUpdates = &gormigrate.Migration{
-	ID: "20261028-container-image-updates",
-	Migrate: func(tx *gorm.DB) error {
-		if err := tx.AutoMigrate(&model.ContainerImageCheckUpdate{}); err != nil {
-			return err
-		}
-		return tx.Where("key = ?", "ContainerImageUpdateEnabled").FirstOrCreate(&model.Setting{Key: "ContainerImageUpdateEnabled", Value: "Disable"}).Error
-	},
-}

agent/router/ro_container.go

@@ -16,9 +16,6 @@ func (s *ContainerRouter) InitRouter(Router *gin.RouterGroup) {
 		baRouter.POST("", baseApi.ContainerCreate)
 		baRouter.POST("/update", baseApi.ContainerUpdate)
 		baRouter.POST("/upgrade", baseApi.ContainerUpgrade)
-		baRouter.GET("/image-updates", baseApi.GetContainerImageCheckUpdateStatus)
-		baRouter.POST("/image-updates/check", baseApi.ContainerImageCheckUpdate)
-		baRouter.POST("/image-updates/schedule", baseApi.SetContainerImageCheckUpdateSchedule)
 		baRouter.POST("/info", baseApi.ContainerInfo)
 		baRouter.POST("/search", baseApi.SearchContainer)
 		baRouter.POST("/list", baseApi.ListContainer)
@@ -67,7 +64,6 @@ func (s *ContainerRouter) InitRouter(Router *gin.RouterGroup) {
 		baRouter.POST("/template", baseApi.CreateComposeTemplate)
 		baRouter.POST("/template/del", baseApi.DeleteComposeTemplate)
 
-		baRouter.GET("/image/remote/check", baseApi.GetImageRemoteCheckStatus)
 		baRouter.GET("/image", baseApi.ListImage)
 		baRouter.GET("/image/all", baseApi.ListAllImage)
 		baRouter.POST("/image/search", baseApi.SearchImage)

agent/utils/appicon/appicon.go

@@ -6,13 +6,42 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"
+	"unicode"
 
 	"github.com/1Panel-dev/1Panel/agent/global"
 )
 
 const IconPrefix = "app_"
 
+func IsRemoteURL(icon string) bool {
+	for _, ch := range icon {
+		if unicode.IsSpace(ch) || unicode.IsControl(ch) || ch == '\\' {
+			return false
+		}
+	}
+	u, err := url.Parse(icon)
+	if err != nil || (!strings.EqualFold(u.Scheme, "http") && !strings.EqualFold(u.Scheme, "https")) || u.Hostname() == "" || u.User != nil {
+		return false
+	}
+	if u.Port() != "" {
+		port, err := strconv.Atoi(u.Port())
+		if err != nil || port > 65535 {
+			return false
+		}
+	}
+	_, err = url.QueryUnescape(u.RawQuery)
+	return err == nil
+}
+
+func RemoteURL(icon string) string {
+	if IsRemoteURL(icon) {
+		return icon
+	}
+	return ""
+}
+
 func IsIconFile(icon string) bool {
 	return strings.HasPrefix(icon, IconPrefix)
 }

agent/utils/appicon/appicon_test.go

@@ -0,0 +1,37 @@
+package appicon
+
+import "testing"
+
+func TestRemoteURLPreservesValidSources(t *testing.T) {
+	for _, value := range []string{
+		"https://cdn.example/icon.png",
+		"http://cdn.example:8080/icon.png",
+		"HTTPS://cdn.example/icon.png?token=a%2Bb&v=42#image",
+		"https://[::1]:8443/icon.png",
+	} {
+		t.Run(value, func(t *testing.T) {
+			if !IsRemoteURL(value) || RemoteURL(value) != value {
+				t.Fatalf("URL was rejected or rewritten: %q", value)
+			}
+		})
+	}
+}
+
+func TestRemoteURLRejectsOtherIconFormatsAndAmbiguousURLs(t *testing.T) {
+	for _, value := range []string{
+		"", "app_php.png?etag=42", "iVBORw0KGgo=", "data:image/png;base64,iVBORw0KGgo=",
+		"javascript:alert(1)", "file:///icon.png", "//cdn.example/icon.png", "https:///icon.png",
+		"https://", "https://user:secret@cdn.example/icon.png", "https://@cdn.example/icon.png",
+		" https://cdn.example/icon.png", "https://cdn.example/icon.png ", "https://cdn.example/icon image.png",
+		"https://cdn.example/\nicon.png", "https://cdn.example/icon.png\r\nLocation: https://other.example",
+		"https://cdn.example/\\other.png", "https://cdn.example:bad/icon.png", "https://cdn.example/%zz",
+		"https://cdn.example/icon.png?token=%zz", "https://cdn.example/\u00a0icon.png", "https://cdn.example/\x7ficon.png",
+		"https://cdn.example:65536/icon.png",
+	} {
+		t.Run(value, func(t *testing.T) {
+			if IsRemoteURL(value) || RemoteURL(value) != "" {
+				t.Fatalf("invalid or historical icon was classified as a remote URL: %q", value)
+			}
+		})
+	}
+}

agent/utils/dockerhub/client.go

@@ -1,323 +0,0 @@
-// Package dockerhub checks Docker Hub metadata without downloading image layers.
-package dockerhub
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/url"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/1Panel-dev/1Panel/agent/app/model"
-	"github.com/1Panel-dev/1Panel/agent/buserr"
-	"github.com/1Panel-dev/1Panel/agent/global"
-	"github.com/1Panel-dev/1Panel/agent/utils/encrypt"
-	"github.com/distribution/reference"
-)
-
-const registryURL = "https://registry-1.docker.io"
-
-// Reference only accepts tagged Docker Hub references. Digest pins are intentional.
-func Reference(raw string) (string, string, bool) {
-	if strings.HasPrefix(raw, "sha256:") {
-		return "", "", false
-	}
-	ref, err := reference.ParseNormalizedNamed(raw)
-	if err != nil || reference.Domain(ref) != "docker.io" {
-		return "", "", false
-	}
-	if _, pinned := ref.(reference.Digested); pinned {
-		return "", "", false
-	}
-	tagged := reference.TagNameOnly(ref).(reference.NamedTagged)
-	return reference.Path(ref), tagged.Tag(), true
-}
-
-type Client struct {
-	HTTP       *http.Client
-	repository string
-	token      string
-}
-
-type Platform struct{ OS, Architecture, Variant string }
-type Target struct{ Tag, Digest, ConfigDigest string }
-
-func New(ctx context.Context, repository, username, password string, httpClient *http.Client) (*Client, error) {
-	if httpClient == nil {
-		httpClient = &http.Client{Timeout: 30 * time.Second}
-	}
-	c := &Client{HTTP: httpClient, repository: repository}
-	endpoint := "https://auth.docker.io/token?service=registry.docker.io&scope=" + url.QueryEscape("repository:"+repository+":pull")
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-	if username != "" {
-		req.SetBasicAuth(username, password)
-	}
-	resp, err := c.HTTP.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("Docker Hub authentication: HTTP %d", resp.StatusCode)
-	}
-	var body struct {
-		Token       string `json:"token"`
-		AccessToken string `json:"access_token"`
-	}
-	if err := json.NewDecoder(io.LimitReader(resp.Body, 1<<20)).Decode(&body); err != nil {
-		return nil, err
-	}
-	c.token = body.Token
-	if c.token == "" {
-		c.token = body.AccessToken
-	}
-	if c.token == "" {
-		return nil, fmt.Errorf("Docker Hub returned an empty token")
-	}
-	return c, nil
-}
-
-func (c *Client) get(ctx context.Context, endpoint string, result interface{}) (http.Header, error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+c.token)
-	req.Header.Set("Accept", "application/vnd.oci.image.index.v1+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.docker.distribution.manifest.v2+json")
-	resp, err := c.HTTP.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("Docker Hub metadata: HTTP %d", resp.StatusCode)
-	}
-	err = json.NewDecoder(io.LimitReader(resp.Body, 16<<20)).Decode(result)
-	return resp.Header, err
-}
-
-func (c *Client) Tags(ctx context.Context) ([]string, error) {
-	endpoint := registryURL + "/v2/" + c.repository + "/tags/list?n=1000"
-	var tags []string
-	for page := 0; page < 100; page++ {
-		var body struct {
-			Tags []string `json:"tags"`
-		}
-		headers, err := c.get(ctx, endpoint, &body)
-		if err != nil {
-			return nil, err
-		}
-		tags = append(tags, body.Tags...)
-		link := headers.Get("Link")
-		if link == "" {
-			return tags, nil
-		}
-		start, end := strings.Index(link, "<"), strings.Index(link, ">")
-		if start < 0 || end <= start {
-			return nil, fmt.Errorf("invalid Docker Hub pagination")
-		}
-		base, _ := url.Parse(registryURL)
-		next, err := base.Parse(link[start+1 : end])
-		if err != nil || next.Scheme != "https" || next.Host != base.Host || next.Path != "/v2/"+c.repository+"/tags/list" {
-			return nil, fmt.Errorf("invalid Docker Hub pagination URL")
-		}
-		endpoint = next.String()
-	}
-	return nil, fmt.Errorf("Docker Hub tag pagination limit exceeded")
-}
-
-type manifest struct {
-	Config struct {
-		Digest string `json:"digest"`
-	} `json:"config"`
-	Manifests []struct {
-		Digest   string `json:"digest"`
-		Platform struct {
-			OS           string `json:"os"`
-			Architecture string `json:"architecture"`
-			Variant      string `json:"variant"`
-		} `json:"platform"`
-	} `json:"manifests"`
-}
-
-func (c *Client) Resolve(ctx context.Context, tag string, platform Platform) (Target, bool, error) {
-	var m manifest
-	headers, err := c.get(ctx, registryURL+"/v2/"+c.repository+"/manifests/"+url.PathEscape(tag), &m)
-	if err != nil {
-		return Target{}, false, err
-	}
-	digest := headers.Get("Docker-Content-Digest")
-	if len(m.Manifests) > 0 {
-		digest = ""
-		for _, item := range m.Manifests {
-			if item.Platform.OS == platform.OS && item.Platform.Architecture == platform.Architecture && normalizedVariant(platform.Architecture, item.Platform.Variant) == normalizedVariant(platform.Architecture, platform.Variant) {
-				digest = item.Digest
-				break
-			}
-		}
-		if digest == "" {
-			return Target{}, false, nil
-		}
-		m = manifest{}
-		if _, err := c.get(ctx, registryURL+"/v2/"+c.repository+"/manifests/"+url.PathEscape(digest), &m); err != nil {
-			return Target{}, false, err
-		}
-	}
-	if m.Config.Digest == "" {
-		return Target{}, false, fmt.Errorf("unsupported Docker Hub manifest")
-	}
-	// Validate single-platform manifests too; the config digest is the Docker Image ID.
-	var config struct {
-		OS           string `json:"os"`
-		Architecture string `json:"architecture"`
-		Variant      string `json:"variant"`
-	}
-	if _, err := c.get(ctx, registryURL+"/v2/"+c.repository+"/blobs/"+url.PathEscape(m.Config.Digest), &config); err != nil {
-		return Target{}, false, err
-	}
-	if config.OS != platform.OS || config.Architecture != platform.Architecture || (platform.Variant != "" && config.Variant != "" && config.Variant != platform.Variant) {
-		return Target{}, false, nil
-	}
-	return Target{Tag: tag, Digest: digest, ConfigDigest: m.Config.Digest}, true, nil
-}
-
-var versionPattern = regexp.MustCompile(`^v?(\d+)\.(\d+)(?:\.(\d+))?(-[a-zA-Z][a-zA-Z0-9_.-]*)?$`)
-var prereleasePattern = regexp.MustCompile(`(?i)(^|[-_.])(alpha|beta|rc|dev|nightly|edge|test|unstable|preview)([0-9_.-]|$)`)
-
-type version struct {
-	numbers [3]uint64
-	parts   int
-	variant string
-}
-
-func parseVersion(tag string) (version, bool) {
-	m := versionPattern.FindStringSubmatch(tag)
-	if m == nil || prereleasePattern.MatchString(m[4]) {
-		return version{}, false
-	}
-	v := version{parts: 2, variant: m[4]}
-	for i := 0; i < 3; i++ {
-		if m[i+1] != "" {
-			n, err := strconv.ParseUint(m[i+1], 10, 64)
-			if err != nil {
-				return version{}, false
-			}
-			v.numbers[i] = n
-		}
-	}
-	if m[3] != "" {
-		v.parts = 3
-	}
-	return v, true
-}
-func greater(a, b version) bool {
-	for i := 0; i < 3; i++ {
-		if a.numbers[i] != b.numbers[i] {
-			return a.numbers[i] > b.numbers[i]
-		}
-	}
-	return false
-}
-
-// Candidates preserves the current tag's major version, variant and precision. Unknown/floating
-// tags are checked only for content changes, never guessed from upload dates.
-func Candidates(current string, tags []string) []string {
-	baseline, ok := parseVersion(current)
-	if !ok {
-		return []string{current}
-	}
-	type candidate struct {
-		tag     string
-		version version
-	}
-	candidates := []candidate{}
-	seen := map[string]bool{}
-	for _, tag := range tags {
-		v, valid := parseVersion(tag)
-		if valid && v.numbers[0] == baseline.numbers[0] && v.parts == baseline.parts && v.variant == baseline.variant && greater(v, baseline) && !seen[tag] {
-			candidates = append(candidates, candidate{tag: tag, version: v})
-			seen[tag] = true
-		}
-	}
-	sort.Slice(candidates, func(i, j int) bool {
-		a, b := candidates[i], candidates[j]
-		if a.version.numbers == b.version.numbers {
-			return a.tag < b.tag
-		}
-		return greater(a.version, b.version)
-	})
-	result := make([]string, 0, len(candidates)+1)
-	for _, candidate := range candidates {
-		result = append(result, candidate.tag)
-	}
-
-	return append(result, current)
-}
-
-func NeedsTags(tag string) bool { _, ok := parseVersion(tag); return ok }
-
-func normalizedVariant(architecture, variant string) string {
-	if architecture == "arm64" && variant == "" {
-		return "v8"
-	}
-	return variant
-}
-
-// NewHTTPClient reads the synchronized panel settings for each check, including cron.
-func NewHTTPClient() (*http.Client, error) {
-	var rows []model.Setting
-	if err := global.DB.Where("key IN ?", []string{"Edition", "ProxyType", "ProxyUrl", "ProxyPort", "ProxyUser", "ProxyPasswd"}).Find(&rows).Error; err != nil {
-		return nil, err
-	}
-	settings := make(map[string]string, len(rows))
-	for _, row := range rows {
-		settings[row.Key] = row.Value
-	}
-	client := &http.Client{Timeout: 30 * time.Second}
-	if settings["Edition"] == "intl" {
-		return client, nil
-	}
-	kind, host, port := settings["ProxyType"], strings.TrimSpace(settings["ProxyUrl"]), settings["ProxyPort"]
-	if kind == "" || kind == "close" || host == "" || port == "" {
-		return nil, buserr.New("ErrImageCheckProxyRequired")
-	}
-	if kind != "http" && kind != "https" && kind != "socks5" {
-		return nil, buserr.New("ErrImageCheckProxyRequired")
-	}
-	number, err := strconv.Atoi(port)
-	if err != nil || number < 1 || number > 65535 {
-		return nil, buserr.New("ErrImageCheckProxyRequired")
-	}
-	if !strings.Contains(host, "://") {
-		host = kind + "://" + host
-	}
-	address, err := url.Parse(host)
-	if err != nil || address.Scheme != kind || address.Hostname() == "" || address.User != nil || address.RawQuery != "" || address.Fragment != "" || (address.Path != "" && address.Path != "/") {
-		return nil, buserr.New("ErrImageCheckProxyRequired")
-	}
-	address.Host = net.JoinHostPort(address.Hostname(), port)
-	address.Path = ""
-	if settings["ProxyUser"] != "" {
-		password, err := encrypt.StringDecrypt(settings["ProxyPasswd"])
-		if err != nil {
-			return nil, buserr.New("ErrImageCheckProxyRequired")
-		}
-		address.User = url.UserPassword(settings["ProxyUser"], password)
-	}
-	transport := http.DefaultTransport.(*http.Transport).Clone()
-	// Explicit proxy selection prevents NO_PROXY from bypassing the panel proxy.
-	// net/http also supports SOCKS5 URLs and proxy authentication.
-	transport.Proxy = http.ProxyURL(address)
-	client.Transport = transport
-	return client, nil
-}

core/app/api/v2/api_key.go

@@ -15,7 +15,7 @@ import (
 )
 
 func bindAPIKeyRequest(c *gin.Context, value interface{}) bool {
-	if _, err := auth.RequireAPIKeySession(c); err != nil {
+	if _, err := auth.RequireAPIKeyManagement(c); err != nil {
 		helper.BadAuth(c, "ErrNotLogin", nil)
 		return false
 	}
@@ -41,6 +41,24 @@ func apiKeyError(c *gin.Context, err error) {
 	helper.InternalServer(c, err)
 }
 
+// Swag's legacy || syntax combines schemes in one requirement (AND);
+// separate @Security lines represent alternative authentication methods.
+// @Tags API Key
+// @Summary List the current account's API keys
+// @Description Accepts a panel login session with CSRF protection, or a valid API Key signature. The authenticated account determines ownership; another account cannot be selected in the request.
+// @Description Returns key metadata and masked hints, never plaintext secrets. The legacy key is included when present; deleted keys are excluded.
+// @Description Authentication and business errors use HTTP 200 with envelope code 400, 401 or 500; check code rather than HTTP status alone.
+// @Accept json
+// @Produce json
+// @Param request body dto.APIKeySearch true "Pagination and revoked-key filter"
+// @Param 1Panel-Key-ID header string false "Optional ID of the authenticating independent key; omit for legacy keys"
+// @Param 1Panel-Signature-Version header string false "Signature algorithm; omission accepts either supported algorithm" Enums(v1,md5,hmac-sha256)
+// @Success 200 {object} dto.Response{data=dto.APIKeyPage} "code=200 on success; data is null on errors"
+// @Failure 403 {object} dto.Response "Invalid or missing CSRF token for a session request"
+// @Header 200 {string} Cache-Control "no-store"
+// @Security ApiKeyAuth || Timestamp
+// @Security PanelSession || CSRFToken
+// @Router /core/auth/api/keys/search [post]
 func (b *BaseApi) SearchAPIKeys(c *gin.Context) {
 	var req dto.APIKeySearch
 	if !bindAPIKeyRequest(c, &req) {
@@ -55,6 +73,25 @@ func (b *BaseApi) SearchAPIKeys(c *gin.Context) {
 	helper.SuccessWithData(c, result)
 }
 
+// @Tags API Key
+// @Summary Create an API key for the current account
+// @Description Accepts a panel login session with CSRF protection, or a valid API Key signature. The new key belongs to the authenticated account.
+// @Description requestID is optional. Omitted or empty values are generated by the server. For idempotent retries, supply a UUID and reuse it with the same payload.
+// @Description A successful first request returns the plaintext secret. Repeating the same requestID and payload returns alreadyCreated=true and an empty apiKey; changing the payload for that requestID is rejected.
+// @Description Omitted expiresAt defaults to 90 days; explicit null means no expiration. Omitted apiKeyValidityTime defaults to 120 minutes; zero disables timestamp validation.
+// @Description API-created keys may have a longer lifetime or broader IP policy than the calling key. Revoking the calling key does not revoke keys it created.
+// @Description Authentication and business errors use HTTP 200 with envelope code 400, 401 or 500; check code rather than HTTP status alone. Unknown fields and bodies larger than 32 KiB are rejected.
+// @Accept json
+// @Produce json
+// @Param request body dto.APIKeyCreate true "Key policy and an optional UUID requestID for idempotency"
+// @Param 1Panel-Key-ID header string false "Optional ID of the authenticating independent key; omit for legacy keys"
+// @Param 1Panel-Signature-Version header string false "Signature algorithm; omission accepts either supported algorithm" Enums(v1,md5,hmac-sha256)
+// @Success 200 {object} dto.Response{data=dto.APIKeyCreated} "code=200 on success; data is null on errors"
+// @Failure 403 {object} dto.Response "Invalid or missing CSRF token for a session request"
+// @Header 200 {string} Cache-Control "no-store"
+// @Security ApiKeyAuth || Timestamp
+// @Security PanelSession || CSRFToken
+// @Router /core/auth/api/keys/create [post]
 func (b *BaseApi) CreateAPIKey(c *gin.Context) {
 	req := dto.APIKeyCreate{APIKeyFields: dto.APIKeyFields{APIKeyValidityTime: 120}}
 	if !bindAPIKeyRequest(c, &req) {
@@ -69,6 +106,22 @@ func (b *BaseApi) CreateAPIKey(c *gin.Context) {
 	helper.SuccessWithData(c, result)
 }
 
+// @Tags API Key
+// @Summary Update an API key's policy
+// @Description Accepts a panel login session with CSRF protection, or a valid API Key signature. Only keys owned by the authenticated account can be changed.
+// @Description Submit the current revision returned by search; stale revisions are rejected. This replaces editable policy fields without changing the secret. expiresAt must be supplied as an RFC 3339 timestamp or null.
+// @Description Use id=legacy for the legacy key; its name is fixed and expiresAt must be null. Revoked or deleted independent keys cannot be updated.
+// @Description Success increments the revision; search again before another mutation. Authentication and business errors use HTTP 200 with envelope code 400, 401 or 500.
+// @Accept json
+// @Produce json
+// @Param request body dto.APIKeyUpdate true "Key ID, current revision and complete editable policy"
+// @Param 1Panel-Key-ID header string false "Optional ID of the authenticating independent key; omit for legacy keys"
+// @Param 1Panel-Signature-Version header string false "Signature algorithm; omission accepts either supported algorithm" Enums(v1,md5,hmac-sha256)
+// @Success 200 {object} dto.Response{data=dto.APIKeyMutationResult} "code=200 on success; data is null on errors"
+// @Failure 403 {object} dto.Response "Invalid or missing CSRF token for a session request"
+// @Security ApiKeyAuth || Timestamp
+// @Security PanelSession || CSRFToken
+// @Router /core/auth/api/keys/update [post]
 func (b *BaseApi) UpdateAPIKey(c *gin.Context) {
 	var req dto.APIKeyUpdate
 	if !bindAPIKeyRequest(c, &req) {
@@ -81,6 +134,21 @@ func (b *BaseApi) UpdateAPIKey(c *gin.Context) {
 	apiKeyMutationSuccess(c)
 }
 
+// @Tags API Key
+// @Summary Enable or disable an API key
+// @Description Accepts a panel login session with CSRF protection, or a valid API Key signature. Only keys owned by the authenticated account can be changed; id=legacy is supported.
+// @Description Submit the current revision returned by search. Revoked or deleted keys cannot be enabled; expired keys must first receive a future expiration time. Disabling a key also closes its active terminal sessions.
+// @Description Success increments the revision; search again before another mutation. Authentication and business errors use HTTP 200 with envelope code 400, 401 or 500.
+// @Accept json
+// @Produce json
+// @Param request body dto.APIKeyStatus true "Key ID, current revision and Enable or Disable status"
+// @Param 1Panel-Key-ID header string false "Optional ID of the authenticating independent key; omit for legacy keys"
+// @Param 1Panel-Signature-Version header string false "Signature algorithm; omission accepts either supported algorithm" Enums(v1,md5,hmac-sha256)
+// @Success 200 {object} dto.Response{data=dto.APIKeyMutationResult} "code=200 on success; data is null on errors"
+// @Failure 403 {object} dto.Response "Invalid or missing CSRF token for a session request"
+// @Security ApiKeyAuth || Timestamp
+// @Security PanelSession || CSRFToken
+// @Router /core/auth/api/keys/status [post]
 func (b *BaseApi) SetAPIKeyStatus(c *gin.Context) {
 	var req dto.APIKeyStatus
 	if !bindAPIKeyRequest(c, &req) {
@@ -93,6 +161,22 @@ func (b *BaseApi) SetAPIKeyStatus(c *gin.Context) {
 	apiKeyMutationSuccess(c)
 }
 
+// @Tags API Key
+// @Summary Revoke an API key
+// @Description Accepts a panel login session with CSRF protection, or a valid API Key signature. Only keys owned by the authenticated account can be revoked.
+// @Description Submit the current revision returned by search. Revocation destroys the independent key's stored secret and cannot be undone; its metadata remains listed. For id=legacy, the legacy secret is cleared and API access is disabled.
+// @Description A key can revoke itself; subsequent requests signed with it fail. Keys previously created by the revoked key remain independent. Success increments the revision and closes associated terminal sessions.
+// @Description Authentication and business errors use HTTP 200 with envelope code 400, 401 or 500.
+// @Accept json
+// @Produce json
+// @Param request body dto.APIKeyMutation true "Key ID and current revision"
+// @Param 1Panel-Key-ID header string false "Optional ID of the authenticating independent key; omit for legacy keys"
+// @Param 1Panel-Signature-Version header string false "Signature algorithm; omission accepts either supported algorithm" Enums(v1,md5,hmac-sha256)
+// @Success 200 {object} dto.Response{data=dto.APIKeyMutationResult} "code=200 on success; data is null on errors"
+// @Failure 403 {object} dto.Response "Invalid or missing CSRF token for a session request"
+// @Security ApiKeyAuth || Timestamp
+// @Security PanelSession || CSRFToken
+// @Router /core/auth/api/keys/revoke [post]
 func (b *BaseApi) RevokeAPIKey(c *gin.Context) {
 	var req dto.APIKeyMutation
 	if !bindAPIKeyRequest(c, &req) {
@@ -106,5 +190,63 @@ func (b *BaseApi) RevokeAPIKey(c *gin.Context) {
 }
 
 func apiKeyMutationSuccess(c *gin.Context) {
-	helper.SuccessWithData(c, gin.H{"terminalClosePending": c.GetBool("API_KEY_TERMINAL_CLOSE_PENDING")})
+	helper.SuccessWithData(c, dto.APIKeyMutationResult{TerminalClosePending: c.GetBool("API_KEY_TERMINAL_CLOSE_PENDING")})
+}
+
+// @Tags API Key
+// @Summary Delete an independent API key
+// @Description Accepts a panel login session with CSRF protection, or a valid API Key signature. Only keys owned by the authenticated account can be deleted; id=legacy is not supported.
+// @Description Submit the current revision returned by search. Deletion immediately revokes the key, destroys its stored secret and removes it from lists. Audit and idempotency records are retained. Already-revoked keys can be deleted; deletion cannot be undone.
+// @Description A key can delete itself; subsequent requests signed with it fail. Authentication and business errors use HTTP 200 with envelope code 400, 401 or 500.
+// @Accept json
+// @Produce json
+// @Param request body dto.APIKeyMutation true "Independent key ID and current revision"
+// @Param 1Panel-Key-ID header string false "Optional ID of the authenticating independent key; omit for legacy keys"
+// @Param 1Panel-Signature-Version header string false "Signature algorithm; omission accepts either supported algorithm" Enums(v1,md5,hmac-sha256)
+// @Success 200 {object} dto.Response{data=dto.APIKeyMutationResult} "code=200 on success; data is null on errors"
+// @Failure 403 {object} dto.Response "Invalid or missing CSRF token for a session request"
+// @Security ApiKeyAuth || Timestamp
+// @Security PanelSession || CSRFToken
+// @Router /core/auth/api/keys/delete [post]
+func (b *BaseApi) DeleteAPIKey(c *gin.Context) {
+	var req dto.APIKeyMutation
+	if !bindAPIKeyRequest(c, &req) {
+		return
+	}
+	if err := service.NewAPIKeyService().Delete(c, req); err != nil {
+		apiKeyError(c, err)
+		return
+	}
+	apiKeyMutationSuccess(c)
+}
+
+// @Tags API Key
+// @Summary Reveal an independent API key's plaintext secret
+// @Description Requires a panel login session and CSRF token. API Key authentication is not supported, including requests that also contain a valid session cookie; omit all 1Panel authentication headers.
+// @Description Only the current account's independent keys can be revealed. Submit the current revision returned by search. Legacy, revoked and deleted keys are rejected; disabled or expired keys can still be revealed.
+// @Description Secret disclosure is audited. Authentication and business errors use HTTP 200 with envelope code 400, 401 or 500. The response must not be cached or logged.
+// @Accept json
+// @Produce json
+// @Param request body dto.APIKeyMutation true "Independent key ID and current revision"
+// @Success 200 {object} dto.Response{data=dto.APIKeyRevealed} "code=200 on success; data is null on errors"
+// @Failure 403 {object} dto.Response "Invalid or missing CSRF token"
+// @Header 200 {string} Cache-Control "no-store"
+// @Security PanelSession || CSRFToken
+// @Router /core/auth/api/keys/reveal [post]
+func (b *BaseApi) RevealAPIKey(c *gin.Context) {
+	c.Header("Cache-Control", "no-store")
+	if _, err := auth.RequireAPIKeySession(c); err != nil {
+		helper.BadAuth(c, "ErrNotLogin", nil)
+		return
+	}
+	var req dto.APIKeyMutation
+	if !bindAPIKeyRequest(c, &req) {
+		return
+	}
+	result, err := service.NewAPIKeyService().Reveal(c, req)
+	if err != nil {
+		apiKeyError(c, err)
+		return
+	}
+	helper.SuccessWithData(c, result)
 }

core/app/api/v2/auth.go

@@ -417,11 +417,13 @@ func (b *BaseApi) MFAClose(c *gin.Context) {
 }
 
 // @Tags Auth
-// @Summary generate api key
+// @Summary Generate or reset the legacy API key
+// @Description Requires a panel login session and CSRF token. API Key authentication is not supported. This replaces the current account's legacy secret; existing clients using the previous secret must be updated. Independent API keys are unaffected.
 // @Accept json
-// @Success 200 {string} key
+// @Produce json
-// @Security ApiKeyAuth
+// @Success 200 {object} dto.Response{data=string} "code=200 with the new secret; authentication and business errors use envelope code 400, 401 or 500"
-// @Security Timestamp
+// @Header 200 {string} Cache-Control "no-store"
+// @Security PanelSession || CSRFToken
 // @Router /core/auth/api/generate [post]
 // @x-panel-log {"bodyKeys":[],"paramKeys":[],"BeforeFunctions":[],"formatZH":"生成 API 接口密钥","formatEN":"generate api key"}
 func (b *BaseApi) GenerateApiKey(c *gin.Context) {
@@ -440,12 +442,13 @@ func (b *BaseApi) GenerateApiKey(c *gin.Context) {
 }
 
 // @Tags Auth
-// @Summary Update api config
+// @Summary Update the legacy API key configuration
+// @Description Requires a panel login session and CSRF token. API Key authentication is not supported. This updates only the current account's legacy API configuration.
 // @Accept json
+// @Produce json
 // @Param request body dto.ApiInterfaceConfig true "request"
-// @Success 200
+// @Success 200 {object} dto.Response "code=200 on success; authentication and business errors use envelope code 400, 401 or 500"
-// @Security ApiKeyAuth
+// @Security PanelSession || CSRFToken
-// @Security Timestamp
 // @Router /core/auth/api/update [post]
 // @x-panel-log {"bodyKeys":["ipWhiteList","apiTrustedProxies"],"paramKeys":[],"BeforeFunctions":[],"formatZH":"更新 API 接口配置 => IP 白名单: [ipWhiteList], API 可信代理: [apiTrustedProxies]","formatEN":"update api config => IP Allowlist: [ipWhiteList], API Trusted Proxies: [apiTrustedProxies]"}
 func (b *BaseApi) UpdateApiConfig(c *gin.Context) {

core/app/auth/api_auth.go

@@ -7,6 +7,7 @@ import (
 	"encoding/hex"
 	"errors"
 	"net"
+	"net/http"
 	"strconv"
 	"strings"
 	"time"
@@ -42,7 +43,7 @@ func APIAuthMiddleware(loadConfig APIAuthConfigLoader, onSuccess APIAuthSuccessH
 		ownerProvider = ownerProviders[0]
 	}
 	return func(c *gin.Context) {
-		if strings.HasPrefix(c.Request.URL.Path, "/api/v2/core/auth") {
+		if strings.HasPrefix(c.Request.URL.Path, "/api/v2/core/auth") && !isAPIKeyManagementRequest(c) {
 			c.Next()
 			return
 		}
@@ -97,6 +98,20 @@ func APIAuthMiddleware(loadConfig APIAuthConfigLoader, onSuccess APIAuthSuccessH
 	}
 }
 
+func isAPIKeyManagementRequest(c *gin.Context) bool {
+	if c.Request.Method != http.MethodPost {
+		return false
+	}
+	switch c.Request.URL.Path {
+	case "/api/v2/core/auth/api/keys/search", "/api/v2/core/auth/api/keys/create",
+		"/api/v2/core/auth/api/keys/update", "/api/v2/core/auth/api/keys/status",
+		"/api/v2/core/auth/api/keys/revoke", "/api/v2/core/auth/api/keys/delete":
+		return true
+	default:
+		return false
+	}
+}
+
 func LoadAPIAuthConfig(_ *gin.Context) (APIAuthConfig, error) {
 	settingRepo := repo.NewISettingRepo()
 	config := APIAuthConfig{}

core/app/auth/api_key.go

@@ -66,6 +66,26 @@ func RequireAPIKeySession(c *gin.Context) (psession.SessionUser, error) {
 	return u, nil
 }
 
+func RequireAPIKeyManagement(c *gin.Context) (psession.SessionUser, error) {
+	if c == nil || !c.GetBool("API_AUTH") {
+		return RequireAPIKeySession(c)
+	}
+	if c.GetBool("LOCAL_REQUEST") {
+		return psession.SessionUser{}, buserr.New("ErrNotLogin")
+	}
+	kind, keyID := c.GetString("API_AUTH_KEY_KIND"), c.GetString("API_AUTH_KEY_ID")
+	if (kind != "apiKey" && kind != "legacy") || keyID == "" || (kind == "legacy") != (keyID == "legacy") {
+		return psession.SessionUser{}, buserr.New("ErrNotLogin")
+	}
+	ownerType, ownerID := c.GetString("API_AUTH_OWNER_TYPE"), c.GetString("API_AUTH_OWNER_ID")
+	value, _ := c.Get(psession.GinContextSessionUserKey)
+	u, ok := value.(psession.SessionUser)
+	if (ownerType != APIKeyOwnerPanelAdmin && ownerType != APIKeyOwnerEnterpriseUser) || ownerID == "" || !ok || u.ID != ownerID || u.Name == "" {
+		return psession.SessionUser{}, buserr.New("ErrNotLogin")
+	}
+	return u, nil
+}
+
 func HasAPICredentials(c *gin.Context) bool {
 	return c.GetHeader("1Panel-Token") != "" || c.GetHeader("1Panel-Timestamp") != "" || c.GetHeader("1Panel-Key-ID") != "" || c.GetHeader("1Panel-Signature-Version") != ""
 }
@@ -87,7 +107,7 @@ func LegacyAPIKeyFingerprint(owner APIKeyOwner, config APIAuthConfig, policy mod
 }
 
 func APIKeySecret(key model.APIKey) (string, error) {
-	if key.SecretVersion != 1 || key.SecretCiphertext == "" {
+	if key.DeletedAt != nil || key.Status == "Revoked" || key.SecretVersion != 1 || key.SecretCiphertext == "" {
 		return "", buserr.New("ErrApiConfigKeyInvalid")
 	}
 	master, err := encrypt.APIKeyEncryptionKey()
@@ -98,7 +118,7 @@ func APIKeySecret(key model.APIKey) (string, error) {
 }
 
 func ValidateAPIKeyState(key model.APIKey, now time.Time) error {
-	if key.Status != constant.StatusEnable {
+	if key.DeletedAt != nil || key.Status != constant.StatusEnable {
 		return buserr.New("ErrApiConfigStatusInvalid")
 	}
 	if key.ExpiresAt != nil && !now.Before(*key.ExpiresAt) {
@@ -113,7 +133,7 @@ func configForAPIKey(key model.APIKey, secret string, owner APIKeyOwner) APIAuth
 
 func loadMultiAPIKeyConfig(c *gin.Context, legacy APIAuthConfigLoader, provider APIKeyOwnerProvider) (APIAuthConfig, error) {
 	keyID := c.GetHeader("1Panel-Key-ID")
-	q := global.DB.Model(&model.APIKey{}).Select("id", "secret_ciphertext", "secret_version", "revision")
+	q := global.DB.Model(&model.APIKey{}).Where("deleted_at IS NULL").Select("id", "secret_ciphertext", "secret_version", "revision")
 	if keyID != "" {
 		q = q.Where("id = ?", keyID)
 	} else {

core/app/dto/api_key.go

@@ -6,41 +6,42 @@ import (
 )
 
 type APIKeyItem struct {
-	ID                 string     `json:"id"`
+	ID                 string     `json:"id" example:"8a8f0f77-1ec8-4d46-8f5a-0ea8807e2d8a"`
-	Kind               string     `json:"kind"`
+	Kind               string     `json:"kind" enums:"apiKey,legacy" example:"apiKey"`
-	Name               string     `json:"name"`
+	Name               string     `json:"name" example:"Deployment automation"`
-	Description        string     `json:"description"`
+	Description        string     `json:"description" example:"Used by the deployment service"`
-	KeyHint            string     `json:"keyHint"`
+	KeyHint            string     `json:"keyHint" example:"abcd••••1234"`
-	Status             string     `json:"status"`
+	Status             string     `json:"status" enums:"Enable,Disable,Revoked,Expired" example:"Enable"`
-	IPWhiteList        string     `json:"ipWhiteList"`
+	IPWhiteList        string     `json:"ipWhiteList" example:"192.0.2.10"`
-	APITrustedProxies  string     `json:"apiTrustedProxies"`
+	APITrustedProxies  string     `json:"apiTrustedProxies" example:"192.0.2.1"`
-	APIKeyValidityTime int        `json:"apiKeyValidityTime"`
+	APIKeyValidityTime int        `json:"apiKeyValidityTime" example:"120"`
-	ExpiresAt          *time.Time `json:"expiresAt"`
+	ExpiresAt          *time.Time `json:"expiresAt" format:"date-time" extensions:"x-nullable"`
-	AllowAppBinding    bool       `json:"allowAppBinding"`
+	AllowAppBinding    bool       `json:"allowAppBinding" example:"false"`
-	Revision           uint64     `json:"revision"`
+	Revision           uint64     `json:"revision" minimum:"1" example:"1"`
-	CreatedAt          *time.Time `json:"createdAt"`
+	CreatedAt          *time.Time `json:"createdAt" format:"date-time" extensions:"x-nullable"`
 }
 
 type APIKeySearch struct {
-	Page           int  `json:"page"`
+	Page           int  `json:"page" minimum:"1" example:"1"`
-	PageSize       int  `json:"pageSize"`
+	PageSize       int  `json:"pageSize" minimum:"1" maximum:"100" example:"20"`
-	ExcludeRevoked bool `json:"excludeRevoked"`
+	ExcludeRevoked bool `json:"excludeRevoked" default:"false"`
 }
 type APIKeyPage struct {
 	Items []APIKeyItem `json:"items"`
 	Total int          `json:"total"`
 }
 type APIKeyFields struct {
-	Name               string          `json:"name"`
+	Name               string          `json:"name" minLength:"1" maxLength:"64" example:"Deployment automation"`
-	Description        string          `json:"description"`
+	Description        string          `json:"description" maxLength:"256" example:"Used by the deployment service"`
-	IPWhiteList        string          `json:"ipWhiteList"`
+	IPWhiteList        string          `json:"ipWhiteList" maxLength:"4096" example:"192.0.2.10"`
-	APITrustedProxies  string          `json:"apiTrustedProxies"`
+	APITrustedProxies  string          `json:"apiTrustedProxies" maxLength:"4096" example:"192.0.2.1"`
-	APIKeyValidityTime int             `json:"apiKeyValidityTime"`
+	APIKeyValidityTime int             `json:"apiKeyValidityTime" minimum:"0" maximum:"1440" example:"120"`
-	ExpiresAt          json.RawMessage `json:"expiresAt"`
+	ExpiresAt          json.RawMessage `json:"expiresAt" swaggertype:"string" format:"date-time" extensions:"x-nullable" example:"2030-01-01T00:00:00Z"`
-	AllowAppBinding    bool            `json:"allowAppBinding"`
+	AllowAppBinding    bool            `json:"allowAppBinding" default:"false"`
 }
 type APIKeyCreate struct {
-	RequestID string `json:"requestID"`
+	// Optional client-generated UUID for idempotent retries. Omitted or empty values are generated by the server.
+	RequestID string `json:"requestID" format:"uuid" example:"df1a75a3-5f56-4fa3-9e7a-a573a853d894"`
 	APIKeyFields
 }
 type APIKeyCreated struct {
@@ -49,8 +50,15 @@ type APIKeyCreated struct {
 	AlreadyCreated bool       `json:"alreadyCreated,omitempty"`
 }
 type APIKeyMutation struct {
-	ID       string `json:"id"`
+	ID       string `json:"id" example:"8a8f0f77-1ec8-4d46-8f5a-0ea8807e2d8a"`
-	Revision uint64 `json:"revision"`
+	Revision uint64 `json:"revision" minimum:"1" example:"1"`
+}
+type APIKeyMutationResult struct {
+	TerminalClosePending bool `json:"terminalClosePending"`
+}
+type APIKeyRevealed struct {
+	APIKeyMutation
+	APIKey string `json:"apiKey"`
 }
 type APIKeyUpdate struct {
 	APIKeyMutation
@@ -58,5 +66,5 @@ type APIKeyUpdate struct {
 }
 type APIKeyStatus struct {
 	APIKeyMutation
-	Status string `json:"status"`
+	Status string `json:"status" enums:"Enable,Disable" example:"Disable"`
 }

core/app/model/api_key.go

@@ -24,6 +24,7 @@ type APIKey struct {
 	CreatedAt          time.Time  `json:"-"`
 	UpdatedAt          time.Time  `json:"-"`
 	RevokedAt          *time.Time `json:"-"`
+	DeletedAt          *time.Time `json:"-"`
 }
 
 type LegacyAPIKeyPolicy struct {

core/app/repo/api_key.go

@@ -14,12 +14,12 @@ func APIKeyOwnerQuery(db *gorm.DB, ownerType, ownerID string) *gorm.DB {
 }
 func (r *APIKeyRepo) Get(id string) (model.APIKey, error) {
 	var key model.APIKey
-	err := global.DB.Where("id = ?", id).First(&key).Error
+	err := global.DB.Where("id = ? AND deleted_at IS NULL", id).First(&key).Error
 	return key, err
 }
 func (r *APIKeyRepo) List(ownerType, ownerID string, excludeRevoked bool) ([]model.APIKey, error) {
 	items := make([]model.APIKey, 0)
-	q := APIKeyOwnerQuery(global.DB, ownerType, ownerID)
+	q := APIKeyOwnerQuery(global.DB, ownerType, ownerID).Where("deleted_at IS NULL")
 	if excludeRevoked {
 		q = q.Where("status <> ?", "Revoked")
 	}

core/app/service/api_key.go

@@ -52,6 +52,27 @@ func (s *APIKeyService) owner(c *gin.Context) (auth.APIKeyOwner, error) {
 	return s.Provider.CurrentAPIKeyOwner(c)
 }
 
+func (s *APIKeyService) managementOwner(c *gin.Context) (auth.APIKeyOwner, error) {
+	if _, err := auth.RequireAPIKeyManagement(c); err != nil {
+		return auth.APIKeyOwner{}, err
+	}
+	if s.Provider == nil {
+		return auth.APIKeyOwner{}, buserr.New("ErrApiConfigStatusInvalid")
+	}
+	if !c.GetBool("API_AUTH") {
+		return s.Provider.CurrentAPIKeyOwner(c)
+	}
+	ownerType, ownerID := c.GetString("API_AUTH_OWNER_TYPE"), c.GetString("API_AUTH_OWNER_ID")
+	owner, err := s.Provider.ResolveAPIKeyOwner(c, ownerType, ownerID)
+	if err != nil {
+		return auth.APIKeyOwner{}, err
+	}
+	if owner.Type != ownerType || owner.ID != ownerID {
+		return auth.APIKeyOwner{}, buserr.New("ErrNotLogin")
+	}
+	return owner, nil
+}
+
 func apiKeyItem(key model.APIKey) dto.APIKeyItem {
 	status := key.Status
 	if status != "Revoked" && key.ExpiresAt != nil && !time.Now().Before(*key.ExpiresAt) {
@@ -75,7 +96,7 @@ func (s *APIKeyService) legacy(owner auth.APIKeyOwner) (dto.APIKeyItem, auth.API
 }
 
 func (s *APIKeyService) Search(c *gin.Context, req dto.APIKeySearch) (*dto.APIKeyPage, error) {
-	owner, err := s.owner(c)
+	owner, err := s.managementOwner(c)
 	if err != nil {
 		return nil, err
 	}
@@ -146,11 +167,13 @@ func keyHint(secret string) string {
 }
 
 func (s *APIKeyService) Create(c *gin.Context, req dto.APIKeyCreate) (*dto.APIKeyCreated, error) {
-	owner, err := s.owner(c)
+	owner, err := s.managementOwner(c)
 	if err != nil {
 		return nil, err
 	}
-	if _, err = uuid.Parse(req.RequestID); err != nil {
+	if req.RequestID == "" {
+		req.RequestID = uuid.NewString()
+	} else if _, err = uuid.Parse(req.RequestID); err != nil {
 		return nil, buserr.New("ErrInvalidParams")
 	}
 	expires, err := validateAPIKeyFields(&req.APIKeyFields, true)
@@ -172,6 +195,9 @@ func (s *APIKeyService) Create(c *gin.Context, req dto.APIKeyCreate) (*dto.APIKe
 		q := repo.APIKeyOwnerQuery(tx, owner.Type, owner.ID)
 		err := q.Where("request_id = ?", req.RequestID).First(&key).Error
 		if err == nil {
+			if key.DeletedAt != nil {
+				return buserr.New("ErrAPIKeyNotFound")
+			}
 			if key.RequestHash != requestHash {
 				return buserr.New("ErrAPIKeyConflict")
 			}
@@ -219,7 +245,7 @@ func ensureAPIKeyName(tx *gorm.DB, owner auth.APIKeyOwner, name, id string) erro
 }
 
 func (s *APIKeyService) Update(c *gin.Context, req dto.APIKeyUpdate) error {
-	owner, err := s.owner(c)
+	owner, err := s.managementOwner(c)
 	if err != nil {
 		return err
 	}
@@ -247,7 +273,7 @@ func (s *APIKeyService) Update(c *gin.Context, req dto.APIKeyUpdate) error {
 }
 
 func (s *APIKeyService) Status(c *gin.Context, req dto.APIKeyStatus) error {
-	owner, err := s.owner(c)
+	owner, err := s.managementOwner(c)
 	if err != nil {
 		return err
 	}
@@ -271,7 +297,7 @@ func (s *APIKeyService) Status(c *gin.Context, req dto.APIKeyStatus) error {
 }
 
 func (s *APIKeyService) Revoke(c *gin.Context, req dto.APIKeyMutation) error {
-	owner, err := s.owner(c)
+	owner, err := s.managementOwner(c)
 	if err != nil {
 		return err
 	}
@@ -289,21 +315,75 @@ func (s *APIKeyService) Revoke(c *gin.Context, req dto.APIKeyMutation) error {
 	})
 }
 
+func (s *APIKeyService) Delete(c *gin.Context, req dto.APIKeyMutation) error {
+	owner, err := s.managementOwner(c)
+	if err != nil {
+		return err
+	}
+	if req.ID == "legacy" {
+		return buserr.New("ErrInvalidParams")
+	}
+	return s.mutate(c, owner, req, "delete", func(_ *gorm.DB, key *model.APIKey) error {
+		now := time.Now()
+		key.Status = "Revoked"
+		if key.RevokedAt == nil {
+			key.RevokedAt = &now
+		}
+		key.DeletedAt = &now
+		key.ActiveName = nil
+		key.SecretCiphertext = ""
+		key.KeyHint = ""
+		key.AllowAppBinding = false
+		return nil
+	})
+}
+
+func (s *APIKeyService) Reveal(c *gin.Context, req dto.APIKeyMutation) (*dto.APIKeyRevealed, error) {
+	owner, err := s.owner(c)
+	if err != nil {
+		return nil, err
+	}
+	if req.ID == "" || req.ID == "legacy" || req.Revision == 0 {
+		return nil, buserr.New("ErrInvalidParams")
+	}
+	// Serialize the snapshot and disclosure audit with revocation/deletion.
+	apiKeyMutationMu.Lock()
+	defer apiKeyMutationMu.Unlock()
+	var key model.APIKey
+	if err = repo.APIKeyOwnerQuery(global.DB, owner.Type, owner.ID).Where("id = ? AND deleted_at IS NULL", req.ID).First(&key).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, buserr.New("ErrAPIKeyNotFound")
+		}
+		return nil, err
+	}
+	if key.Revision != req.Revision || key.Status == "Revoked" {
+		return nil, buserr.New("ErrAPIKeyConflict")
+	}
+	secret, err := auth.APIKeySecret(key)
+	if err != nil {
+		return nil, buserr.New("ErrApiConfigKeyInvalid")
+	}
+	if err = apikey_audit.Record(c, apikey_audit.Event{OwnerType: owner.Type, OwnerID: owner.ID, KeyID: key.ID, KeyName: key.Name, Action: "reveal", Status: constant.StatusSuccess}); err != nil {
+		return nil, err
+	}
+	return &dto.APIKeyRevealed{APIKeyMutation: req, APIKey: secret}, nil
+}
+
 func (s *APIKeyService) mutate(c *gin.Context, owner auth.APIKeyOwner, req dto.APIKeyMutation, action string, change func(*gorm.DB, *model.APIKey) error) error {
 	if req.ID == "" || req.Revision == 0 {
 		return buserr.New("ErrInvalidParams")
 	}
 	apiKeyMutationMu.Lock()
 	var key model.APIKey
-	closeTerminals := action == "disable" || action == "revoke"
+	closeTerminals := action == "disable" || action == "revoke" || action == "delete"
 	err := global.DB.Transaction(func(tx *gorm.DB) error {
-		if err := repo.APIKeyOwnerQuery(tx, owner.Type, owner.ID).Where("id = ?", req.ID).First(&key).Error; err != nil {
+		if err := repo.APIKeyOwnerQuery(tx, owner.Type, owner.ID).Where("id = ? AND deleted_at IS NULL", req.ID).First(&key).Error; err != nil {
 			if errors.Is(err, gorm.ErrRecordNotFound) {
 				return buserr.New("ErrAPIKeyNotFound")
 			}
 			return err
 		}
-		if key.Revision != req.Revision || key.Status == "Revoked" {
+		if key.Revision != req.Revision || (key.Status == "Revoked" && action != "delete") {
 			return buserr.New("ErrAPIKeyConflict")
 		}
 		before := key

core/cmd/server/docs/swagger.json

@@ -4542,6 +4542,9 @@
 						"schema": {
 							"type": "file"
 						}
+					},
+					"302": {
+						"description": "redirect to the official icon URL"
 					}
 				},
 				"security": [
@@ -5339,6 +5342,17 @@
 				"consumes": [
 					"application/json"
 				],
+				"parameters": [
+					{
+						"description": "request",
+						"in": "body",
+						"name": "request",
+						"required": true,
+						"schema": {
+							"$ref": "#/definitions/request.AppUpdateVersion"
+						}
+					}
+				],
 				"responses": {
 					"200": {
 						"description": "OK",
@@ -47477,6 +47491,23 @@
 			],
 			"type": "object"
 		},
+		"request.AppUpdateVersion": {
+			"properties": {
+				"appInstallID": {
+					"type": "integer"
+				},
+				"loadCompose": {
+					"type": "boolean"
+				},
+				"updateVersion": {
+					"type": "string"
+				}
+			},
+			"required": [
+				"appInstallID"
+			],
+			"type": "object"
+		},
 		"response.AppConfig": {
 			"properties": {
 				"advanced": {
@@ -47503,6 +47534,9 @@
 				"hostMode": {
 					"type": "boolean"
 				},
+				"isEdit": {
+					"type": "boolean"
+				},
 				"memoryLimit": {
 					"type": "number"
 				},
@@ -47763,6 +47797,9 @@
 				"gpuSupport": {
 					"type": "boolean"
 				},
+				"icon": {
+					"type": "string"
+				},
 				"id": {
 					"type": "integer"
 				},

core/cmd/server/main.go

@@ -18,7 +18,10 @@ import (
 // @schemes http https
 
 // @securityDefinitions.apikey ApiKeyAuth
-// @description Custom Token Format, Format: md5('1panel' + API-Key + UnixTimestamp).
+// @description Signed API Key authentication. Send the signature, never the plaintext API Key, in 1Panel-Token.
+// @description Supported formats: hex(HMAC-SHA256(API-Key, '1panel:' + UnixTimestamp)) or md5('1panel' + API-Key + UnixTimestamp).
+// @description Send the matching Unix timestamp in 1Panel-Timestamp. Optionally set 1Panel-Signature-Version to hmac-sha256, v1 or md5; omission accepts either algorithm.
+// @description Independent keys may include their ID in 1Panel-Key-ID to select the credential; omit that header for a legacy key.
 // @description ```
 // @description eg:
 // @description curl -X GET "http://{host}:{port}/api/v2/toolbox/device/base" \
@@ -27,7 +30,7 @@ import (
 // @description ```
 // @description - `1Panel-Token` is the key for the panel API Key.
 // @type apiKey
-// @in Header
+// @in header
 // @name 1Panel-Token
 // @securityDefinitions.apikey Timestamp
 // @type apiKey

core/init/migration/migrate.go

@@ -72,5 +72,6 @@ func coreMigrations() []*gormigrate.Migration {
 		migrations.UpdateAiMenuOrder,
 		migrations.UpdateAiMenuOrderV2,
 		migrations.AddPanelMCP,
+		migrations.AddAPIKeyDeletedAt,
 	}
 }

core/init/migration/migrations/api_key.go

@@ -15,3 +15,8 @@ var AddOperationLogAPIKey = &gormigrate.Migration{
 	ID:      "20260915-add-operation-log-api-key",
 	Migrate: func(tx *gorm.DB) error { return tx.AutoMigrate(&model.OperationLog{}) },
 }
+
+var AddAPIKeyDeletedAt = &gormigrate.Migration{
+	ID:      "20261028-api-key-deleted-at",
+	Migrate: func(tx *gorm.DB) error { return tx.AutoMigrate(&model.APIKey{}) },
+}

core/init/proxy/app_icon_test.go

@@ -0,0 +1,34 @@
+package proxy
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+type iconRedirectTransport func(*http.Request) (*http.Response, error)
+
+func (f iconRedirectTransport) RoundTrip(req *http.Request) (*http.Response, error) { return f(req) }
+
+func TestLocalAppIconRedirectIsPassedToBrowser(t *testing.T) {
+	const icon = "https://cdn.example/icon.png?signature=a%2Bb&v=42"
+	calls := 0
+	proxy := newLocalAgentProxy(iconRedirectTransport(func(req *http.Request) (*http.Response, error) {
+		calls++
+		if req.URL.Host != "unix" || req.URL.Path != "/api/v2/apps/icon/php" {
+			t.Fatalf("proxy attempted to fetch a remote image: %s", req.URL)
+		}
+		return &http.Response{
+			StatusCode: http.StatusFound,
+			Header:     http.Header{"Location": {icon}, "Cache-Control": {"no-cache"}},
+			Body:       io.NopCloser(strings.NewReader("")),
+		}, nil
+	}))
+	rw := httptest.NewRecorder()
+	proxy.ServeHTTP(rw, httptest.NewRequest(http.MethodGet, "/api/v2/apps/icon/php", nil))
+	if rw.Code != http.StatusFound || rw.Header().Get("Location") != icon || rw.Header().Get("Cache-Control") != "no-cache" || calls != 1 {
+		t.Fatalf("local proxy did not preserve the redirect: status=%d headers=%v calls=%d", rw.Code, rw.Header(), calls)
+	}
+}

core/middleware/operation.go

@@ -42,6 +42,10 @@ func OperationLog() gin.HandlerFunc {
 			return
 		}
 		switch c.Request.URL.Path {
+		case "/api/v2/core/auth/api/keys/reveal":
+			// Disclosure has its own audit and must not enter response-body capture.
+			c.Next()
+			return
 		case "/api/v2/core/mcp/credentials/create", "/api/v2/core/mcp/credentials/reveal", "/api/v2/core/mcp/credentials/rotate", "/api/v2/core/mcp/credentials/export":
 			c.Next()
 			return

core/router/ro_base.go

@@ -40,6 +40,8 @@ func (s *BaseRouter) InitRouter(Router *gin.RouterGroup) {
 		authRouter.POST("/api/keys/update", baseApi.UpdateAPIKey)
 		authRouter.POST("/api/keys/status", baseApi.SetAPIKeyStatus)
 		authRouter.POST("/api/keys/revoke", baseApi.RevokeAPIKey)
+		authRouter.POST("/api/keys/delete", baseApi.DeleteAPIKey)
+		authRouter.POST("/api/keys/reveal", baseApi.RevealAPIKey)
 
 		authRouter.GET("/current", baseApi.GetCurrentUser)
 		authRouter.POST("/current/update", baseApi.UpdateCurrentUser)

core/utils/apikey_audit/audit.go

@@ -45,6 +45,8 @@ func Build(c *gin.Context, event Event) (*model.OperationLog, error) {
 		"enable":      {"启用 API Key", "Enable API key"},
 		"disable":     {"停用 API Key", "Disable API key"},
 		"revoke":      {"撤销 API Key", "Revoke API key"},
+		"delete":      {"删除 API Key", "Delete API key"},
+		"reveal":      {"查看 API Key", "Reveal API key"},
 		"app_binding": {"向 APP 交付 API Key", "Deliver API key to APP"},
 	}
 	label, ok := labels[event.Action]
@@ -80,6 +82,17 @@ func Build(c *gin.Context, event Event) (*model.OperationLog, error) {
 			record.UserAgent = c.Request.UserAgent()
 			record.IP = c.ClientIP()
 		}
+		if c.GetBool("API_AUTH") && event.Action != "app_binding" {
+			record.AuthMethod = "api_key"
+			record.APIKeyID = c.GetString("API_AUTH_KEY_ID")
+			record.APIKeyName = c.GetString("API_AUTH_KEY_NAME")
+			if c.GetString("API_AUTH_KEY_KIND") == "legacy" {
+				record.APIKeyID = "legacy:" + c.GetString("API_AUTH_OWNER_TYPE") + ":" + c.GetString("API_AUTH_OWNER_ID")
+			}
+			if clientIP := c.GetString("API_AUTH_CLIENT_IP"); clientIP != "" {
+				record.IP = clientIP
+			}
+		}
 	}
 	if event.ClientIP != "" {
 		record.IP = event.ClientIP

frontend/src/api/interface/api-key.ts

@@ -30,4 +30,7 @@ export namespace APIKey {
         id: string;
         revision: number;
     }
+    export interface Revealed extends Reference {
+        apiKey: string;
+    }
 }

frontend/src/api/interface/app.ts

@@ -53,6 +53,7 @@ export namespace App {
 
     export interface AppItem {
         name: string;
+        icon?: string;
         key: string;
         id: number;
         description: string;
@@ -291,6 +292,7 @@ export namespace App {
         feishuConfigured?: boolean;
         version: string;
         detailId: number;
+        dockerCompose?: string;
     }
 
     export interface InstallParams {
@@ -318,6 +320,7 @@ export namespace App {
         modelAccountBaseURL: string;
         params: InstallParams[];
         rawCompose?: string;
+        isEdit?: boolean;
         cpuQuota: number;
         memoryLimit: number;
         memoryUnit: string;
@@ -341,6 +344,7 @@ export namespace App {
     export interface AppUpdateVersionReq {
         appInstallID: number;
         updateVersion?: string;
+        loadCompose?: boolean;
     }
 
     export interface AppIgnoreReq {

frontend/src/api/interface/container.ts

@@ -136,9 +136,6 @@ export namespace Container {
         mode: string;
     }
     export interface ContainerInfo {
-        latestVersion?: string;
-        targetImage?: string;
-        hasUpdate?: boolean;
         containerID: string;
         name: string;
         imageName: string;

frontend/src/api/modules/api-key.ts

@@ -6,7 +6,7 @@ const prefix = '/core/auth/api/keys';
 export const searchAPIKeys = (params: { page: number; pageSize: number; excludeRevoked?: boolean }) => {
     return http.post<APIKey.Search>(`${prefix}/search`, params);
 };
-export const createAPIKey = (params: APIKey.Editable & { requestID: string }) => {
+export const createAPIKey = (params: APIKey.Editable & { requestID?: string }) => {
     return http.post<APIKey.Created>(`${prefix}/create`, params);
 };
 export const updateAPIKey = (params: APIKey.Editable & APIKey.Reference) => {
@@ -18,3 +18,9 @@ export const setAPIKeyStatus = (params: APIKey.Reference & { status: 'Enable' |
 export const revokeAPIKey = (params: APIKey.Reference) => {
     return http.post<{ terminalClosePending: boolean }>(`${prefix}/revoke`, params);
 };
+export const deleteAPIKey = (params: APIKey.Reference) => {
+    return http.post<{ terminalClosePending: boolean }>(`${prefix}/delete`, params);
+};
+export const revealAPIKey = (params: APIKey.Reference) => {
+    return http.post<APIKey.Revealed>(`${prefix}/reveal`, params);
+};

frontend/src/api/modules/app.ts

@@ -2,6 +2,7 @@ import http from '@/api';
 import { ResPage } from '../interface';
 import { App } from '../interface/app';
 import { TimeoutEnum } from '@/enums/http-enum';
+import { resolveAppIconUrl } from '@/utils/app-icon';
 
 export const syncApp = (req: App.AppStoreSync) => {
     return http.post('apps/sync/remote', req);
@@ -99,8 +100,9 @@ export const getAppDefaultConfig = (key: string, name: string) => {
     return http.post<string>(`apps/installed/conf`, { type: key, name: name });
 };
 
-export const getAppInstallParams = (id: number) => {
+export const getAppInstallParams = (id: number, node?: string) => {
-    return http.get<App.AppConfig>(`apps/installed/params/${id}`);
+    const params = node ? `?operateNode=${encodeURIComponent(node)}` : '';
+    return http.get<App.AppConfig>(`apps/installed/params/${id}${params}`);
 };
 
 export const updateAppInstallParams = (req: any) => {
@@ -135,10 +137,9 @@ export const getCurrentNodeCustomAppConfig = () => {
     return http.get<App.CustomAppStoreConfig>(`/custom/app/config`);
 };
 
-export function getAppIconUrl(appKey: string, node?: string): string {
+export function getAppIconUrl(appKey: string, node?: string, icon = ''): string {
     const baseURL = import.meta.env.VITE_API_URL as string;
-    const params = node ? `?operateNode=${node}` : '';
+    return resolveAppIconUrl(appKey, node, icon, baseURL);
-    return `${baseURL}/apps/icon/${appKey}${params}`;
 }
 
 export const installAppToNodes = (param: App.InstallAppToNodes) => {

frontend/src/api/modules/container.ts

@@ -290,43 +290,3 @@ export const updateIpv6Option = (fixedCidrV6: string, ip6Tables: boolean, experi
 export const updateDaemonJsonByfile = (params: Container.DaemonJsonUpdateByFile) => {
     return http.post(`/containers/daemonjson/update/byfile`, params, TimeoutEnum.T_3M);
 };
-
-export interface ImageRemoteCheckStatus {
-    proxyRequired: boolean;
-}
-export const getImageRemoteCheckStatus = (node: string, signal?: AbortSignal) =>
-    http.get<ImageRemoteCheckStatus>(
-        '/containers/image/remote/check',
-        {},
-        { headers: { CurrentNode: node }, signal },
-    );
-
-export interface ContainerImageCheckUpdateStatus {
-    taskID: string;
-    enabled: boolean;
-    running: boolean;
-    checked: number;
-    updates: number;
-    failed: number;
-    skipped: number;
-    error: string;
-    finishedAt: number;
-}
-export const getContainerImageCheckUpdateStatus = (node: string, signal?: AbortSignal) =>
-    http.get<ContainerImageCheckUpdateStatus>(
-        '/containers/image-updates',
-        {},
-        { headers: { CurrentNode: node }, signal },
-    );
-export const runContainerImageCheckUpdate = (node: string) =>
-    http.postWithConfig<ContainerImageCheckUpdateStatus>(
-        '/containers/image-updates/check',
-        {},
-        { headers: { CurrentNode: node } },
-    );
-export const setContainerImageCheckUpdateSchedule = (enabled: boolean, node: string) =>
-    http.postWithConfig<ContainerImageCheckUpdateStatus>(
-        '/containers/image-updates/schedule',
-        { enabled },
-        { headers: { CurrentNode: node } },
-    );

frontend/src/components/api-key-management/editor.vue

@@ -6,27 +6,14 @@
         :confirm-before-close="true"
         @before-close="beforeClose"
     >
-        <template v-if="created">
+        <el-form
-            <el-alert
+            ref="formRef"
-                :title="$t(secret ? 'apiKeyManagement.saveSecret' : 'apiKeyManagement.alreadyCreated')"
+            :model="form"
-                :type="secret ? 'warning' : 'info'"
+            :rules="rules"
-                :closable="false"
+            label-position="top"
-                show-icon
+            class="text-[var(--el-text-color-regular)]"
-                class="mb-4"
+            @submit.prevent="submit"
-            />
+        >
-            <el-form label-position="top">
-                <el-form-item :label="$t('commons.table.name')">{{ created.name }}</el-form-item>
-                <el-form-item v-if="secret" :label="$t('setting.apiKey')">
-                    <el-input :model-value="secret" readonly autocomplete="off">
-                        <template #append>
-                            <CopyButton :content="secret" :is-icon="false" />
-                        </template>
-                    </el-input>
-                </el-form-item>
-            </el-form>
-            <el-checkbox v-if="secret" v-model="saved">{{ $t('apiKeyManagement.saved') }}</el-checkbox>
-        </template>
-        <el-form v-else ref="formRef" :model="form" :rules="rules" label-position="top" @submit.prevent="submit">
             <el-alert v-if="!item" type="warning" :closable="false" class="!mb-4">
                 <ul class="m-0 list-disc space-y-1 pl-4 break-words leading-6">
                     <li>
@@ -139,13 +126,10 @@
             </el-form-item>
         </el-form>
         <template #footer>
-            <el-button v-if="!created" :disabled="busy" @click="beforeClose(() => (visible = false))">
+            <el-button :disabled="busy" @click="beforeClose(() => (visible = false))">
                 {{ $t('commons.button.cancel') }}
             </el-button>
-            <el-button v-if="created" type="primary" :disabled="!!secret && !saved" @click="finish">
+            <el-button type="primary" :loading="busy" @click="submit">
-                {{ $t('commons.button.confirm') }}
-            </el-button>
-            <el-button v-else type="primary" :loading="busy" @click="submit">
                 {{ $t(item ? 'commons.button.save' : 'apiKeyManagement.create') }}
             </el-button>
         </template>
@@ -154,7 +138,7 @@
 
 <script setup lang="ts">
 import { computed, nextTick, onBeforeUnmount, reactive, ref, watch } from 'vue';
-import { ElMessageBox, type FormInstance } from 'element-plus';
+import type { FormInstance } from 'element-plus';
 import { isAxiosError } from 'axios';
 import { v4 as uuidv4 } from 'uuid';
 import { onBeforeRouteLeave } from 'vue-router';
@@ -174,9 +158,6 @@ const visible = ref(false);
 const busy = ref(false);
 const uncertain = ref(false);
 const item = ref<APIKey.Item>();
-const created = ref<APIKey.Item>();
-const secret = ref('');
-const saved = ref(false);
 const formRef = ref<FormInstance>();
 const ipMode = ref('restricted');
 const neverExpires = ref(false);
@@ -196,8 +177,6 @@ let editorVersion = 0;
 
 const discardEditor = () => {
     editorVersion++;
-    secret.value = '';
-    created.value = undefined;
     visible.value = false;
     busy.value = false;
 };
@@ -240,9 +219,6 @@ const rules = {
 const open = (existing?: APIKey.Item, fromApp = false) => {
     editorVersion++;
     item.value = existing;
-    created.value = undefined;
-    secret.value = '';
-    saved.value = false;
     uncertain.value = false;
     pendingCreate = undefined;
     requestID = uuidv4();
@@ -269,19 +245,9 @@ const open = (existing?: APIKey.Item, fromApp = false) => {
     nextTick(() => formRef.value?.clearValidate());
 };
 
-const finish = () => {
+const beforeClose = (done: () => void) => {
-    secret.value = '';
-    visible.value = false;
-    if (created.value) emit('created', created.value);
-};
-const beforeClose = async (done: () => void) => {
     if (busy.value) return;
-    if (secret.value && !saved.value) {
+    if (uncertain.value) emit('changed');
-        await ElMessageBox.alert(i18n.global.t('apiKeyManagement.saveSecret'), i18n.global.t('apiKeyManagement.title'));
-        return;
-    }
-    if (created.value) finish();
-    else if (uncertain.value) emit('changed');
     done();
 };
 
@@ -310,9 +276,13 @@ const submit = async () => {
             pendingCreate ??= { ...payload, requestID };
             const response = await createAPIKey(pendingCreate);
             if (ticket !== editorVersion) return;
-            created.value = response.data.item;
-            secret.value = response.data.apiKey;
             uncertain.value = false;
+            pendingCreate = undefined;
+            MsgSuccess(i18n.global.t('commons.msg.createSuccess'));
+            visible.value = false;
+            emit('changed');
+            emit('created', response.data.item);
+            return;
         }
         emit('changed');
     } catch (error) {
@@ -341,16 +311,12 @@ watch(
     { flush: 'sync' },
 );
 onBeforeUnmount(discardEditor);
-onBeforeRouteLeave(async (to) => {
+onBeforeRouteLeave((to) => {
     if (!globalStore.isLogin || ['entrance', 'Expired', 'EnterpriseLicenseRequired'].includes(String(to.name))) {
         discardEditor();
         return true;
     }
     if (busy.value) return false;
-    if (secret.value && !saved.value) {
-        await ElMessageBox.alert(i18n.global.t('apiKeyManagement.saveSecret'), i18n.global.t('apiKeyManagement.title'));
-        return false;
-    }
     discardEditor();
     return true;
 });

frontend/src/components/table/TableOperationActions.vue

@@ -13,16 +13,14 @@
                 @click.stop="handleButtonClick(button)"
             >
                 <el-icon v-if="button.icon" class="mr-1"><component :is="button.icon" /></el-icon>
-                <el-badge is-dot :hidden="!hasDot(button)">
+                <span>{{ button.label }}</span>
-                    <span>{{ button.label }}</span>
-                </el-badge>
             </el-button>
         </span>
         <span v-if="actions.more.length" class="fu-table-operations__action">
             <el-dropdown class="fu-table-more-button" :trigger="trigger" @command="handleButtonClick">
                 <span class="fu-table-operations__dropdown-trigger">
                     <el-button class="fu-table-operations__button" link type="primary">
-                        <el-badge is-dot :hidden="!actions.more.some(hasDot)">{{ t('fu.table.more') }}</el-badge>
+                        {{ t('fu.table.more') }}
                     </el-button>
                 </span>
                 <template #dropdown>
@@ -35,9 +33,7 @@
                             :divided="button.divided"
                         >
                             <el-icon v-if="button.icon" class="mr-1"><component :is="button.icon" /></el-icon>
-                            <el-badge is-dot :hidden="!hasDot(button)">
+                            <span>{{ button.label }}</span>
-                                <span>{{ button.label }}</span>
-                            </el-badge>
                         </el-dropdown-item>
                     </el-dropdown-menu>
                 </template>
@@ -79,9 +75,6 @@ const actions = computed(() => {
     };
 });
 
-const hasDot = (button: FuTableOperationButton) =>
-    typeof button.dot === 'function' ? button.dot(props.row) : Boolean(button.dot);
-
 const handleButtonClick = (button: FuTableOperationButton) => {
     if (!isOperationDisabled(button, props.row)) {
         button.click?.(props.row);

frontend/src/components/table/shared.ts

@@ -23,7 +23,6 @@ export interface FuTableOperationButton<Row = any> {
     type?: string;
     icon?: any;
     divided?: boolean;
-    dot?: boolean | ((row: Row) => boolean);
 }
 
 export const FU_TABLE_STORAGE_PREFIX = 'FU-T-';

frontend/src/lang/modules/en.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'Show secret',
+        hideSecret: 'Hide secret',
+        revealHelp: 'Keep this secret secure. Disabled or expired keys remain unusable even when displayed.',
+        deleteConfirm:
+            'Delete “{0}”? Its secret will be destroyed and the key removed from the list. New requests will be rejected and terminal connections closed. Audit records are retained; running jobs are not cancelled. This cannot be undone.',
         title: 'API Key',
         manage: 'Manage API Keys',
         personalEntry: 'Manage your keys, access conditions, and APP binding in Settings.',
@@ -23,10 +28,6 @@ const message = {
         allowAppBinding: 'Allow APP QR binding',
         bindingDisableHelp:
             'Disabling QR binding prevents new device bindings. Devices already bound can continue to use the key until it is disabled, revoked, or expires.',
-        saveSecret: 'Copy and save this secret now. After closing, ordinary key management cannot display it again.',
-        saved: 'I have saved the secret',
-        alreadyCreated:
-            'This key was already created. Its secret will not be shown again. If the original response was lost, revoke and recreate it, or use QR binding if allowed.',
         uncertain:
             'The request result is uncertain. Retry with the same details to avoid duplicate keys, or close and check the list before creating another.',
         legacyHelp:
@@ -2116,19 +2117,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'To check for image updates in the current runtime environment, please configure a proxy server first.',
-        imageCheckUpdateConfigureProxy: 'Configure',
-        imageCheckUpdateAvailableVersion: 'Available version “{version}”',
-        imageCheckUpdateContentChanged: '(image content changed)',
-        imageCheckUpdates: 'Check for image updates',
-        imageCheckUpdateNow: 'Check now',
-        imageCheckUpdateSchedule: 'Scheduled checks',
-        imageCheckUpdateDisable: 'Disable scheduled checks',
-        imageCheckUpdateStarted: 'Checking images used by all containers on this node',
-        imageCheckUpdateResult:
-            'Check complete: {checked} checked, {updates} upgradable, {failed} failed, {skipped} skipped',
-
         createByCommand: 'Create by command',
         importContainerBackupTip: 'Import container backup file, only .tar.gz is supported',
         importComposeBackupTip: 'Import compose backup file, only .tar.gz is supported',

frontend/src/lang/modules/es-es.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'Mostrar secreto',
+        hideSecret: 'Ocultar secreto',
+        revealHelp: 'Guarde el secreto de forma segura. Mostrarlo no reactiva claves deshabilitadas o caducadas.',
+        deleteConfirm:
+            '¿Eliminar «{0}»? Se destruirá el secreto y se quitará la clave de la lista. Se rechazarán nuevas solicitudes y se cerrarán sus terminales. Se conservará la auditoría; las tareas en ejecución no se cancelarán. Esta acción es irreversible.',
         title: 'API Key',
         manage: 'Gestionar claves API',
         personalEntry: 'Gestiona tus claves, condiciones de acceso y vinculación de la APP en Ajustes.',
@@ -23,10 +28,6 @@ const message = {
         allowAppBinding: 'Permitir vinculación de APP por QR',
         bindingDisableHelp:
             'Desactivar la vinculación por QR impide nuevas vinculaciones. Los dispositivos ya vinculados pueden seguir usando la clave hasta que se desactive, se revoque o caduque.',
-        saveSecret: 'Copia y guarda la clave ahora. Tras cerrar, la gestión normal no podrá mostrarla de nuevo.',
-        saved: 'He guardado la clave',
-        alreadyCreated:
-            'La clave ya se creó y no se mostrará de nuevo. Si se perdió la respuesta original, revócala y crea otra, o usa QR si está permitido.',
         uncertain:
             'El resultado es incierto. Reintenta con los mismos datos para evitar duplicados, o cierra y revisa la lista antes de crear otra.',
         legacyHelp:
@@ -2135,19 +2136,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'Para comprobar actualizaciones de imágenes en el entorno actual, configura primero un servidor proxy.',
-        imageCheckUpdateConfigureProxy: 'Configurar',
-        imageCheckUpdateAvailableVersion: 'Versión disponible «{version}»',
-        imageCheckUpdateContentChanged: '(el contenido de la imagen ha cambiado)',
-        imageCheckUpdates: 'Buscar actualizaciones de imágenes',
-        imageCheckUpdateNow: 'Comprobar ahora',
-        imageCheckUpdateSchedule: 'Comprobación programada',
-        imageCheckUpdateDisable: 'Desactivar comprobación programada',
-        imageCheckUpdateStarted: 'Buscando actualizaciones de las imágenes de todos los contenedores de este nodo',
-        imageCheckUpdateResult:
-            'Comprobación finalizada: comprobados {checked}, actualizables {updates}, fallidos {failed}, omitidos {skipped}',
-
         createByCommand: 'Crear por comando',
         importContainerBackupTip: 'Importar archivo de copia de seguridad de contenedor, solo se admite .tar.gz',
         importComposeBackupTip: 'Importar archivo de copia de seguridad de compose, solo se admite .tar.gz',

frontend/src/lang/modules/fa.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'نمایش کلید محرمانه',
+        hideSecret: 'پنهان کردن کلید محرمانه',
+        revealHelp: 'کلید را در جای امن نگه دارید. نمایش آن، کلید غیرفعال یا منقضی‌شده را قابل استفاده نمی‌کند.',
+        deleteConfirm:
+            '«{0}» حذف شود؟ کلید محرمانه نابود و از فهرست حذف می‌شود. درخواست‌های جدید رد و اتصال‌های ترمینال مرتبط بسته می‌شوند. سوابق حسابرسی حفظ و کارهای در حال اجرا لغو نمی‌شوند. این عملیات برگشت‌پذیر نیست.',
         title: 'API Key',
         manage: 'مدیریت کلیدهای API',
         personalEntry: 'کلیدها، شرایط دسترسی و اتصال برنامه را در تنظیمات مدیریت کنید.',
@@ -23,10 +28,6 @@ const message = {
         allowAppBinding: 'اجازه اتصال برنامه با QR',
         bindingDisableHelp:
             'با غیرفعال کردن اتصال از طریق QR، اتصال دستگاه‌های جدید متوقف می‌شود. دستگاه‌های متصل می‌توانند تا زمان غیرفعال‌سازی، لغو یا انقضای کلید به استفاده از آن ادامه دهند.',
-        saveSecret: 'اکنون کلید را کپی و ذخیره کنید. پس از بستن، مدیریت عادی نمی‌تواند کلید کامل را دوباره نشان دهد.',
-        saved: 'کلید را ذخیره کردم',
-        alreadyCreated:
-            'این کلید قبلاً ایجاد شده و دوباره نمایش داده نمی‌شود. اگر پاسخ اصلی گم شده است، کلید را لغو و دوباره ایجاد کنید یا در صورت اجازه از QR استفاده کنید.',
         uncertain:
             'نتیجه درخواست نامشخص است. برای جلوگیری از تکرار، با همان اطلاعات دوباره تلاش کنید یا ببندید و پیش از ایجاد کلید دیگر فهرست را بررسی کنید.',
         legacyHelp:
@@ -2093,19 +2094,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'برای بررسی به‌روزرسانی تصاویر در محیط فعلی، ابتدا یک سرور پروکسی پیکربندی کنید.',
-        imageCheckUpdateConfigureProxy: 'پیکربندی',
-        imageCheckUpdateAvailableVersion: 'نسخه قابل ارتقا «{version}»',
-        imageCheckUpdateContentChanged: '(محتوای تصویر تغییر کرده است)',
-        imageCheckUpdates: 'بررسی به‌روزرسانی ایمیج‌ها',
-        imageCheckUpdateNow: 'بررسی اکنون',
-        imageCheckUpdateSchedule: 'بررسی زمان‌بندی‌شده',
-        imageCheckUpdateDisable: 'غیرفعال‌کردن بررسی زمان‌بندی‌شده',
-        imageCheckUpdateStarted: 'در حال بررسی به‌روزرسانی ایمیج‌های همه کانتینرهای این گره',
-        imageCheckUpdateResult:
-            'بررسی پایان یافت: بررسی‌شده {checked}، قابل ارتقا {updates}، ناموفق {failed}، ردشده {skipped}',
-
         createByCommand: 'ایجاد با دستور',
         importContainerBackupTip: 'واردات فایل پشتیبان کانتینر، فقط .tar.gz پشتیبانی می‌شود',
         importComposeBackupTip: 'واردات فایل پشتیبان compose، فقط .tar.gz پشتیبانی می‌شود',

frontend/src/lang/modules/ja.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'シークレットを表示',
+        hideSecret: 'シークレットを隠す',
+        revealHelp: 'シークレットを安全に保管してください。表示しても無効または期限切れのキーは使用できません。',
+        deleteConfirm:
+            '「{0}」を削除しますか？シークレットは破棄され、キーは一覧から削除されます。新しいリクエストは拒否され、関連ターミナルは切断されます。監査記録は保持され、実行中のタスクは中止されません。この操作は元に戻せません。',
         title: 'API Key',
         manage: 'API Key を管理',
         personalEntry: '設定で自分のキー、アクセス条件、APP の QR 連携を管理します。',
@@ -23,10 +28,6 @@ const message = {
         allowAppBinding: 'APP の QR 連携を許可',
         bindingDisableHelp:
             'QR 連携を無効にすると、新規の連携を受け付けなくなります。連携済みの端末は、キーが無効化、失効、または期限切れになるまで引き続き利用できます。',
-        saveSecret: '今すぐキーをコピーして保存してください。閉じると通常のキー管理から完全なキーを再表示できません。',
-        saved: 'キーを保存しました',
-        alreadyCreated:
-            'このキーは作成済みで、再表示できません。最初の応答を受け取れなかった場合は失効させて再作成するか、許可されていれば QR を使用してください。',
         uncertain: 'リクエスト結果が不明です。重複を避けるため同じ設定で再試行するか、閉じて一覧を確認してください。',
         legacyHelp:
             '旧版キーは従来の API 接続との互換性を維持します。有効化、無効化、リセットはこのキーにのみ適用されます。',
@@ -2100,18 +2101,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            '現在の実行環境でイメージの更新を確認するには、先にプロキシサーバーを設定してください。',
-        imageCheckUpdateConfigureProxy: '設定へ',
-        imageCheckUpdateAvailableVersion: '更新可能なバージョン「{version}」',
-        imageCheckUpdateContentChanged: '（イメージの内容が変更されています）',
-        imageCheckUpdates: 'イメージの更新を確認',
-        imageCheckUpdateNow: '今すぐ確認',
-        imageCheckUpdateSchedule: '定期チェック',
-        imageCheckUpdateDisable: '定期チェックを無効にする',
-        imageCheckUpdateStarted: 'このノードのすべてのコンテナで使用されているイメージの更新を確認しています',
-        imageCheckUpdateResult: '確認完了：成功 {checked}、更新可能 {updates}、失敗 {failed}、スキップ {skipped}',
-
         createByCommand: 'コマンドで作成',
         importContainerBackupTip: 'コンテナバックアップファイルをインポートします。.tar.gz のみ対応です',
         importComposeBackupTip: 'Compose バックアップファイルをインポートします。.tar.gz のみ対応です',

frontend/src/lang/modules/ko.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: '비밀 키 표시',
+        hideSecret: '비밀 키 숨기기',
+        revealHelp: '비밀 키를 안전하게 보관하세요. 표시해도 비활성화되거나 만료된 키는 사용할 수 없습니다.',
+        deleteConfirm:
+            '“{0}”을(를) 삭제하시겠습니까? 비밀 키가 파기되고 목록에서 제거됩니다. 새 요청은 거부되고 연결된 터미널은 종료됩니다. 감사 기록은 유지되며 실행 중인 작업은 취소되지 않습니다. 이 작업은 되돌릴 수 없습니다.',
         title: 'API Key',
         manage: 'API Key 관리',
         personalEntry: '설정에서 내 키, 접근 조건 및 APP QR 연결을 관리합니다.',
@@ -23,10 +28,6 @@ const message = {
         allowAppBinding: 'APP QR 연결 허용',
         bindingDisableHelp:
             'QR 연결을 비활성화하면 새로운 기기를 연결할 수 없습니다. 이미 연결된 기기는 키가 비활성화, 폐기 또는 만료될 때까지 계속 사용할 수 있습니다.',
-        saveSecret: '지금 키를 복사하여 저장하세요. 닫으면 일반 키 관리에서 전체 키를 다시 표시할 수 없습니다.',
-        saved: '키를 저장했습니다',
-        alreadyCreated:
-            '이 키는 이미 생성되어 다시 표시할 수 없습니다. 원래 응답을 잃었다면 폐기 후 다시 만들거나 허용된 QR 연결을 사용하세요.',
         uncertain:
             '요청 결과를 확인할 수 없습니다. 중복 생성을 피하려면 같은 설정으로 재시도하거나 닫고 목록을 확인하세요.',
         legacyHelp:
@@ -2075,17 +2076,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired: '현재 실행 환경에서 이미지 업데이트를 확인하려면 먼저 프록시 서버를 설정하세요.',
-        imageCheckUpdateConfigureProxy: '설정하기',
-        imageCheckUpdateAvailableVersion: '업그레이드 가능한 버전 “{version}”',
-        imageCheckUpdateContentChanged: '(이미지 내용 변경)',
-        imageCheckUpdates: '이미지 업데이트 확인',
-        imageCheckUpdateNow: '지금 확인',
-        imageCheckUpdateSchedule: '정기 확인',
-        imageCheckUpdateDisable: '정기 확인 끄기',
-        imageCheckUpdateStarted: '현재 노드의 모든 컨테이너에서 사용하는 이미지의 업데이트를 확인하고 있습니다',
-        imageCheckUpdateResult: '확인 완료: 성공 {checked}, 업데이트 가능 {updates}, 실패 {failed}, 건너뜀 {skipped}',
-
         createByCommand: '명령으로 생성',
         importContainerBackupTip: '컨테이너 백업 파일 가져오기, .tar.gz 형식만 지원합니다',
         importComposeBackupTip: 'Compose 백업 파일 가져오기, .tar.gz 형식만 지원합니다',

frontend/src/lang/modules/lo.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'ສະແດງຄີລັບ',
+        hideSecret: 'ເຊື່ອງຄີລັບ',
+        revealHelp: 'ກະລຸນາເກັບຄີລັບໃຫ້ປອດໄພ. ການສະແດງບໍ່ເຮັດໃຫ້ຄີທີ່ປິດໃຊ້ງານ ຫຼືໝົດອາຍຸກັບມາໃຊ້ໄດ້.',
+        deleteConfirm:
+            'ລຶບ “{0}” ຫຼືບໍ່? ຄີລັບຈະຖືກທຳລາຍ ແລະລຶບອອກຈາກລາຍການ. ຄຳຮ້ອງຂໍໃໝ່ຈະຖືກປະຕິເສດ ແລະປິດເທີມິນັລທີ່ກ່ຽວຂ້ອງ. ບັນທຶກການກວດສອບຈະຍັງຄົງຢູ່; ວຽກທີ່ກຳລັງເຮັດຈະບໍ່ຖືກຍົກເລີກ. ບໍ່ສາມາດກູ້ຄືນໄດ້.',
         title: 'API Key',
         manage: 'ຈັດການ API Key',
         personalEntry: 'ຈັດການກະແຈ, ເງື່ອນໄຂເຂົ້າໃຊ້ ແລະ ການຜູກ APP ໃນການຕັ້ງຄ່າ.',
@@ -23,9 +28,6 @@ const message = {
         allowAppBinding: 'ອະນຸຍາດຜູກ APP ຜ່ານ QR',
         bindingDisableHelp:
             'ເມື່ອປິດການຜູກມັດຜ່ານ QR, ລະບົບຈະບໍ່ຮັບການຜູກມັດໃໝ່. ອຸປະກອນທີ່ຜູກມັດແລ້ວຍັງສາມາດໃຊ້ງານໄດ້ ຈົນກວ່າກະແຈຈະຖືກປິດໃຊ້, ຖອນ ຫຼື ໝົດອາຍຸ.',
-        saveSecret: 'ຄັດລອກ ແລະ ບັນທຶກກະແຈດຽວນີ້. ຫຼັງປິດແລ້ວ ການຈັດການປົກກະຕິຈະບໍ່ສະແດງກະແຈເຕັມອີກ.',
-        saved: 'ຂ້ອຍບັນທຶກກະແຈແລ້ວ',
-        alreadyCreated: 'ກະແຈນີ້ສ້າງແລ້ວ ແລະ ບໍ່ສະແດງອີກ. ຖ້າຄຳຕອບເກົ່າຫາຍ ໃຫ້ຖອນແລ້ວສ້າງໃໝ່ ຫຼື ໃຊ້ QR ຖ້າອະນຸຍາດ.',
         uncertain: 'ຍັງບໍ່ແນ່ໃຈຜົນຄຳຮ້ອງ. ລອງໃໝ່ດ້ວຍຂໍ້ມູນເດີມເພື່ອບໍ່ສ້າງຊ້ຳ ຫຼື ປິດແລ້ວກວດລາຍການກ່ອນສ້າງອີກ.',
         legacyHelp:
             'ກະແຈເກົ່າໃຊ້ເພື່ອຮອງຮັບການເຊື່ອມຕໍ່ API ເກົ່າ. ການເປີດໃຊ້, ປິດໃຊ້ ແລະ ຣີເຊັດ ມີຜົນສະເພາະກະແຈນີ້ເທົ່ານັ້ນ.',
@@ -2060,19 +2062,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'ເພື່ອກວດສອບການອັບເດດອິມເມຈໃນສະພາບແວດລ້ອມປັດຈຸບັນ ກະລຸນາຕັ້ງຄ່າພຣັອກຊີເຊີບເວີກ່ອນ.',
-        imageCheckUpdateConfigureProxy: 'ໄປຕັ້ງຄ່າ',
-        imageCheckUpdateAvailableVersion: 'ເວີຊັນທີ່ອັບເກຣດໄດ້ “{version}”',
-        imageCheckUpdateContentChanged: '(ເນື້ອຫາອິມເມຈປ່ຽນແປງ)',
-        imageCheckUpdates: 'ກວດສອບການອັບເດດອິມເມຈ',
-        imageCheckUpdateNow: 'ກວດສອບຕອນນີ້',
-        imageCheckUpdateSchedule: 'ກວດສອບຕາມຕາຕະລາງ',
-        imageCheckUpdateDisable: 'ປິດການກວດສອບຕາມຕາຕະລາງ',
-        imageCheckUpdateStarted: 'ກຳລັງກວດສອບການອັບເດດອິມເມຈຂອງທຸກຄອນເທນເນີໃນໂນດນີ້',
-        imageCheckUpdateResult:
-            'ກວດສອບສຳເລັດ: ກວດແລ້ວ {checked}, ອັບເກຣດໄດ້ {updates}, ລົ້ມເຫຼວ {failed}, ຂ້າມ {skipped}',
-
         createByCommand: 'ສ້າງດ້ວຍຄຳສັ່ງ',
         importContainerBackupTip: 'ນຳເຂົ້າໄຟລ໌ສຳຮອງຄອນເທນເນີ, ຮອງຮັບສະເພາະ .tar.gz',
         importComposeBackupTip: 'ນຳເຂົ້າໄຟລ໌ສຳຮອງ compose, ຮອງຮັບສະເພາະ .tar.gz',

frontend/src/lang/modules/ms.ts

@@ -2,6 +2,12 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'Papar rahsia',
+        hideSecret: 'Sembunyikan rahsia',
+        revealHelp:
+            'Simpan rahsia ini dengan selamat. Memaparkannya tidak mengaktifkan semula kunci yang dinyahdayakan atau tamat tempoh.',
+        deleteConfirm:
+            'Padam “{0}”? Rahsianya akan dimusnahkan dan kunci dibuang daripada senarai. Permintaan baharu akan ditolak dan terminal berkaitan ditutup. Rekod audit dikekalkan; tugas yang sedang berjalan tidak dibatalkan. Tindakan ini tidak boleh dibuat asal.',
         title: 'API Key',
         manage: 'Urus kunci API',
         personalEntry: 'Urus kunci, syarat akses dan pautan APP anda dalam Tetapan.',
@@ -23,11 +29,6 @@ const message = {
         allowAppBinding: 'Benarkan pautan APP melalui QR',
         bindingDisableHelp:
             'Menyahdayakan pautan QR menghalang pautan peranti baharu. Peranti yang telah dipautkan boleh terus digunakan sehingga kunci dinyahdayakan, dibatalkan atau tamat tempoh.',
-        saveSecret:
-            'Salin dan simpan kunci sekarang. Selepas ditutup, pengurusan biasa tidak dapat memaparkan kunci penuh lagi.',
-        saved: 'Saya telah menyimpan kunci',
-        alreadyCreated:
-            'Kunci ini telah dicipta dan tidak akan dipaparkan semula. Jika respons asal hilang, batalkan dan cipta semula atau gunakan QR jika dibenarkan.',
         uncertain:
             'Hasil permintaan belum pasti. Cuba semula dengan butiran sama untuk mengelakkan pendua, atau tutup dan semak senarai sebelum mencipta lagi.',
         legacyHelp:
@@ -2131,19 +2132,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'Untuk menyemak kemas kini imej dalam persekitaran semasa, sila konfigurasikan pelayan proksi terlebih dahulu.',
-        imageCheckUpdateConfigureProxy: 'Konfigurasi',
-        imageCheckUpdateAvailableVersion: 'Versi tersedia “{version}”',
-        imageCheckUpdateContentChanged: '(kandungan imej berubah)',
-        imageCheckUpdates: 'Semak kemas kini imej',
-        imageCheckUpdateNow: 'Semak sekarang',
-        imageCheckUpdateSchedule: 'Semakan berjadual',
-        imageCheckUpdateDisable: 'Matikan semakan berjadual',
-        imageCheckUpdateStarted: 'Menyemak kemas kini imej yang digunakan oleh semua kontena pada nod ini',
-        imageCheckUpdateResult:
-            'Semakan selesai: disemak {checked}, boleh dikemas kini {updates}, gagal {failed}, dilangkau {skipped}',
-
         createByCommand: 'Cipta melalui perintah',
         importContainerBackupTip: 'Import fail sandaran kontena, hanya format .tar.gz disokong',
         importComposeBackupTip: 'Import fail sandaran compose, hanya format .tar.gz disokong',

frontend/src/lang/modules/pt-br.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'Mostrar segredo',
+        hideSecret: 'Ocultar segredo',
+        revealHelp: 'Guarde o segredo com segurança. Exibi-lo não reativa chaves desabilitadas ou expiradas.',
+        deleteConfirm:
+            'Excluir “{0}”? O segredo será destruído e a chave removida da lista. Novas solicitações serão rejeitadas e os terminais associados serão fechados. Os registros de auditoria serão mantidos; tarefas em execução não serão canceladas. Esta ação é irreversível.',
         title: 'API Key',
         manage: 'Gerenciar chaves API',
         personalEntry: 'Gerencie suas chaves, condições de acesso e vínculo do APP nas Configurações.',
@@ -23,10 +28,6 @@ const message = {
         allowAppBinding: 'Permitir vínculo do APP por QR',
         bindingDisableHelp:
             'Desativar a vinculação por QR impede novas vinculações. Os dispositivos já vinculados podem continuar usando a chave até que ela seja desativada, revogada ou expire.',
-        saveSecret: 'Copie e salve a chave agora. Após fechar, o gerenciamento normal não poderá exibi-la novamente.',
-        saved: 'Salvei a chave',
-        alreadyCreated:
-            'Esta chave já foi criada e não será exibida novamente. Se a resposta original foi perdida, revogue e recrie a chave ou use o QR, se permitido.',
         uncertain:
             'O resultado é incerto. Tente novamente com os mesmos dados para evitar duplicações ou feche e verifique a lista antes de criar outra.',
         legacyHelp:
@@ -2134,19 +2135,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'Para verificar atualizações de imagens no ambiente atual, configure primeiro um servidor proxy.',
-        imageCheckUpdateConfigureProxy: 'Configurar',
-        imageCheckUpdateAvailableVersion: 'Versão disponível “{version}”',
-        imageCheckUpdateContentChanged: '(conteúdo da imagem alterado)',
-        imageCheckUpdates: 'Verificar atualizações de imagens',
-        imageCheckUpdateNow: 'Verificar agora',
-        imageCheckUpdateSchedule: 'Verificação agendada',
-        imageCheckUpdateDisable: 'Desativar verificação agendada',
-        imageCheckUpdateStarted: 'Verificando atualizações das imagens de todos os contêineres deste nó',
-        imageCheckUpdateResult:
-            'Verificação concluída: verificados {checked}, atualizáveis {updates}, falhas {failed}, ignorados {skipped}',
-
         createByCommand: 'Criar por comando',
         importContainerBackupTip: 'Importar arquivo de backup de contêiner, apenas .tar.gz é suportado',
         importComposeBackupTip: 'Importar arquivo de backup de compose, apenas .tar.gz é suportado',

frontend/src/lang/modules/ru.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'Показать секрет',
+        hideSecret: 'Скрыть секрет',
+        revealHelp: 'Храните секрет в безопасности. Просмотр не активирует отключённые или просроченные ключи.',
+        deleteConfirm:
+            'Удалить «{0}»? Секрет будет уничтожен, а ключ удалён из списка. Новые запросы будут отклонены, связанные терминалы закрыты. Журнал аудита сохранится; выполняющиеся задачи не отменяются. Действие необратимо.',
         title: 'API Key',
         manage: 'Управление API-ключами',
         personalEntry: 'Управляйте своими ключами, условиями доступа и привязкой приложения в настройках.',
@@ -23,11 +28,6 @@ const message = {
         allowAppBinding: 'Разрешить привязку приложения по QR',
         bindingDisableHelp:
             'Отключение привязки по QR-коду запрещает новые привязки. Уже привязанные устройства могут продолжать работу, пока ключ не будет отключён, отозван или не истечёт срок его действия.',
-        saveSecret:
-            'Скопируйте и сохраните ключ сейчас. После закрытия обычное управление не сможет показать полный ключ снова.',
-        saved: 'Ключ сохранён',
-        alreadyCreated:
-            'Ключ уже создан и не будет показан повторно. Если исходный ответ потерян, отзовите и создайте ключ заново либо используйте разрешённую привязку по QR.',
         uncertain:
             'Результат запроса неизвестен. Повторите с теми же данными, чтобы избежать дублей, или закройте и проверьте список.',
         legacyHelp:
@@ -2127,19 +2127,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'Для проверки обновлений образов в текущей среде сначала настройте прокси-сервер.',
-        imageCheckUpdateConfigureProxy: 'Настроить',
-        imageCheckUpdateAvailableVersion: 'Доступна версия «{version}»',
-        imageCheckUpdateContentChanged: '(содержимое образа изменилось)',
-        imageCheckUpdates: 'Проверить обновления образов',
-        imageCheckUpdateNow: 'Проверить сейчас',
-        imageCheckUpdateSchedule: 'Проверка по расписанию',
-        imageCheckUpdateDisable: 'Отключить проверку по расписанию',
-        imageCheckUpdateStarted: 'Проверка обновлений образов всех контейнеров на текущем узле',
-        imageCheckUpdateResult:
-            'Проверка завершена: проверено {checked}, доступны обновления {updates}, ошибок {failed}, пропущено {skipped}',
-
         createByCommand: 'Создать с помощью команды',
         importContainerBackupTip: 'Импорт файла резервной копии контейнера, поддерживается только .tar.gz',
         importComposeBackupTip: 'Импорт файла резервной копии compose, поддерживается только .tar.gz',

frontend/src/lang/modules/tr.ts

@@ -2,6 +2,12 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: 'Gizli anahtarı göster',
+        hideSecret: 'Gizli anahtarı gizle',
+        revealHelp:
+            'Gizli anahtarı güvenli tutun. Görüntülemek, devre dışı veya süresi dolmuş anahtarı kullanılabilir yapmaz.',
+        deleteConfirm:
+            '“{0}” silinsin mi? Gizli anahtar yok edilecek ve listeden kaldırılacaktır. Yeni istekler reddedilecek ve ilgili terminaller kapatılacaktır. Denetim kayıtları korunur; çalışan işler iptal edilmez. Bu işlem geri alınamaz.',
         title: 'API Key',
         manage: 'API anahtarlarını yönet',
         personalEntry: 'Ayarlar bölümünde anahtarlarınızı, erişim koşullarını ve uygulama QR bağlantısını yönetin.',
@@ -23,11 +29,6 @@ const message = {
         allowAppBinding: 'Uygulama QR bağlantısına izin ver',
         bindingDisableHelp:
             'QR eşleştirmesini devre dışı bırakmak yeni eşleştirmeleri engeller. Eşleştirilmiş cihazlar, anahtar devre dışı bırakılana, iptal edilene veya süresi dolana kadar kullanılmaya devam edebilir.',
-        saveSecret:
-            'Anahtarı şimdi kopyalayıp kaydedin. Kapattıktan sonra normal anahtar yönetimi tam anahtarı yeniden gösteremez.',
-        saved: 'Anahtarı kaydettim',
-        alreadyCreated:
-            'Bu anahtar zaten oluşturuldu ve yeniden gösterilmez. İlk yanıt kaybolduysa iptal edip yeniden oluşturun veya izin veriliyorsa QR bağlantısını kullanın.',
         uncertain:
             'İstek sonucu belirsiz. Tekrarları önlemek için aynı bilgilerle yeniden deneyin veya kapatıp yeni anahtar oluşturmadan listeyi kontrol edin.',
         legacyHelp:
@@ -2132,19 +2133,6 @@ const message = {
         batchUpgradeWaiting: 'Queued',
         batchUpgradeRunning: 'Upgrading',
         batchUpgradeSubmitted: 'Upgrade task submitted',
-        imageCheckUpdateProxyRequired:
-            'Geçerli çalışma ortamında imaj güncellemelerini kontrol etmek için önce bir proxy sunucusu yapılandırın.',
-        imageCheckUpdateConfigureProxy: 'Yapılandır',
-        imageCheckUpdateAvailableVersion: 'Yükseltilebilir sürüm “{version}”',
-        imageCheckUpdateContentChanged: '(imaj içeriği değişti)',
-        imageCheckUpdates: 'İmaj güncellemelerini denetle',
-        imageCheckUpdateNow: 'Şimdi denetle',
-        imageCheckUpdateSchedule: 'Zamanlanmış denetim',
-        imageCheckUpdateDisable: 'Zamanlanmış denetimi kapat',
-        imageCheckUpdateStarted: 'Bu düğümdeki tüm konteynerlerin imaj güncellemeleri denetleniyor',
-        imageCheckUpdateResult:
-            'Denetim tamamlandı: denetlenen {checked}, güncellenebilir {updates}, başarısız {failed}, atlanan {skipped}',
-
         createByCommand: 'Komutla oluştur',
         importContainerBackupTip: 'Konteyner yedek dosyasını içe aktar, yalnızca .tar.gz desteklenir',
         importComposeBackupTip: 'Compose yedek dosyasını içe aktar, yalnızca .tar.gz desteklenir',

frontend/src/lang/modules/zh-Hant.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: '檢視密鑰',
+        hideSecret: '隱藏密鑰',
+        revealHelp: '請妥善保管密鑰。檢視不會恢復已停用或已過期密鑰的使用權限。',
+        deleteConfirm:
+            '確定刪除「{0}」嗎？密鑰將被銷毀並從列表移除，拒絕後續請求並關閉關聯終端。稽核記錄仍保留，執行中的工作不會取消，此操作無法復原。',
         title: 'API Key',
         manage: '管理 API Key',
         personalEntry: '前往設定管理自己的金鑰、存取條件與 APP 掃碼綁定。',
@@ -22,10 +27,6 @@ const message = {
         futureExpiry: '請選擇晚於目前時間的到期時間。',
         allowAppBinding: '允許 APP 掃碼綁定',
         bindingDisableHelp: '關閉掃碼綁定後，將停止接受新的綁定；已綁定裝置可繼續使用，直至金鑰被停用、撤銷或到期。',
-        saveSecret: '請立即複製並儲存金鑰。關閉後，一般金鑰管理無法再次顯示完整金鑰。',
-        saved: '我已儲存金鑰',
-        alreadyCreated:
-            '這把金鑰已建立，無法再次顯示明文。若原回應遺失，請撤銷後重新建立；允許掃碼綁定時，也可透過掃碼交付。',
         uncertain: '請求結果尚不確定。請保持原設定重試，避免重複建立；或關閉並檢查清單後再建立其他金鑰。',
         legacyHelp: '舊版 Key 用於相容歷史 API 連線，啟用、停用及重設操作僅對該 Key 生效。',
         showLegacy: '檢視舊版金鑰',
@@ -1997,17 +1998,6 @@ const message = {
         batchUpgradeWaiting: '等待執行',
         batchUpgradeRunning: '正在升級',
         batchUpgradeSubmitted: '已提交升級任務',
-        imageCheckUpdateProxyRequired: '目前運行環境下，如需檢查映像是否更新，請先設定代理伺服器',
-        imageCheckUpdateConfigureProxy: '前往設定',
-        imageCheckUpdateAvailableVersion: '可升級版本「{version}」',
-        imageCheckUpdateContentChanged: '（映像內容變更）',
-        imageCheckUpdates: '檢查更新映像',
-        imageCheckUpdateNow: '立即檢查',
-        imageCheckUpdateSchedule: '定時檢查',
-        imageCheckUpdateDisable: '關閉定時檢查',
-        imageCheckUpdateStarted: '已開始檢查目前節點全部容器的映像更新',
-        imageCheckUpdateResult: '檢查完成：成功 {checked}，可升級 {updates}，失敗 {failed}，略過 {skipped}',
-
         createByCommand: '指令建立',
         importContainerBackupTip: '匯入容器備份檔案，僅支援 .tar.gz 格式',
         importComposeBackupTip: '匯入編排備份檔案，僅支援 .tar.gz 格式',

frontend/src/lang/modules/zh.ts

@@ -2,6 +2,11 @@ import { getFuLocaleMessage } from '@/lang/fu';
 
 const message = {
     apiKeyManagement: {
+        reveal: '查看密钥',
+        hideSecret: '隐藏密钥',
+        revealHelp: '请妥善保管密钥。查看不会恢复已停用或已过期密钥的使用权限。',
+        deleteConfirm:
+            '确定删除“{0}”吗？密钥将被销毁并从列表移除，拒绝后续请求并关闭关联终端。审计记录仍保留，运行中的任务不会取消，此操作不可恢复。',
         title: 'API Key',
         manage: '管理 API Key',
         personalEntry: '前往设置管理自己的密钥、访问条件和 APP 扫码绑定。',
@@ -22,10 +27,6 @@ const message = {
         futureExpiry: '请选择晚于当前时间的到期时间。',
         allowAppBinding: '允许 APP 扫码绑定',
         bindingDisableHelp: '关闭扫码绑定后，将停止接受新的绑定；已绑定设备可继续使用，直至密钥被停用、撤销或到期。',
-        saveSecret: '请立即复制并保存密钥。关闭后，普通密钥管理无法再次显示完整密钥。',
-        saved: '我已保存密钥',
-        alreadyCreated:
-            '这把密钥已创建，无法再次展示明文。若原响应丢失，请撤销后重新创建；允许扫码绑定时，也可通过扫码交付。',
         uncertain: '请求结果尚不确定。请保持原配置重试，避免重复创建；或关闭并检查列表后再创建其他密钥。',
         legacyHelp: '旧版 Key 用于兼容历史 API 连接，启用、停用和重置操作仅对该 Key 生效。',
         showLegacy: '查看旧版密钥',
@@ -2006,17 +2007,6 @@ const message = {
         batchUpgradeWaiting: '等待执行',
         batchUpgradeRunning: '正在升级',
         batchUpgradeSubmitted: '已提交升级任务',
-        imageCheckUpdateProxyRequired: '当前运行环境下，如需检查镜像是否更新，请优先配置代理服务器',
-        imageCheckUpdateConfigureProxy: '去配置',
-        imageCheckUpdateAvailableVersion: '可升级版本 “{version}”',
-        imageCheckUpdateContentChanged: '（镜像内容变化）',
-        imageCheckUpdates: '检查更新镜像',
-        imageCheckUpdateNow: '立即检查',
-        imageCheckUpdateSchedule: '定时检查',
-        imageCheckUpdateDisable: '关闭定时检查',
-        imageCheckUpdateStarted: '已开始检查当前节点全部容器的镜像更新',
-        imageCheckUpdateResult: '检查完成：成功 {checked}，可升级 {updates}，失败 {failed}，跳过 {skipped}',
-
         createByCommand: '命令创建',
         importContainerBackupTip: '导入容器备份文件，仅支持 .tar.gz 格式',
         importComposeBackupTip: '导入编排备份文件，仅支持 .tar.gz 格式',

frontend/src/utils/app-icon.ts

@@ -0,0 +1,26 @@
+export function isRemoteAppIcon(icon: string): boolean {
+    if (
+        !/^https?:\/\/[^/?#]/i.test(icon) ||
+        /^https?:\/\/[^/?#]*@/i.test(icon) ||
+        Array.from(icon).some(
+            (char) => char <= ' ' || (char >= '\u007f' && char <= '\u009f') || /\s/.test(char) || char === '\\',
+        ) ||
+        /%(?![\da-f]{2})/i.test(icon)
+    ) {
+        return false;
+    }
+    try {
+        const url = new URL(icon);
+        return !!url.hostname && !url.username && !url.password;
+    } catch {
+        return false;
+    }
+}
+
+export function resolveAppIconUrl(appKey: string, node: string | undefined, icon: string, baseURL: string): string {
+    if (isRemoteAppIcon(icon)) {
+        return icon;
+    }
+    const params = node ? `?operateNode=${encodeURIComponent(node)}` : '';
+    return `${baseURL}/apps/icon/${encodeURIComponent(appKey)}${params}`;
+}

frontend/src/views/app-store/apps/app/index.vue

@@ -3,7 +3,9 @@
         <el-card>
             <div class="app-wrapper" @click="openDetail(app.key)">
                 <div class="app-image">
-                    <el-avatar shape="square" :size="60" :src="getAppIconUrl(app.key, currentNode)" />
+                    <el-avatar shape="square" :size="60" :src="getAppIconUrl(app.key, currentNode, app.icon)">
+                        <SvgIcon iconName="p-appstore" />
+                    </el-avatar>
                 </div>
                 <div class="app-content">
                     <div class="content-top">

frontend/src/views/app-store/detail/index.vue

@@ -4,12 +4,15 @@
             <div class="brief" v-loading="loadingApp">
                 <div class="detail flex">
                     <div class="w-12 h-12 rounded p-1 shadow-md icon">
-                        <img
+                        <el-avatar
-                            :src="getAppIconUrl(app.key, currentNode)"
+                            :src="getAppIconUrl(app.key, currentNode, app.icon)"
                             alt="App Icon"
-                            class="w-full h-full rounded"
+                            shape="square"
-                            style="object-fit: contain"
+                            fit="contain"
-                        />
+                            class="!w-full !h-full rounded"
+                        >
+                            <SvgIcon iconName="p-appstore" />
+                        </el-avatar>
                     </div>
                     <div class="ml-4">
                         <div class="name mb-2">

frontend/src/views/app-store/installed/app/card.vue

@@ -6,6 +6,7 @@
                     <AppIcon
                         @open-detail="$emit('openDetail')"
                         :appKey="installed.appKey"
+                        :icon="installed.icon"
                         :currentNode="currentNode"
                     ></AppIcon>
                 </el-col>

frontend/src/views/app-store/installed/app/icon.vue

@@ -1,6 +1,13 @@
 <template>
     <div class="icon">
-        <el-avatar @click="$emit('openDetail')" shape="square" :size="77" :src="getAppIconUrl(appKey, currentNode)" />
+        <el-avatar
+            @click="$emit('openDetail')"
+            shape="square"
+            :size="77"
+            :src="getAppIconUrl(appKey, currentNode, icon)"
+        >
+            <SvgIcon iconName="p-appstore" />
+        </el-avatar>
     </div>
 </template>
 
@@ -10,6 +17,7 @@ import { getAppIconUrl } from '@/api/modules/app';
 interface Props {
     currentNode: string;
     appKey: string;
+    icon?: string;
 }
 defineProps<Props>();
 

frontend/src/views/app-store/installed/ignore/create/index.vue

@@ -65,7 +65,7 @@ const acceptParams = (apppInstall: App.AppInstalled) => {
 
 const getVersions = async () => {
     try {
-        const res = await getAppUpdateVersions({ appInstallID: appInstallID.value });
+        const res = await getAppUpdateVersions({ appInstallID: appInstallID.value, loadCompose: false });
         versions.value = res.data || [];
         if (versions.value.length > 0) {
             req.appDetailID = versions.value[0].detailId;

frontend/src/views/app-store/installed/upgrade/index.vue

@@ -5,7 +5,7 @@
         :resource="resourceName"
         @close="handleClose"
     >
-        <div v-loading="loading">
+        <div v-loading="loading || loadingVersions">
             <el-descriptions direction="vertical">
                 <el-descriptions-item>
                     <el-link @click="toLink(app.website)">
@@ -41,6 +41,13 @@
                             :label="version.version"
                         ></el-option>
                     </el-select>
+                    <el-button
+                        v-if="operateReq.operate === 'upgrade' && !composeReady && !loadingVersions"
+                        class="mt-2"
+                        @click="getVersions(operateReq.version)"
+                    >
+                        {{ $t('commons.button.retry') }}
+                    </el-button>
                 </el-form-item>
                 <el-alert
                     v-if="showOpenclawHttpRollbackNotice"
@@ -55,7 +62,7 @@
                         <div>2. {{ $t('app.openclawHttpsUpgradeNoticeItem2') }}</div>
                     </div>
                 </el-alert>
-                <template v-if="feishuLegacy && operateReq.operate === 'upgrade'">
+                <template v-if="feishuLegacy && operateReq.operate === 'upgrade' && composeReady">
                     <el-alert
                         class="mb-4"
                         type="warning"
@@ -83,7 +90,7 @@
                     <el-checkbox v-model="operateReq.deleteImage" :label="$t('app.upgradeDeleteImage')" />
                 </el-form-item>
             </el-form>
-            <div v-if="operateReq.operate === 'upgrade'">
+            <div v-if="operateReq.operate === 'upgrade' && composeReady">
                 <el-text type="danger" v-if="isEdit">{{ $t('app.isEdirWarn') }}</el-text>
                 <el-text type="warning" v-else>{{ $t('app.upgradeWarn') }}</el-text>
                 <div>
@@ -100,7 +107,16 @@
         </div>
         <template #footer>
             <el-button @click="handleClose" :disabled="loading">{{ $t('commons.button.cancel') }}</el-button>
-            <el-button type="primary" @click="onOperate" :disabled="versions == null || loading">
+            <el-button
+                type="primary"
+                @click="onOperate"
+                :disabled="
+                    versions == null ||
+                    loading ||
+                    loadingVersions ||
+                    (operateReq.operate === 'upgrade' && !composeReady)
+                "
+            >
                 {{ $t('commons.button.confirm') }}
             </el-button>
         </template>
@@ -116,13 +132,13 @@ import CodemirrorPro from '@/components/codemirror-pro/index.vue';
 import { App } from '@/api/interface/app';
 import { AI } from '@/api/interface/ai';
 import FeishuTransition from '@/views/ai/agents/agent/config/tabs/channels/components/feishu-transition.vue';
-import { getAppUpdateVersions, ignoreUpgrade, installedOp } from '@/api/modules/app';
+import { getAppInstallParams, getAppUpdateVersions, ignoreUpgrade, installedOp } from '@/api/modules/app';
 import { getAppStoreConfig } from '@/api/modules/setting';
 import { isOpenclawCurrentHTTPVersion, isOpenclawHTTPSWindowVersion } from '@/utils/agent';
 import i18n from '@/lang';
 import { ElMessageBox, FormInstance } from 'element-plus';
 import { computed, onBeforeUnmount, reactive, ref } from 'vue';
-import { MsgSuccess } from '@/utils/message';
+import { MsgError, MsgSuccess } from '@/utils/message';
 import { Rules } from '@/global/form-rules';
 import bus from '@/global/bus';
 import { v4 as uuidv4 } from 'uuid';
@@ -133,6 +149,10 @@ const composeDiffRef = ref();
 const updateRef = ref<FormInstance>();
 const open = ref(false);
 const loading = ref(false);
+const loadingVersions = ref(false);
+const composeReady = ref(false);
+const currentComposeReady = ref(false);
+let versionRequest = 0;
 const versions = ref<App.VersionDetail[]>();
 const operateReq = reactive({
     detailId: 0,
@@ -163,6 +183,9 @@ const oldContent = ref('');
 const newContent = ref('');
 const em = defineEmits(['close']);
 const handleClose = () => {
+    versionRequest++;
+    loadingVersions.value = false;
+    composeReady.value = false;
     open.value = false;
     em('close', open.value);
 };
@@ -195,9 +218,10 @@ const toLink = (link: string) => {
 };
 
 const openDiff = async () => {
-    if (newContent.value === '') {
+    if (!composeReady.value) {
         await getVersions(operateReq.version);
     }
+    if (!composeReady.value) return;
     composeDiffRef.value.acceptParams(oldContent.value, newContent.value);
 };
 
@@ -212,16 +236,26 @@ const getNewCompose = (compose: string) => {
 };
 
 const initData = async () => {
+    const request = versionRequest;
     const config = await getAppStoreConfig(node.value);
+    if (request !== versionRequest) return false;
     newCompose.value = '';
     useNewCompose.value = false;
     operateReq.backup = config.data.upgradeBackup == 'Enable';
     operateReq.pullImage = true;
     operateReq.deleteImage = config.data.upgradeDeleteImage == 'Enable';
     operateReq.dockerCompose = '';
+    return true;
 };
 
 const acceptParams = async (appInstall: App.AppInstallDto, op: string, opNode?: string) => {
+    versionRequest++;
+    composeReady.value = false;
+    currentComposeReady.value = false;
+    loadingVersions.value = false;
+    versions.value = undefined;
+    operateReq.detailId = 0;
+    operateReq.version = '';
     if (opNode) {
         node.value = opNode;
     } else {
@@ -236,7 +270,7 @@ const acceptParams = async (appInstall: App.AppInstallDto, op: string, opNode?:
         groupSessionScope: 'group',
         requireMention: 'true',
     });
-    await initData();
+    if (!(await initData())) return;
     isEdit.value = appInstall.isEdit;
     currentVersion.value = appInstall.version;
     currentAppKey.value = appInstall.appKey;
@@ -255,20 +289,37 @@ const acceptParams = async (appInstall: App.AppInstallDto, op: string, opNode?:
 };
 
 const getVersions = async (version: string) => {
-    const req = {
+    const request = ++versionRequest;
+    const upgrading = operateReq.operate === 'upgrade';
+    composeReady.value = false;
+    loadingVersions.value = true;
+    const req: App.AppUpdateVersionReq = {
         appInstallID: appInstallID.value,
+        loadCompose: upgrading,
     };
     if (version !== '') {
-        req['updateVersion'] = version;
+        req.updateVersion = version;
     }
     try {
+        if (upgrading && !currentComposeReady.value) {
+            const config = await getAppInstallParams(appInstallID.value, node.value);
+            if (request !== versionRequest) return;
+            if (typeof config.data.isEdit === 'boolean') isEdit.value = config.data.isEdit;
+            oldContent.value = config.data.dockerCompose;
+            currentComposeReady.value = true;
+        }
         const res = await getAppUpdateVersions(req, node.value);
+        if (request !== versionRequest) return;
         versions.value = res.data || [];
-        if (res.data != null && res.data.length > 0) {
+        if (versions.value.length > 0) {
             let item = res.data[0];
             if (version != '') {
                 item = res.data.find((v) => v.version === version);
             }
+            if (!item || (upgrading && !item.dockerCompose?.trim())) {
+                if (upgrading) MsgError(i18n.global.t('container.contentEmpty'));
+                return;
+            }
             feishuLegacy.value = Boolean(item.feishuLegacy);
             feishuConfigured.value = Boolean(item.feishuConfigured);
             if (feishuLegacy.value) operateReq.backup = true;
@@ -277,8 +328,12 @@ const getVersions = async (version: string) => {
             newContent.value = item.dockerCompose;
             newCompose.value = item.dockerCompose;
             useNewCompose.value = false;
+            composeReady.value = upgrading;
         }
-    } catch (error) {}
+    } catch (error) {
+    } finally {
+        if (request === versionRequest) loadingVersions.value = false;
+    }
 };
 
 const openTaskLog = (taskID: string) => {
@@ -286,6 +341,7 @@ const openTaskLog = (taskID: string) => {
 };
 
 const operate = async () => {
+    if (operateReq.operate === 'upgrade' && !composeReady.value) return;
     loading.value = true;
     if (operateReq.operate === 'upgrade') {
         if (useNewCompose.value) {
@@ -316,6 +372,11 @@ const operate = async () => {
 };
 
 const onOperate = async () => {
+    if (loadingVersions.value || (operateReq.operate === 'upgrade' && !composeReady.value)) return;
+    if (operateReq.operate === 'upgrade' && useNewCompose.value && !newCompose.value.trim()) {
+        MsgError(i18n.global.t('container.contentEmpty'));
+        return;
+    }
     await updateRef.value?.validate();
     const helper = i18n.global.t('app.operatorHelper', [i18n.global.t('commons.button.' + operateReq.operate)]);
     const notice =

frontend/src/views/container/container/index.vue

@@ -31,34 +31,6 @@
                 <el-button v-permission type="primary" plain @click="onClean()">
                     {{ $t('container.containerPrune') }}
                 </el-button>
-                <el-dropdown v-permission trigger="click" @command="onImageCheckUpdateCommand">
-                    <el-button type="primary" plain :loading="imageCheckUpdateBusy">
-                        {{ $t('container.imageCheckUpdates') }}
-                        <el-icon class="el-icon--right"><ArrowDown /></el-icon>
-                    </el-button>
-                    <template #dropdown>
-                        <el-dropdown-menu>
-                            <el-dropdown-item
-                                command="check"
-                                :disabled="imageCheckUpdateBusy || imageCheckUpdateStatus?.running"
-                            >
-                                {{ $t('container.imageCheckUpdateNow') }}
-                            </el-dropdown-item>
-                            <el-dropdown-item
-                                command="schedule"
-                                :disabled="imageCheckUpdateBusy || !imageCheckUpdateStatus"
-                            >
-                                {{
-                                    $t(
-                                        imageCheckUpdateStatus?.enabled
-                                            ? 'container.imageCheckUpdateDisable'
-                                            : 'container.imageCheckUpdateSchedule',
-                                    )
-                                }}
-                            </el-dropdown-item>
-                        </el-dropdown-menu>
-                    </template>
-                </el-dropdown>
             </template>
             <template #rightToolBar>
                 <TableViewSwitch v-model="viewMode" storage-key="container" />
@@ -500,15 +472,8 @@ import Uploads from '@/components/upload/index.vue';
 import DockerStatus from '@/views/container/docker-status/index.vue';
 import ContainerLogDialog from '@/components/log/container-drawer/index.vue';
 import Status from '@/components/status/index.vue';
-import { toRef, computed, onMounted, onActivated, onBeforeUnmount, onDeactivated, reactive, ref, watch } from 'vue';
+import { toRef, computed, onBeforeUnmount, onDeactivated, reactive, ref } from 'vue';
-import { ElMessageBox } from 'element-plus';
-import { ArrowDown } from '@element-plus/icons-vue';
 import {
-    getContainerImageCheckUpdateStatus,
-    getImageRemoteCheckStatus,
-    runContainerImageCheckUpdate,
-    setContainerImageCheckUpdateSchedule,
-    type ContainerImageCheckUpdateStatus,
     containerItemStats,
     containerListStats,
     containerOperator,
@@ -812,125 +777,6 @@ const loadContainers = async (background = false, column?: any) => {
 
 const search = (column?: any) => loadContainers(false, column);
 
-const imageCheckUpdateStatus = ref<ContainerImageCheckUpdateStatus>();
-const imageCheckUpdateBusy = ref(false);
-let imageCheckUpdateTimer: ReturnType<typeof setTimeout> | undefined;
-let imageCheckUpdateGeneration = 0;
-let imageCheckUpdateActive = false;
-let imageCheckUpdateController: AbortController | undefined;
-const pauseImageCheckUpdatePolling = () => {
-    imageCheckUpdateGeneration++;
-    clearTimeout(imageCheckUpdateTimer);
-    imageCheckUpdateController?.abort();
-    imageCheckUpdateController = undefined;
-};
-const stopImageCheckUpdatePolling = () => {
-    imageCheckUpdateActive = false;
-    pauseImageCheckUpdatePolling();
-};
-const showImageCheckUpdateResult = (status: ContainerImageCheckUpdateStatus) => {
-    if (status.error) MsgWarning(status.error);
-    else {
-        const summary = i18n.global.t('container.imageCheckUpdateResult', { ...status });
-        if (status.failed) MsgWarning(summary);
-        else MsgSuccess(summary);
-    }
-};
-const refreshImageCheckUpdateStatus = async (generation: number) => {
-    if (!imageCheckUpdateActive || document.hidden || generation !== imageCheckUpdateGeneration) return;
-    const node = currentNode.value;
-    const controller = new AbortController();
-    imageCheckUpdateController = controller;
-    try {
-        const res = await getContainerImageCheckUpdateStatus(node, controller.signal);
-        if (generation !== imageCheckUpdateGeneration || node !== currentNode.value) return;
-        const previous = imageCheckUpdateStatus.value;
-        imageCheckUpdateStatus.value = res.data;
-        if (previous && res.data.finishedAt && previous.finishedAt !== res.data.finishedAt) {
-            await loadContainers();
-            if (generation !== imageCheckUpdateGeneration || node !== currentNode.value) return;
-            showImageCheckUpdateResult(res.data);
-        }
-    } catch {
-        // The HTTP layer displays errors. Retry on the next status poll.
-    } finally {
-        if (imageCheckUpdateController === controller) imageCheckUpdateController = undefined;
-        if (generation === imageCheckUpdateGeneration && imageCheckUpdateActive && !document.hidden) {
-            const interval = imageCheckUpdateStatus.value?.running ? 10000 : 60000;
-            imageCheckUpdateTimer = setTimeout(() => refreshImageCheckUpdateStatus(generation), interval);
-        }
-    }
-};
-const restartImageCheckUpdatePolling = () => {
-    pauseImageCheckUpdatePolling();
-    if (imageCheckUpdateActive && !document.hidden) void refreshImageCheckUpdateStatus(imageCheckUpdateGeneration);
-};
-const startImageCheckUpdatePolling = () => {
-    if (imageCheckUpdateActive) return;
-    imageCheckUpdateActive = true;
-    restartImageCheckUpdatePolling();
-};
-const onImageCheckUpdateCommand = async (command: string) => {
-    const node = currentNode.value;
-    const generation = imageCheckUpdateGeneration;
-    imageCheckUpdateBusy.value = true;
-    try {
-        const status = await getContainerImageCheckUpdateStatus(node);
-        if (generation !== imageCheckUpdateGeneration || node !== currentNode.value) return;
-        imageCheckUpdateStatus.value = status.data;
-        // Disabling an existing schedule must remain possible without a proxy.
-        const proxyStatus =
-            command === 'check' || !status.data.enabled ? await getImageRemoteCheckStatus(node) : undefined;
-        if (generation !== imageCheckUpdateGeneration || node !== currentNode.value) return;
-        if (proxyStatus?.data.proxyRequired) {
-            try {
-                await ElMessageBox.confirm(i18n.global.t('container.imageCheckUpdateProxyRequired'), '', {
-                    confirmButtonText: i18n.global.t('container.imageCheckUpdateConfigureProxy'),
-                    cancelButtonText: i18n.global.t('commons.button.cancel'),
-                    type: 'warning',
-                });
-                if (node === currentNode.value) routerToName('Panel');
-            } catch {
-                // Cancellation leaves the check and schedule untouched.
-            }
-            return;
-        }
-        const res =
-            command === 'check'
-                ? await runContainerImageCheckUpdate(node)
-                : await setContainerImageCheckUpdateSchedule(!imageCheckUpdateStatus.value?.enabled, node);
-        if (generation !== imageCheckUpdateGeneration || node !== currentNode.value) return;
-        imageCheckUpdateStatus.value = res.data;
-        if (command === 'check' && res.data.taskID) openTaskLog(res.data.taskID);
-        if (command === 'check' && !res.data.running) {
-            showImageCheckUpdateResult(res.data);
-            await loadContainers();
-        } else {
-            MsgSuccess(
-                i18n.global.t(
-                    command === 'check' ? 'container.imageCheckUpdateStarted' : 'commons.msg.operationSuccess',
-                ),
-            );
-        }
-        if (generation === imageCheckUpdateGeneration && node === currentNode.value) restartImageCheckUpdatePolling();
-    } catch {
-        // The HTTP layer reports failures; keep the last confirmed schedule state.
-    } finally {
-        if (node === currentNode.value) imageCheckUpdateBusy.value = false;
-    }
-};
-onMounted(startImageCheckUpdatePolling);
-onMounted(() => document.addEventListener('visibilitychange', restartImageCheckUpdatePolling));
-onBeforeUnmount(() => document.removeEventListener('visibilitychange', restartImageCheckUpdatePolling));
-onActivated(startImageCheckUpdatePolling);
-onBeforeUnmount(stopImageCheckUpdatePolling);
-onDeactivated(stopImageCheckUpdatePolling);
-watch(currentNode, () => {
-    imageCheckUpdateStatus.value = undefined;
-    imageCheckUpdateBusy.value = false;
-    restartImageCheckUpdatePolling();
-});
-
 const searchWithStatus = (item: string) => {
     activeTag.value = item;
     paginationConfig.state = activeTag.value;
@@ -1148,15 +994,8 @@ const buttons = [
     {
         label: i18n.global.t('commons.button.upgrade'),
         permission: true,
-        dot: (row: Container.ContainerInfo) => Boolean(row.hasUpdate),
         click: (row: Container.ContainerInfo) => {
-            dialogUpgradeRef.value!.acceptParams({
+            dialogUpgradeRef.value!.acceptParams({ container: row.name, image: row.imageName, fromApp: row.isFromApp });
-                container: row.name,
-                image: row.imageName,
-                fromApp: row.isFromApp,
-                latestVersion: row.latestVersion,
-                hasUpdate: row.hasUpdate,
-            });
         },
     },
     {

frontend/src/views/container/container/upgrade/index.vue

@@ -54,13 +54,6 @@
                         :disabled="loading || !group.names.length || !isGroupEditable(group)"
                     />
                     <span class="input-help">{{ $t('container.upgradeHelper') }}</span>
-                    <div v-if="group.availableVersion" class="input-help">
-                        {{ $t('container.imageCheckUpdateAvailableVersion', { version: group.availableVersion }) }}
-                        <span v-if="imageTag(group.currentImage) === group.availableVersion">
-                            {{ $t('container.imageCheckUpdateContentChanged') }}
-                        </span>
-                        <CopyButton :content="group.availableVersion" />
-                    </div>
                 </el-form-item>
                 <div v-if="group.state !== 'draft'" class="mb-3">
                     <el-tag :type="statusType(group)">{{ statusLabel(group) }}</el-tag>
@@ -107,7 +100,6 @@ import { GlobalStore } from '@/store';
 interface UpgradeGroup {
     currentImage: string;
     targetImage: string;
-    availableVersion: string;
     names: string[];
     appNames: string[];
     options: Container.ContainerOption[];
@@ -120,14 +112,7 @@ interface DialogProps {
     container: string;
     image: string;
     fromApp: boolean;
-    latestVersion?: string;
-    hasUpdate?: boolean;
 }
-const imageTag = (image: string) => {
-    const name = image.slice(image.lastIndexOf('/') + 1);
-    const separator = name.lastIndexOf(':');
-    return separator < 0 ? 'latest' : name.slice(separator + 1);
-};
 const isBatch = ref(false);
 const isGroupEditable = (group: UpgradeGroup) => ['draft', 'failed'].includes(group.state);
 const isGroupChecked = (group: UpgradeGroup) => group.options.length > 0 && group.names.length === group.options.length;
@@ -152,15 +137,7 @@ const acceptParams = async (props: DialogProps | Container.ContainerInfo[]) => {
     isBatch.value = Array.isArray(props);
     const containers = Array.isArray(props)
         ? props
-        : [
+        : [{ name: props.container, imageName: props.image, isFromApp: props.fromApp }];
-              {
-                  name: props.container,
-                  imageName: props.image,
-                  isFromApp: props.fromApp,
-                  latestVersion: props.latestVersion,
-                  hasUpdate: props.hasUpdate,
-              },
-          ];
     operateNode = GlobalStore().currentNode;
     clearTimeout(timer);
     generation++;
@@ -171,7 +148,6 @@ const acceptParams = async (props: DialogProps | Container.ContainerInfo[]) => {
             group = {
                 currentImage: item.imageName,
                 targetImage: item.imageName.includes('sha256:') ? '' : item.imageName,
-                availableVersion: '',
                 names: [],
                 appNames: [],
                 options: [],
@@ -182,7 +158,6 @@ const acceptParams = async (props: DialogProps | Container.ContainerInfo[]) => {
             };
             groups.set(item.imageName, group);
         }
-        if (item.hasUpdate && item.latestVersion) group.availableVersion = item.latestVersion;
         if (!group.names.includes(item.name)) {
             group.names.push(item.name);
             group.options.push({ name: item.name, state: '' });
@@ -190,7 +165,7 @@ const acceptParams = async (props: DialogProps | Container.ContainerInfo[]) => {
         if (item.isFromApp && !group.appNames.includes(item.name)) group.appNames.push(item.name);
     }
     form.groups = [...groups.values()];
-    form.forcePull = containers.some((item) => item.hasUpdate);
+    form.forcePull = false;
     started.value = false;
     visible.value = true;
     formRef.value?.clearValidate();

frontend/src/views/home/app/index.vue

@@ -33,7 +33,9 @@
                         <el-row :gutter="5">
                             <el-col :span="5" class="h-app-media-col">
                                 <div class="h-app-media">
-                                    <el-avatar shape="square" :size="55" :src="getAppIconSrc(app)" />
+                                    <el-avatar shape="square" :size="55" :src="getAppIconSrc(app)">
+                                        <SvgIcon iconName="p-appstore" />
+                                    </el-avatar>
                                 </div>
                             </el-col>
                             <el-col :span="16" class="h-app-main-col">
@@ -149,6 +151,7 @@ import { ref } from 'vue';
 import { jumpToInstall } from '@/utils/app';
 import { routerToName, routerToNameWithQuery } from '@/utils/router';
 import { useGlobalStore } from '@/composables/useGlobalStore';
+import { isRemoteAppIcon } from '@/utils/app-icon';
 
 const { isMobile, isAdminOrNodeAdmin } = useGlobalStore();
 let loading = ref(false);
@@ -232,8 +235,8 @@ const loadOption = async () => {
 
 const getAppIconSrc = (app: any) => {
     const icon = app?.icon || '';
-    if (icon.startsWith('app_') || icon === '') {
+    if (isRemoteAppIcon(icon) || icon.startsWith('app_') || icon === '') {
-        return getAppIconUrl(app.key);
+        return getAppIconUrl(app.key, undefined, icon);
     }
     return `data:image/png;base64,${icon}`;
 };

frontend/src/views/setting/api-keys/index.vue

@@ -42,7 +42,7 @@
                                     />
                                 </el-tooltip>
                             </div>
-                            <div class="text-xs text-gray-500 break-all">{{ row.keyHint }}</div>
+                            <div class="text-xs text-[var(--el-text-color-secondary)] break-all">{{ row.keyHint }}</div>
                         </template>
                     </el-table-column>
                     <el-table-column :label="$t('commons.table.status')" min-width="100" prop="status">
@@ -137,26 +137,50 @@
             v-model="detailVisible"
             :header="$t('apiKeyManagement.details')"
             size="min(640px, 100vw)"
-            @close="clearLegacySecret"
+            @close="clearSecret"
         >
             <APIKeySummary v-if="detail" :item="detail" />
-            <div v-if="detail?.kind === 'legacy' && detail.status !== 'Revoked'" class="mt-5 flex flex-col gap-3">
+            <div v-if="detail && detail.status !== 'Revoked'" class="mt-5 flex flex-col gap-3">
-                <el-alert :title="$t('apiKeyManagement.legacyHelp')" type="info" :closable="false" show-icon />
+                <el-alert
-                <el-space wrap>
+                    :title="
-                    <el-button type="primary" plain :loading="legacyBusy" @click="revealLegacy">
+                        $t(detail.kind === 'legacy' ? 'apiKeyManagement.legacyHelp' : 'apiKeyManagement.revealHelp')
-                        {{ $t('apiKeyManagement.showLegacy') }}
+                    "
+                    type="info"
+                    :closable="false"
+                    show-icon
+                />
+                <el-space v-if="detail.kind === 'legacy'" wrap>
+                    <el-button :disabled="secretBusy" @click="resetLegacy">
+                        {{ $t('setting.apiKeyReset') }}
                     </el-button>
-                    <el-button :disabled="legacyBusy" @click="resetLegacy">{{ $t('setting.apiKeyReset') }}</el-button>
                 </el-space>
                 <el-input
-                    v-if="legacySecret"
+                    :model-value="secret || '********'"
-                    :model-value="legacySecret"
+                    :type="secret ? 'text' : 'password'"
                     :aria-label="$t('setting.apiKey')"
                     readonly
                     autocomplete="off"
                 >
+                    <template #suffix>
+                        <el-button
+                            link
+                            :icon="secret ? Hide : View"
+                            :loading="secretBusy && secretAction === 'reveal'"
+                            :disabled="loading || secretBusy"
+                            :aria-label="$t(secret ? 'apiKeyManagement.hideSecret' : 'apiKeyManagement.reveal')"
+                            :title="$t(secret ? 'apiKeyManagement.hideSecret' : 'apiKeyManagement.reveal')"
+                            :aria-pressed="!!secret"
+                            @click="toggleSecret"
+                        />
+                    </template>
                     <template #append>
-                        <CopyButton :content="legacySecret" :is-icon="false" />
+                        <el-button
+                            :loading="secretBusy && secretAction === 'copy'"
+                            :disabled="loading || secretBusy"
+                            @click="copySecret"
+                        >
+                            {{ $t('commons.button.copy') }}
+                        </el-button>
                     </template>
                 </el-input>
             </div>
@@ -165,10 +189,11 @@
 </template>
 
 <script setup lang="ts">
-import { computed, onActivated, onBeforeUnmount, onDeactivated, onMounted, reactive, ref } from 'vue';
+import { computed, onActivated, onBeforeUnmount, onDeactivated, onMounted, reactive, ref, watch } from 'vue';
 import { ElMessageBox } from 'element-plus';
+import { Hide, View } from '@element-plus/icons-vue';
 import type { APIKey } from '@/api/interface/api-key';
-import { revokeAPIKey, searchAPIKeys, setAPIKeyStatus } from '@/api/modules/api-key';
+import { deleteAPIKey, revealAPIKey, revokeAPIKey, searchAPIKeys, setAPIKeyStatus } from '@/api/modules/api-key';
 import { generateApiKey, getUserInfo } from '@/api/modules/auth';
 import APIKeyEditor from '@/components/api-key-management/editor.vue';
 import APIKeySummary from '@/components/api-key-management/summary.vue';
@@ -176,35 +201,38 @@ import DrawerPro from '@/components/drawer-pro/index.vue';
 import type { FuTableOperationButton } from '@/components/table/shared';
 import { isAnyAPIKeyIP, normalizeAPIKeyIPs } from '@/utils/api-key';
 import { MsgSuccess, MsgWarning } from '@/utils/message';
+import { copyText } from '@/utils/clipboard';
 import i18n from '@/lang';
 import { useGlobalStore } from '@/composables/useGlobalStore';
 
-const { isMobile } = useGlobalStore();
+const { isMobile, globalStore } = useGlobalStore();
 
 const items = ref<APIKey.Item[]>([]);
 const loading = ref(false);
 const editor = ref<InstanceType<typeof APIKeyEditor>>();
 const detail = ref<APIKey.Item>();
 const detailVisible = ref(false);
-const legacySecret = ref('');
+const secret = ref('');
-const legacyBusy = ref(false);
+const secretBusy = ref(false);
+const secretAction = ref<'reveal' | 'copy'>('reveal');
 const pagination = reactive({ currentPage: 1, pageSize: 20, total: 0 });
 let searchVersion = 0;
 let secretRequestVersion = 0;
 let active = false;
+let operationPending = false;
 
 const whitelistEntries = (value: string) =>
     normalizeAPIKeyIPs(value || '')
         .split('\n')
         .filter(Boolean);
 
-const clearLegacySecret = () => {
+const clearSecret = () => {
     secretRequestVersion++;
-    legacySecret.value = '';
+    secret.value = '';
-    legacyBusy.value = false;
+    secretBusy.value = false;
 };
 
-const search = async (preserveLegacyRequest?: number) => {
+const search = async (preserveSecretRequest?: number) => {
     const ticket = ++searchVersion;
     loading.value = true;
     try {
@@ -213,7 +241,7 @@ const search = async (preserveLegacyRequest?: number) => {
         const lastPage = Math.max(1, Math.ceil(response.data.total / pagination.pageSize));
         if (pagination.currentPage > lastPage) {
             pagination.currentPage = lastPage;
-            await search(preserveLegacyRequest);
+            await search(preserveSecretRequest);
             return;
         }
         items.value = response.data.items || [];
@@ -221,8 +249,8 @@ const search = async (preserveLegacyRequest?: number) => {
         if (detail.value) {
             const previousRevision = detail.value.revision;
             detail.value = items.value.find((entry) => entry.id === detail.value?.id);
-            if (detail.value?.revision !== previousRevision && preserveLegacyRequest !== secretRequestVersion)
+            if (detail.value?.revision !== previousRevision && preserveSecretRequest !== secretRequestVersion)
-                clearLegacySecret();
+                clearSecret();
             if (!detail.value) detailVisible.value = false;
         }
     } finally {
@@ -230,7 +258,7 @@ const search = async (preserveLegacyRequest?: number) => {
     }
 };
 const showDetail = (entry: APIKey.Item) => {
-    clearLegacySecret();
+    clearSecret();
     detail.value = entry;
     detailVisible.value = true;
 };
@@ -239,15 +267,19 @@ const operate = async (entry: APIKey.Item, action: string) => {
         editor.value?.open(entry);
         return;
     }
-    if (action !== 'status' && action !== 'revoke') return;
+    if (!active || operationPending || !['status', 'revoke', 'delete'].includes(action)) return;
+    operationPending = true;
+    const requestVersion = searchVersion;
     try {
         await ElMessageBox.confirm(
             i18n.global.t(
-                action === 'revoke'
+                action === 'delete'
-                    ? 'apiKeyManagement.revokeConfirm'
+                    ? 'apiKeyManagement.deleteConfirm'
-                    : entry.status === 'Enable'
+                    : action === 'revoke'
-                      ? 'apiKeyManagement.disableConfirm'
+                      ? 'apiKeyManagement.revokeConfirm'
-                      : 'apiKeyManagement.enableConfirm',
+                      : entry.status === 'Enable'
+                        ? 'apiKeyManagement.disableConfirm'
+                        : 'apiKeyManagement.enableConfirm',
                 [entry.name],
             ),
             i18n.global.t('apiKeyManagement.title'),
@@ -258,20 +290,29 @@ const operate = async (entry: APIKey.Item, action: string) => {
             },
         );
     } catch {
+        operationPending = false;
         return;
     }
+    if (!active || requestVersion !== searchVersion) {
+        operationPending = false;
+        return;
+    }
+    clearSecret();
     loading.value = true;
     try {
         const reference = { id: entry.id, revision: entry.revision };
         const response =
-            action === 'revoke'
+            action === 'delete'
-                ? await revokeAPIKey(reference)
+                ? await deleteAPIKey(reference)
-                : await setAPIKeyStatus({ ...reference, status: entry.status === 'Enable' ? 'Disable' : 'Enable' });
+                : action === 'revoke'
-        clearLegacySecret();
+                  ? await revokeAPIKey(reference)
+                  : await setAPIKeyStatus({ ...reference, status: entry.status === 'Enable' ? 'Disable' : 'Enable' });
+        clearSecret();
         if (response.data?.terminalClosePending) MsgWarning(i18n.global.t('apiKeyManagement.closePending'));
         else MsgSuccess(i18n.global.t('commons.msg.operationSuccess'));
     } finally {
-        await search();
+        operationPending = false;
+        if (active) await search();
     }
 };
 const buttons = computed<FuTableOperationButton<APIKey.Item>[]>(() => [
@@ -300,21 +341,59 @@ const buttons = computed<FuTableOperationButton<APIKey.Item>[]>(() => [
         show: (row) => row.status !== 'Revoked',
         click: (row) => operate(row, 'revoke'),
     },
+    {
+        label: i18n.global.t('commons.button.delete'),
+        show: (row) => row.kind === 'apiKey',
+        click: (row) => operate(row, 'delete'),
+    },
 ]);
-const revealLegacy = async () => {
+const toggleSecret = async () => {
-    if (legacyBusy.value || !detailVisible.value || detail.value?.kind !== 'legacy') return;
+    if (secretBusy.value || loading.value) return;
+    if (secret.value) clearSecret();
+    else await revealSecret();
+};
+const accessSecret = async (action: 'reveal' | 'copy') => {
+    if (secretBusy.value || loading.value || !active || !detailVisible.value || !detail.value) return;
+    if (detail.value.status === 'Revoked') return;
+    const reference = { id: detail.value.id, revision: detail.value.revision };
+    const kind = detail.value.kind;
     const ticket = ++secretRequestVersion;
-    legacyBusy.value = true;
+    secretAction.value = action;
+    secretBusy.value = true;
     try {
-        const response = await getUserInfo();
+        if (action === 'copy' && secret.value) {
-        if (ticket === secretRequestVersion && detailVisible.value && active && detail.value?.kind === 'legacy')
+            await copyText(secret.value);
-            legacySecret.value = response.data.apiKey;
+            return;
+        }
+        secret.value = '';
+        const data =
+            kind === 'legacy'
+                ? { ...reference, apiKey: (await getUserInfo()).data.apiKey }
+                : (await revealAPIKey(reference)).data;
+        if (
+            ticket === secretRequestVersion &&
+            active &&
+            detailVisible.value &&
+            detail.value?.id === reference.id &&
+            detail.value?.kind === kind &&
+            detail.value?.revision === reference.revision &&
+            data.id === reference.id &&
+            data.revision === reference.revision &&
+            data.apiKey
+        ) {
+            if (action === 'copy') await copyText(data.apiKey);
+            else secret.value = data.apiKey;
+        }
+    } catch {
+        if (ticket === secretRequestVersion && active) await search();
     } finally {
-        if (ticket === secretRequestVersion) legacyBusy.value = false;
+        if (ticket === secretRequestVersion) secretBusy.value = false;
     }
 };
+const revealSecret = () => accessSecret('reveal');
+const copySecret = () => accessSecret('copy');
 const resetLegacy = async () => {
-    if (legacyBusy.value || !detailVisible.value || detail.value?.kind !== 'legacy') return;
+    if (secretBusy.value || !detailVisible.value || detail.value?.kind !== 'legacy') return;
     const ticket = ++secretRequestVersion;
     try {
         await ElMessageBox.confirm(i18n.global.t('setting.apiKeyResetHelper'), i18n.global.t('setting.apiKeyReset'));
@@ -322,17 +401,18 @@ const resetLegacy = async () => {
         return;
     }
     if (ticket !== secretRequestVersion || !detailVisible.value || !active) return;
-    legacyBusy.value = true;
+    secretAction.value = 'reveal';
-    legacySecret.value = '';
+    secretBusy.value = true;
+    secret.value = '';
     try {
         const response = await generateApiKey();
         await search(ticket);
         // A reset changes the revision and deliberately clears any older reveal.
         // Never restore a secret after the original details drawer was closed.
         if (ticket === secretRequestVersion && detailVisible.value && active && detail.value?.kind === 'legacy')
-            legacySecret.value = response.data;
+            secret.value = response.data;
     } finally {
-        if (ticket === secretRequestVersion) legacyBusy.value = false;
+        if (ticket === secretRequestVersion) secretBusy.value = false;
     }
 };
 const activate = () => {
@@ -343,9 +423,16 @@ const activate = () => {
 const deactivate = () => {
     active = false;
     searchVersion++;
-    clearLegacySecret();
+    clearSecret();
     detailVisible.value = false;
 };
+watch(
+    () => globalStore.isLogin,
+    (loggedIn) => {
+        if (!loggedIn) deactivate();
+    },
+    { flush: 'sync' },
+);
 onMounted(activate);
 onActivated(activate);
 onDeactivated(deactivate);

frontend/tests/app-compose-on-demand.test.mjs

@@ -0,0 +1,277 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import { baseParse } from '@vue/compiler-dom';
+import { parse } from '@vue/compiler-sfc';
+import ts from 'typescript';
+import { computed, proxyRefs, reactive, ref } from 'vue';
+
+const view = (name) =>
+    parse(readFileSync(new URL(`../src/views/app-store/installed/${name}/index.vue`, import.meta.url), 'utf8'))
+        .descriptor;
+const upgrade = view('upgrade');
+const target = (version = '2.0', detailId = 2, dockerCompose = 'services:\n  app:\n    image: demo:2') => ({
+    version,
+    detailId,
+    dockerCompose,
+});
+
+function drawer(overrides = {}) {
+    const calls = { params: [], versions: [], errors: [], operations: [], confirmations: [] };
+    const bindings = {
+        ref,
+        reactive,
+        computed,
+        onBeforeUnmount: () => {},
+        defineEmits: () => () => {},
+        defineExpose: () => {},
+        useGlobalStore: () => ({ currentNode: ref('local') }),
+        Rules: { requiredSelect: {} },
+        i18n: { global: { t: (key) => key } },
+        bus: { on() {}, off() {}, emit() {} },
+        isOpenclawCurrentHTTPVersion: () => false,
+        isOpenclawHTTPSWindowVersion: () => false,
+        uuidv4: () => 'task-id',
+        MsgError: (message) => calls.errors.push(message),
+        MsgSuccess() {},
+        ElMessageBox: {
+            confirm: (...args) => {
+                calls.confirmations.push(args);
+                return Promise.resolve();
+            },
+        },
+        getAppStoreConfig: async () => ({ data: { upgradeBackup: 'Disable', upgradeDeleteImage: 'Disable' } }),
+        getAppInstallParams: async (...args) => {
+            calls.params.push(args);
+            return { data: { isEdit: true, dockerCompose: 'original custom instance compose' } };
+        },
+        getAppUpdateVersions: async (...args) => {
+            calls.versions.push(args);
+            return { data: [target()] };
+        },
+        installedOp: async (...args) => calls.operations.push(args),
+        ignoreUpgrade: async () => {},
+        ...overrides,
+    };
+    const ast = ts.createSourceFile('upgrade.ts', upgrade.scriptSetup.content, ts.ScriptTarget.Latest, true);
+    const script = ast.statements
+        .filter((statement) => !ts.isImportDeclaration(statement))
+        .map((statement) => statement.getText(ast))
+        .join('\n');
+    const compiled = ts.transpileModule(script, { compilerOptions: { target: ts.ScriptTarget.ESNext } }).outputText;
+    const state = new Function(
+        ...Object.keys(bindings),
+        `${compiled}\nreturn { acceptParams, getVersions, handleClose, openDiff, onOperate, operate, versions, loading, loadingVersions, composeReady, currentComposeReady, operateReq, oldContent, newContent, newCompose, useNewCompose, isEdit, node, appInstallID, feishuLegacy, feishuConfigured, open };`,
+    )(...Object.values(bindings));
+    state.node.value = 'child & node';
+    state.appInstallID.value = 17;
+    state.oldContent.value = 'saved instance compose';
+    return { ...state, calls };
+}
+
+function findNode(node, predicate) {
+    if (predicate(node)) return node;
+    for (const child of node.children || []) {
+        const found = findNode(child, predicate);
+        if (found) return found;
+    }
+}
+
+const template = baseParse(upgrade.template.content);
+const button = findNode(template, (node) =>
+    node.props?.some((prop) => prop.name === 'on' && prop.exp?.content === 'onOperate'),
+);
+const disabled = button.props.find((prop) => prop.name === 'bind' && prop.arg.content === 'disabled').exp.content;
+const isDisabled = (state) => new Function('state', `with (state) { return (${disabled}); }`)(proxyRefs(state));
+
+test('upgrade validates the current template and loads only the default target on the selected node', async () => {
+    const state = drawer();
+    assert.equal(isDisabled(state), true);
+    await state.getVersions('');
+    assert.deepEqual(state.calls.params, [[17, 'child & node']]);
+    assert.deepEqual(state.calls.versions, [[{ appInstallID: 17, loadCompose: true }, 'child & node']]);
+    assert.equal(state.isEdit.value, true, 'authoritative configuration overrides the stale list flag');
+    assert.equal(state.oldContent.value, 'original custom instance compose');
+    assert.equal(state.operateReq.detailId, 2);
+    assert.equal(state.newContent.value, target().dockerCompose);
+    assert.equal(state.composeReady.value, true);
+    assert.equal(isDisabled(state), false);
+});
+
+test('older agents without isEdit retain the existing custom Compose warning', async () => {
+    const state = drawer({ getAppInstallParams: async () => ({ data: { dockerCompose: 'old agent compose' } }) });
+    state.isEdit.value = true;
+    await state.getVersions('');
+    assert.equal(state.isEdit.value, true);
+    assert.equal(state.oldContent.value, 'old agent compose');
+    assert.equal(state.composeReady.value, true);
+});
+
+test('current-template failure blocks preview and submission without changing the saved Compose', async () => {
+    const state = drawer({
+        getAppInstallParams: async () => {
+            throw new Error('template unavailable');
+        },
+    });
+    await state.getVersions('');
+    assert.equal(state.calls.versions.length, 0);
+    assert.equal(state.oldContent.value, 'saved instance compose');
+    assert.equal(state.currentComposeReady.value, false);
+    assert.equal(state.loadingVersions.value, false);
+    assert.equal(isDisabled(state), true);
+    await state.onOperate();
+    await state.operate();
+    assert.equal(state.calls.confirmations.length, 0);
+    assert.equal(state.calls.operations.length, 0);
+});
+
+test('a failed target switch cannot submit the previous target and can be retried', async () => {
+    let fail = true;
+    const state = drawer({
+        getAppUpdateVersions: async (req) => {
+            if (req.updateVersion === '3.0' && fail) throw new Error('download failed');
+            return { data: [target(), target('3.0', 3, 'services:\n  app:\n    image: demo:3')] };
+        },
+    });
+    await state.getVersions('');
+    state.operateReq.version = '3.0';
+    await state.getVersions('3.0');
+    assert.equal(state.operateReq.detailId, 2);
+    assert.equal(state.oldContent.value, 'original custom instance compose');
+    assert.equal(isDisabled(state), true);
+    await state.onOperate();
+    assert.equal(state.calls.confirmations.length, 0);
+    fail = false;
+    await state.getVersions('3.0');
+    assert.equal(state.operateReq.detailId, 3);
+    assert.equal(state.composeReady.value, true);
+    assert.equal(state.calls.params.length, 1, 'switching targets reuses the verified current configuration');
+    assert.equal(isDisabled(state), false);
+});
+
+test('empty and missing target Compose cannot become valid previews', async () => {
+    for (const data of [[target('2.0', 2, '')], [target('2.0', 2, '  ')], [target('different', 3)]]) {
+        const state = drawer({ getAppUpdateVersions: async () => ({ data }) });
+        await state.getVersions('2.0');
+        assert.equal(state.composeReady.value, false);
+        assert.equal(state.operateReq.detailId, 0);
+        assert.equal(state.oldContent.value, 'original custom instance compose');
+        assert.deepEqual(state.calls.errors, ['container.contentEmpty']);
+    }
+});
+
+test('out-of-order responses cannot overwrite the latest selection or enable it too soon', async () => {
+    const pending = new Map();
+    const state = drawer({
+        getAppUpdateVersions: (req) => new Promise((resolve) => pending.set(req.updateVersion, resolve)),
+    });
+    state.currentComposeReady.value = true;
+    const first = state.getVersions('2.0');
+    const latest = state.getVersions('3.0');
+    pending.get('2.0')({ data: [target()] });
+    await first;
+    assert.equal(state.loadingVersions.value, true);
+    assert.equal(state.composeReady.value, false);
+    pending.get('3.0')({ data: [target('3.0', 3)] });
+    await latest;
+    assert.equal(state.operateReq.version, '3.0');
+    assert.equal(state.operateReq.detailId, 3);
+    assert.equal(state.composeReady.value, true);
+});
+
+test('closing a drawer invalidates in-flight template responses', async () => {
+    let resolve;
+    const state = drawer({ getAppUpdateVersions: () => new Promise((done) => (resolve = done)) });
+    state.currentComposeReady.value = true;
+    const request = state.getVersions('2.0');
+    state.handleClose();
+    resolve({ data: [target()] });
+    await request;
+    assert.equal(state.open.value, false);
+    assert.equal(state.composeReady.value, false);
+    assert.equal(state.operateReq.detailId, 0);
+});
+
+test('a late settings response cannot reopen a closed upgrade drawer', async () => {
+    let resolve;
+    const state = drawer({ getAppStoreConfig: () => new Promise((done) => (resolve = done)) });
+    const request = state.acceptParams({ id: 17 }, 'upgrade');
+    state.handleClose();
+    resolve({ data: {} });
+    await request;
+    assert.equal(state.open.value, false);
+    assert.equal(state.calls.params.length, 0);
+    assert.equal(state.calls.versions.length, 0);
+});
+
+test('ignore version requests skip both current and target Compose loading', async () => {
+    const state = drawer();
+    state.operateReq.operate = 'ignore';
+    await state.getVersions('');
+    assert.equal(state.calls.params.length, 0);
+    assert.equal(state.calls.versions[0][0].loadCompose, false);
+
+    const source = view('ignore/create').scriptSetup.content;
+    const ast = ts.createSourceFile('ignore.ts', source, ts.ScriptTarget.Latest, true);
+    const declaration = ast.statements
+        .filter(ts.isVariableStatement)
+        .flatMap((statement) => statement.declarationList.declarations)
+        .find((item) => item.name.getText(ast) === 'getVersions');
+    const compiled = ts.transpileModule(`const getVersions = ${declaration.initializer.getText(ast)};`, {
+        compilerOptions: { target: ts.ScriptTarget.ESNext },
+    }).outputText;
+    let request;
+    const getVersions = new Function(
+        'getAppUpdateVersions',
+        'appInstallID',
+        'versions',
+        'req',
+        `${compiled}\nreturn getVersions;`,
+    )(
+        async (req) => {
+            request = req;
+            return { data: [target()] };
+        },
+        ref(17),
+        ref([]),
+        {},
+    );
+    await getVersions();
+    assert.deepEqual(request, { appInstallID: 17, loadCompose: false });
+});
+
+test('blank custom Compose is rejected before the upgrade confirmation', async () => {
+    const state = drawer();
+    await state.getVersions('');
+    state.useNewCompose.value = true;
+    state.newCompose.value = '  ';
+    await state.onOperate();
+    assert.deepEqual(state.calls.errors, ['container.contentEmpty']);
+    assert.equal(state.calls.confirmations.length, 0);
+});
+
+test('Feishu legacy transition still enforces the required backup', async () => {
+    const state = drawer({
+        getAppUpdateVersions: async () => ({ data: [{ ...target(), feishuLegacy: true, feishuConfigured: true }] }),
+    });
+    state.operateReq.backup = false;
+    await state.getVersions('');
+    assert.equal(state.feishuLegacy.value, true);
+    assert.equal(state.feishuConfigured.value, true);
+    assert.equal(state.operateReq.backup, true);
+});
+
+test('explicit current-configuration loading preserves child-node routing', () => {
+    const source = readFileSync(new URL('../src/api/modules/app.ts', import.meta.url), 'utf8');
+    const ast = ts.createSourceFile('app-api.ts', source, ts.ScriptTarget.Latest, true);
+    const declaration = ast.statements
+        .filter(ts.isVariableStatement)
+        .flatMap((statement) => statement.declarationList.declarations)
+        .find((item) => item.name.getText(ast) === 'getAppInstallParams');
+    const compiled = ts.transpileModule(`const getAppInstallParams = ${declaration.initializer.getText(ast)};`, {
+        compilerOptions: { target: ts.ScriptTarget.ESNext },
+    }).outputText;
+    const request = new Function('http', `${compiled}\nreturn getAppInstallParams;`)({ get: (url) => url });
+    assert.equal(request(17), 'apps/installed/params/17');
+    assert.equal(request(17, 'child & node'), 'apps/installed/params/17?operateNode=child%20%26%20node');
+});

frontend/tests/app-icon.test.mjs

@@ -0,0 +1,195 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import { baseParse, compile } from '@vue/compiler-dom';
+import { parse } from '@vue/compiler-sfc';
+import { ElAvatar } from 'element-plus/es/components/avatar/index.mjs';
+import ts from 'typescript';
+import * as Vue from 'vue';
+import { isRemoteAppIcon, resolveAppIconUrl } from '../src/utils/app-icon.ts';
+
+const cdnURL = 'https://cdn.example/icons/php.png?v=abc123&token=a%2Bb#icon';
+const apiURL = '/api/v2';
+const getAppIconUrl = (key, node, icon = '') => resolveAppIconUrl(key, node, icon, apiURL);
+
+test('accepts absolute HTTP(S) image URLs without changing their query or fragment', () => {
+    for (const icon of [
+        cdnURL,
+        'http://cdn.example/icon.png',
+        'HTTPS://cdn.example:443/icon.png',
+        'https://[::1]/icon',
+    ]) {
+        assert.equal(isRemoteAppIcon(icon), true, icon);
+        assert.equal(getAppIconUrl('php', 'child-node', icon), icon);
+    }
+});
+
+test('rejects unsafe schemes, credentials, normalization ambiguities and malformed URLs', () => {
+    for (const icon of [
+        '//cdn.example/icon.png',
+        'https:cdn.example/icon.png',
+        'https:///icon.png',
+        'javascript:alert(1)',
+        'data:image/png;base64,eA==',
+        'file:///tmp/icon.png',
+        'https://user:password@cdn.example/icon.png',
+        'https://@cdn.example/icon.png',
+        'https://cdn.example:bad/icon.png',
+        'https://cdn.example:65536/icon.png',
+        'https://cdn.example/%zz',
+        'https://cdn.example/icon.png?token=%zz',
+        ' https://cdn.example/icon.png',
+        'https://cdn.example/icon.png\n',
+        'https://cdn.example/\u00a0icon.png',
+        'https://cdn.example/\u0085icon.png',
+        'https://cdn.example\\other/icon.png',
+    ]) {
+        assert.equal(isRemoteAppIcon(icon), false, icon);
+        assert.equal(getAppIconUrl('php', 'child-node', icon), '/api/v2/apps/icon/php?operateNode=child-node');
+    }
+});
+
+test('keeps historical icons and missing fields on the original node-aware API', () => {
+    for (const icon of ['', undefined, 'app_php.png?etag=%22old%22', 'aGlzdG9yaWNhbC1pbWFnZQ==']) {
+        assert.equal(
+            getAppIconUrl('local-php', 'child & node', icon),
+            '/api/v2/apps/icon/local-php?operateNode=child%20%26%20node',
+        );
+    }
+    assert.equal(getAppIconUrl('php'), '/api/v2/apps/icon/php');
+});
+
+const readView = (name) => parse(readFileSync(new URL(`../src/views/${name}`, import.meta.url), 'utf8')).descriptor;
+
+function launcherResolver() {
+    const source = readView('home/app/index.vue').scriptSetup.content;
+    const ast = ts.createSourceFile('launcher.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const declaration = ast.statements
+        .filter(ts.isVariableStatement)
+        .flatMap((statement) => statement.declarationList.declarations)
+        .find((item) => item.name.getText(ast) === 'getAppIconSrc');
+    const expression = ts.transpileModule(`const getAppIconSrc = ${declaration.initializer.getText(ast)};`, {
+        compilerOptions: { target: ts.ScriptTarget.ESNext },
+    }).outputText;
+    return new Function('isRemoteAppIcon', 'getAppIconUrl', `${expression}\nreturn getAppIconSrc;`)(
+        isRemoteAppIcon,
+        getAppIconUrl,
+    );
+}
+
+test('home launcher uses CDN URLs and retains inline historical Base64 icons', () => {
+    const getAppIconSrc = launcherResolver();
+    assert.equal(getAppIconSrc({ key: 'php', icon: cdnURL }), cdnURL);
+    assert.equal(
+        getAppIconSrc({ key: 'php', icon: 'aGlzdG9yaWNhbC1pbWFnZQ==' }),
+        'data:image/png;base64,aGlzdG9yaWNhbC1pbWFnZQ==',
+    );
+    assert.equal(getAppIconSrc({ key: 'php', icon: 'app_php.png?etag=old' }), '/api/v2/apps/icon/php');
+    assert.equal(getAppIconSrc({ key: 'php' }), '/api/v2/apps/icon/php');
+});
+
+function findComponent(node, tag) {
+    if (node.tag === tag) return node;
+    for (const child of node.children || []) {
+        const component = findComponent(child, tag);
+        if (component) return component;
+    }
+}
+
+function mountAvatar(template, context) {
+    const node = (type, text) => ({ type, text, children: [], props: {} });
+    const renderer = Vue.createRenderer({
+        createElement: (type) => node(type),
+        createText: (text) => node('#text', text),
+        createComment: (text) => node('#comment', text),
+        setText: (element, text) => {
+            element.text = text;
+        },
+        setElementText: (element, text) => {
+            element.children = [node('#text', text)];
+        },
+        parentNode: (element) => element.parent,
+        nextSibling: () => null,
+        patchProp: (element, key, _, value) => {
+            element.props[key] = value;
+        },
+        insert(child, parent) {
+            parent.children.push(child);
+            child.parent = parent;
+        },
+        remove(child) {
+            child.parent.children = child.parent.children.filter((item) => item !== child);
+        },
+    });
+    const render = new Function('Vue', compile(template, { mode: 'function', prefixIdentifiers: true }).code)(Vue);
+    const app = renderer.createApp({ setup: () => context, render });
+    app.component('ElAvatar', ElAvatar);
+    app.component('AppIcon', {
+        props: ['appKey', 'icon', 'currentNode'],
+        setup: () => ({ getAppIconUrl }),
+        render: new Function(
+            'Vue',
+            compile(readView('app-store/installed/app/icon.vue').template.content, {
+                mode: 'function',
+                prefixIdentifiers: true,
+            }).code,
+        )(Vue),
+    });
+    app.component('SvgIcon', {
+        props: ['iconName'],
+        render() {
+            return Vue.h('svg', { 'data-icon': this.iconName });
+        },
+    });
+    const root = node('root');
+    app.mount(root);
+    return { root, app };
+}
+
+for (const view of [
+    'app-store/apps/app/index.vue',
+    'app-store/detail/index.vue',
+    'app-store/installed/app/icon.vue',
+    'home/app/index.vue',
+]) {
+    test(`${view}: actual avatar binding loads CDN once and displays the local fallback on error`, async () => {
+        const avatar = findComponent(baseParse(readView(view).template.content), 'el-avatar');
+        assert.ok(avatar, 'image entry must use an avatar with a local fallback');
+        const { root, app } = mountAvatar(avatar.loc.source, {
+            app: { key: 'php', icon: cdnURL },
+            appKey: 'php',
+            icon: cdnURL,
+            currentNode: 'child-node',
+            getAppIconUrl,
+            getAppIconSrc: launcherResolver(),
+        });
+        const element = root.children[0];
+        const image = element.children.find((child) => child.type === 'img');
+        assert.equal(image.props.src, cdnURL);
+        image.props.onError(new Event('error'));
+        await Vue.nextTick();
+        assert.equal(
+            element.children.some((child) => child.type === 'img'),
+            false,
+        );
+        assert.equal(element.children.find((child) => child.type === 'svg').props['data-icon'], 'p-appstore');
+        await Vue.nextTick();
+        assert.equal(
+            element.children.some((child) => child.type === 'img'),
+            false,
+            'failed URL is not retried',
+        );
+        app.unmount();
+    });
+}
+
+test('installed card passes the API icon URL through to the actual icon child component', () => {
+    const icon = findComponent(baseParse(readView('app-store/installed/app/card.vue').template.content), 'AppIcon');
+    const { root, app } = mountAvatar(icon.loc.source, {
+        installed: { appKey: 'php', icon: cdnURL },
+        currentNode: 'child-node',
+    });
+    const image = root.children[0].children[0].children.find((child) => child.type === 'img');
+    assert.equal(image.props.src, cdnURL);
+    app.unmount();
+});