Skip to content

Modern Docker Management, Designed for Everyone

fix: auto update service logic (#323)

Kyle Mendell80f4ec86b6a2
diff --git a/backend/internal/api/auto_update_handler.go b/backend/internal/api/auto_update_handler.go
index 5899ce0c9..0dbd0b9dc 100644
--- a/backend/internal/api/auto_update_handler.go
+++ b/backend/internal/api/auto_update_handler.go
@@ -2,8 +2,10 @@ package api
import (
"net/http"
+ "strconv"
"github.com/gin-gonic/gin"
+ "github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/services"
)
@@ -17,27 +19,97 @@ func NewAutoUpdateHandler(autoUpdateService *services.AutoUpdateService) *AutoUp
}
}
-func (h *AutoUpdateHandler) CheckContainersForUpdates(c *gin.Context) {
- result, err := h.autoUpdateService.CheckAndUpdateContainers(c.Request.Context())
+func (h *AutoUpdateHandler) CheckForUpdates(c *gin.Context) {
+ var req dto.AutoUpdateCheckDto
+ if err := c.ShouldBindJSON(&req); err != nil {
+ req = dto.AutoUpdateCheckDto{Type: "all"}
+ }
+
+ result, err := h.autoUpdateService.CheckForUpdates(c.Request.Context(), req)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": err.Error(),
+ })
+ return
+ }
+
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": result,
+ })
+}
+
+func (h *AutoUpdateHandler) CheckContainers(c *gin.Context) {
+ req := dto.AutoUpdateCheckDto{
+ Type: "containers",
+ }
+
+ result, err := h.autoUpdateService.CheckForUpdates(c.Request.Context(), req)
if err != nil {
- c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": err.Error(),
+ })
return
}
- c.JSON(http.StatusOK, result)
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": result,
+ })
}
-func (h *AutoUpdateHandler) CheckStacksForUpdates(c *gin.Context) {
- result, err := h.autoUpdateService.CheckAndUpdateStacks(c.Request.Context())
+func (h *AutoUpdateHandler) CheckStacks(c *gin.Context) {
+ req := dto.AutoUpdateCheckDto{
+ Type: "stacks",
+ }
+
+ result, err := h.autoUpdateService.CheckForUpdates(c.Request.Context(), req)
+ if err != nil {
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": err.Error(),
+ })
+ return
+ }
+
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": result,
+ })
+}
+
+func (h *AutoUpdateHandler) GetUpdateHistory(c *gin.Context) {
+ limit := 50
+ if limitStr := c.Query("limit"); limitStr != "" {
+ if parsedLimit, err := strconv.Atoi(limitStr); err == nil && parsedLimit > 0 {
+ limit = parsedLimit
+ if limit > 100 {
+ limit = 100
+ }
+ }
+ }
+
+ history, err := h.autoUpdateService.GetAutoUpdateHistory(c.Request.Context(), limit)
if err != nil {
- c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ c.JSON(http.StatusInternalServerError, gin.H{
+ "success": false,
+ "error": err.Error(),
+ })
return
}
- c.JSON(http.StatusOK, result)
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": history,
+ })
}
func (h *AutoUpdateHandler) GetUpdateStatus(c *gin.Context) {
status := h.autoUpdateService.GetUpdateStatus()
- c.JSON(http.StatusOK, status)
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": status,
+ })
}
diff --git a/backend/internal/api/image_handler.go b/backend/internal/api/image_handler.go
index 195260ed3..2d02eca6e 100644
--- a/backend/internal/api/image_handler.go
+++ b/backend/internal/api/image_handler.go
@@ -59,7 +59,7 @@ func (h *ImageHandler) List(c *gin.Context) {
}
} else if len(img.RepoTags) > 0 && img.RepoTags[0] != "<none>:<none>" && img.Repo != "<none>" && h.imageMaturityService != nil {
go func(imageID string, repo string, tag string, createdTime time.Time) {
- maturityData, checkErr := h.imageMaturityService.CheckImageMaturity(context.Background(), imageID, repo, tag, createdTime, nil)
+ maturityData, checkErr := h.imageMaturityService.CheckImageMaturity(context.Background(), imageID, repo, tag, createdTime)
if checkErr == nil {
setErr := h.imageMaturityService.SetImageMaturity(context.Background(), imageID, repo, tag, *maturityData, map[string]interface{}{
"registryDomain": utils.ExtractRegistryDomain(repo),
@@ -268,7 +268,7 @@ func (h *ImageHandler) CheckMaturity(c *gin.Context) {
repo := parts[0]
tag := parts[1]
- maturityData, err := h.imageMaturityService.CheckImageMaturity(c.Request.Context(), imageID, repo, tag, time.Unix(targetImage.Created, 0), nil)
+ maturityData, err := h.imageMaturityService.CheckImageMaturity(c.Request.Context(), imageID, repo, tag, time.Unix(targetImage.Created, 0))
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"success": false,
diff --git a/backend/internal/api/network_handler.go b/backend/internal/api/network_handler.go
index 63a852a8a..a39dfed7c 100644
--- a/backend/internal/api/network_handler.go
+++ b/backend/internal/api/network_handler.go
@@ -55,7 +55,7 @@ func (h *NetworkHandler) List(c *gin.Context) {
}
func (h *NetworkHandler) GetByID(c *gin.Context) {
- id := c.Param("id")
+ id := c.Param("networkId")
network, err := h.networkService.GetNetworkByID(c.Request.Context(), id)
if err != nil {
@@ -149,7 +149,7 @@ func (h *NetworkHandler) ConnectContainer(c *gin.Context) {
}
func (h *NetworkHandler) DisconnectContainer(c *gin.Context) {
- networkID := c.Param("id")
+ networkID := c.Param("networkId")
var req struct {
ContainerID string `json:"containerId" binding:"required"`
diff --git a/backend/internal/api/routes.go b/backend/internal/api/routes.go
index d4dcb01a5..ce4ec6071 100644
--- a/backend/internal/api/routes.go
+++ b/backend/internal/api/routes.go
@@ -252,8 +252,10 @@ func setupAutoUpdateRoutes(api *gin.RouterGroup, services *Services) {
autoUpdateHandler := NewAutoUpdateHandler(services.AutoUpdate)
- autoUpdate.POST("/check/containers", autoUpdateHandler.CheckContainersForUpdates)
- autoUpdate.POST("/check/compose", autoUpdateHandler.CheckStacksForUpdates)
+ autoUpdate.POST("/check", autoUpdateHandler.CheckForUpdates)
+ autoUpdate.POST("/check/containers", autoUpdateHandler.CheckContainers)
+ autoUpdate.POST("/check/compose", autoUpdateHandler.CheckStacks)
+ autoUpdate.GET("/history", autoUpdateHandler.GetUpdateHistory)
autoUpdate.GET("/status", autoUpdateHandler.GetUpdateStatus)
}
diff --git a/backend/internal/bootstrap/services_bootstrap.go b/backend/internal/bootstrap/services_bootstrap.go
index 94aa0a48f..59c5f5090 100644
--- a/backend/internal/bootstrap/services_bootstrap.go
+++ b/backend/internal/bootstrap/services_bootstrap.go
@@ -22,11 +22,11 @@ func initializeServices(db *database.DB, cfg *config.Config) (*api.Services, *se
imageService := services.NewImageService(db, dockerClientService, containerRegistry)
volumeService := services.NewVolumeService(db, dockerClientService)
networkService := services.NewNetworkService(db, dockerClientService)
- imageMaturityService := services.NewImageMaturityService(db, settingsService)
+ imageMaturityService := services.NewImageMaturityService(db, settingsService, containerRegistry)
templateService := services.NewTemplateService(db)
authService := services.NewAuthService(userService, settingsService, cfg.JWTSecret, cfg)
oidcService := services.NewOidcService(authService)
- autoUpdate := services.NewAutoUpdateService(dockerClientService, settingsService, containerService, stackService, imageService, containerRegistry)
+ autoUpdate := services.NewAutoUpdateService(db, dockerClientService, settingsService, containerService, stackService, imageService, containerRegistry)
systemService := services.NewSystemService(db, dockerClientService, containerService, imageService, volumeService, networkService, settingsService)
appServices := &api.Services{
diff --git a/backend/internal/dto/auto_update_dto.go b/backend/internal/dto/auto_update_dto.go
new file mode 100644
index 000000000..75d125859
--- /dev/null
+++ b/backend/internal/dto/auto_update_dto.go
@@ -0,0 +1,44 @@
+package dto
+
+type AutoUpdateCheckDto struct {
+ Type string `json:"type,omitempty"` // "containers", "stacks", or "all"
+ ResourceIds []string `json:"resourceIds,omitempty"` // Specific resources to check
+ ForceUpdate bool `json:"forceUpdate,omitempty"` // Force update even if no changes
+ DryRun bool `json:"dryRun,omitempty"` // Check only, don't apply updates
+}
+
+type AutoUpdateResultDto struct {
+ Success bool `json:"success"`
+ Checked int `json:"checked"`
+ Updated int `json:"updated"`
+ Skipped int `json:"skipped"`
+ Failed int `json:"failed"`
+ StartTime string `json:"startTime"`
+ EndTime string `json:"endTime"`
+ Duration string `json:"duration"`
+ Results []AutoUpdateResourceResult `json:"results"`
+}
+
+type AutoUpdateResourceResult struct {
+ ResourceID string `json:"resourceId"`
+ ResourceName string `json:"resourceName"`
+ ResourceType string `json:"resourceType"`
+ Status string `json:"status"`
+ UpdateAvailable bool `json:"updateAvailable"`
+ UpdateApplied bool `json:"updateApplied"`
+ OldImages map[string]string `json:"oldImages,omitempty"`
+ NewImages map[string]string `json:"newImages,omitempty"`
+ Error string `json:"error,omitempty"`
+ Details map[string]interface{} `json:"details,omitempty"`
+}
+
+type AutoUpdateConfigDto struct {
+ Enabled bool `json:"enabled"`
+ CheckInterval int `json:"checkInterval"` // minutes
+ IncludeContainers bool `json:"includeContainers"`
+ IncludeStacks bool `json:"includeStacks"`
+ AutoApplyUpdates bool `json:"autoApplyUpdates"`
+ ExcludedImages []string `json:"excludedImages,omitempty"`
+ ExcludedContainers []string `json:"excludedContainers,omitempty"`
+ ExcludedStacks []string `json:"excludedStacks,omitempty"`
+}
diff --git a/backend/internal/job/auto_update_job.go b/backend/internal/job/auto_update_job.go
index 2a6ea2338..2336f01d5 100644
--- a/backend/internal/job/auto_update_job.go
+++ b/backend/internal/job/auto_update_job.go
@@ -6,16 +6,15 @@ import (
"time"
"github.com/go-co-op/gocron/v2"
+ "github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/services"
)
-// AutoUpdateJob handles the scheduled auto-update functionality
type AutoUpdateJob struct {
autoUpdateService *services.AutoUpdateService
settingsService *services.SettingsService
}
-// NewAutoUpdateJob creates a new auto-update job
func NewAutoUpdateJob(autoUpdateService *services.AutoUpdateService, settingsService *services.SettingsService) *AutoUpdateJob {
return &AutoUpdateJob{
autoUpdateService: autoUpdateService,
@@ -23,11 +22,9 @@ func NewAutoUpdateJob(autoUpdateService *services.AutoUpdateService, settingsSer
}
}
-// Execute runs the auto-update check
func (j *AutoUpdateJob) Execute(ctx context.Context) error {
log.Println("=== Starting scheduled auto-update check ===")
- // Verify auto-update is still enabled
settings, err := j.settingsService.GetSettings(ctx)
if err != nil {
log.Printf("Failed to get settings during scheduled update: %v", err)
@@ -39,31 +36,44 @@ func (j *AutoUpdateJob) Execute(ctx context.Context) error {
return nil
}
- // Run container updates
- containerResults, err := j.autoUpdateService.CheckAndUpdateContainers(ctx)
- if err != nil {
- log.Printf("Error during container auto-update: %v", err)
- } else {
- log.Printf("Container auto-update completed: %d checked, %d updated, %d errors",
- containerResults.Checked, containerResults.Updated, len(containerResults.Errors))
+ req := dto.AutoUpdateCheckDto{
+ Type: "all",
+ ForceUpdate: false,
+ DryRun: false,
}
- // Run stack updates
- stackResults, err := j.autoUpdateService.CheckAndUpdateStacks(ctx)
+ result, err := j.autoUpdateService.CheckForUpdates(ctx, req)
if err != nil {
- log.Printf("Error during stack auto-update: %v", err)
- } else {
- log.Printf("Stack auto-update completed: %d checked, %d updated, %d errors",
- stackResults.Checked, stackResults.Updated, len(stackResults.Errors))
+ log.Printf("Error during auto-update: %v", err)
+ return err
+ }
+
+ log.Printf("Auto-update completed: %d checked, %d updated, %d skipped, %d failed",
+ result.Checked, result.Updated, result.Skipped, result.Failed)
+
+ if result.Failed > 0 {
+ log.Printf("Auto-update had %d failures", result.Failed)
+ for _, res := range result.Results {
+ if res.Error != "" {
+ log.Printf("Failed to update %s (%s): %s", res.ResourceName, res.ResourceType, res.Error)
+ }
+ }
+ }
+
+ if result.Updated > 0 {
+ log.Printf("Successfully updated %d resources", result.Updated)
+ for _, res := range result.Results {
+ if res.UpdateApplied {
+ log.Printf("Updated %s (%s)", res.ResourceName, res.ResourceType)
+ }
+ }
}
log.Println("=== Scheduled auto-update check completed ===")
return nil
}
-// RegisterAutoUpdateJob registers the auto-update job with the scheduler
func RegisterAutoUpdateJob(ctx context.Context, scheduler *Scheduler, autoUpdateService *services.AutoUpdateService, settingsService *services.SettingsService) error {
- // Get current settings to determine if auto-update is enabled and get interval
settings, err := settingsService.GetSettings(ctx)
if err != nil {
return err
@@ -91,7 +101,7 @@ func RegisterAutoUpdateJob(ctx context.Context, scheduler *Scheduler, autoUpdate
"auto-update",
jobDefinition,
job.Execute,
- false, // Don't run immediately on startup
+ false,
)
}
diff --git a/backend/internal/models/auto_update.go b/backend/internal/models/auto_update.go
new file mode 100644
index 000000000..638c29601
--- /dev/null
+++ b/backend/internal/models/auto_update.go
@@ -0,0 +1,37 @@
+package models
+
+import (
+ "time"
+)
+
+type AutoUpdateStatus string
+
+const (
+ AutoUpdateStatusPending AutoUpdateStatus = "pending"
+ AutoUpdateStatusChecking AutoUpdateStatus = "checking"
+ AutoUpdateStatusUpdating AutoUpdateStatus = "updating"
+ AutoUpdateStatusCompleted AutoUpdateStatus = "completed"
+ AutoUpdateStatusFailed AutoUpdateStatus = "failed"
+ AutoUpdateStatusSkipped AutoUpdateStatus = "skipped"
+)
+
+type AutoUpdateRecord struct {
+ ID string `json:"id" gorm:"primaryKey"`
+ ResourceID string `json:"resourceId" gorm:"index;not null"`
+ ResourceType string `json:"resourceType" gorm:"not null"` // "container" or "stack"
+ ResourceName string `json:"resourceName" gorm:"not null"`
+ Status AutoUpdateStatus `json:"status" gorm:"not null"`
+ StartTime time.Time `json:"startTime" gorm:"not null"`
+ EndTime *time.Time `json:"endTime,omitempty"`
+ UpdateAvailable bool `json:"updateAvailable" gorm:"default:false"`
+ UpdateApplied bool `json:"updateApplied" gorm:"default:false"`
+ OldImageVersions JSON `json:"oldImageVersions,omitempty" gorm:"type:text"`
+ NewImageVersions JSON `json:"newImageVersions,omitempty" gorm:"type:text"`
+ Error *string `json:"error,omitempty"`
+ Details JSON `json:"details,omitempty" gorm:"type:text"`
+ BaseModel
+}
+
+func (AutoUpdateRecord) TableName() string {
+ return "auto_update_records"
+}
diff --git a/backend/internal/services/auto_update_service.go b/backend/internal/services/auto_update_service.go
index c9a4c46e4..43e7da46c 100644
--- a/backend/internal/services/auto_update_service.go
+++ b/backend/internal/services/auto_update_service.go
@@ -1,14 +1,12 @@
package services
import (
- "bufio"
"context"
"encoding/base64"
"encoding/json"
"fmt"
- "io"
"log"
- "regexp"
+ "slices"
"strings"
"sync"
"time"
@@ -17,12 +15,17 @@ import (
"github.com/docker/docker/api/types/image"
"github.com/docker/docker/api/types/network"
"github.com/docker/docker/api/types/registry"
+ "github.com/google/uuid"
"gopkg.in/yaml.v3"
+ "github.com/ofkm/arcane-backend/internal/database"
+ "github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/models"
+ "github.com/ofkm/arcane-backend/internal/utils"
)
type AutoUpdateService struct {
+ db *database.DB
dockerService *DockerClientService
settingsService *SettingsService
containerService *ContainerService
@@ -34,34 +37,17 @@ type AutoUpdateService struct {
mutex sync.RWMutex
}
-type UpdateResult struct {
- Checked int `json:"checked"`
- Updated int `json:"updated"`
- Skipped int `json:"skipped"`
- Errors []UpdateError `json:"errors"`
- StartTime time.Time `json:"start_time"`
- EndTime time.Time `json:"end_time"`
- Duration string `json:"duration"`
-}
-
-type UpdateError struct {
- ID string `json:"id"`
- Name string `json:"name"`
- Type string `json:"type"` // "container" or "stack"
- Error string `json:"error"`
- ImageRef string `json:"image_ref,omitempty"`
-}
-
-type RegistryCredentials struct {
- URL string `json:"url"`
- Username string `json:"username"`
- Password string `json:"password"`
-}
-
-func NewAutoUpdateService(dockerService *DockerClientService, settingsService *SettingsService,
- containerService *ContainerService, stackService *StackService, imageService *ImageService,
- registryService *ContainerRegistryService) *AutoUpdateService {
+func NewAutoUpdateService(
+ db *database.DB,
+ dockerService *DockerClientService,
+ settingsService *SettingsService,
+ containerService *ContainerService,
+ stackService *StackService,
+ imageService *ImageService,
+ registryService *ContainerRegistryService,
+) *AutoUpdateService {
return &AutoUpdateService{
+ db: db,
dockerService: dockerService,
settingsService: settingsService,
containerService: containerService,
@@ -73,12 +59,12 @@ func NewAutoUpdateService(dockerService *DockerClientService, settingsService *S
}
}
-// CheckAndUpdateContainers checks and updates eligible containers
-func (s *AutoUpdateService) CheckAndUpdateContainers(ctx context.Context) (*UpdateResult, error) {
+func (s *AutoUpdateService) CheckForUpdates(ctx context.Context, req dto.AutoUpdateCheckDto) (*dto.AutoUpdateResultDto, error) {
startTime := time.Now()
- result := &UpdateResult{
- StartTime: startTime,
- Errors: []UpdateError{},
+ result := &dto.AutoUpdateResultDto{
+ Success: true,
+ StartTime: startTime.Format(time.RFC3339),
+ Results: []dto.AutoUpdateResourceResult{},
}
settings, err := s.settingsService.GetSettings(ctx)
@@ -86,563 +72,551 @@ func (s *AutoUpdateService) CheckAndUpdateContainers(ctx context.Context) (*Upda
return nil, fmt.Errorf("failed to get settings: %w", err)
}
- if !settings.AutoUpdate {
- result.EndTime = time.Now()
- result.Duration = result.EndTime.Sub(result.StartTime).String()
+ if !settings.AutoUpdate && !req.ForceUpdate {
+ result.Skipped = 1
+ result.EndTime = time.Now().Format(time.RFC3339)
+ result.Duration = time.Since(startTime).String()
return result, nil
}
- log.Println("Starting container auto-update check...")
+ var wg sync.WaitGroup
+ resultsChan := make(chan dto.AutoUpdateResourceResult, 1000)
+ errorsChan := make(chan error, 100)
- dockerClient, err := s.dockerService.CreateConnection(ctx)
- if err != nil {
- return nil, fmt.Errorf("failed to connect to Docker: %w", err)
- }
- defer dockerClient.Close()
-
- containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
- if err != nil {
- return nil, fmt.Errorf("failed to list containers: %w", err)
+ checkType := strings.ToLower(req.Type)
+ if checkType == "" || checkType == "all" {
+ checkType = "all"
}
- var eligibleContainers []container.Summary
- for _, container := range containers {
- containerName := s.getContainerName(container)
-
- if container.State != "running" {
- continue
- }
-
- if s.hasAutoUpdateLabel(container.Labels) {
- if s.isPartOfStack(container.Labels) {
- log.Printf("Skipping container %s - part of a stack, will be updated via stack update", containerName)
- continue
- }
-
- eligibleContainers = append(eligibleContainers, container)
- }
+ if checkType == "all" || checkType == "containers" {
+ wg.Add(1)
+ go func() {
+ defer func() {
+ if r := recover(); r != nil {
+ log.Printf("Panic in container check goroutine: %v", r)
+ errorsChan <- fmt.Errorf("container check panic: %v", r)
+ }
+ wg.Done()
+ }()
+ s.checkContainers(ctx, req, settings, resultsChan, errorsChan)
+ }()
}
- result.Checked = len(eligibleContainers)
- log.Printf("Found %d standalone containers eligible for auto-update", len(eligibleContainers))
-
- for _, container := range eligibleContainers {
- containerID := container.ID
- containerName := s.getContainerName(container)
-
- s.mutex.RLock()
- isUpdating := s.updatingContainers[containerID]
- s.mutex.RUnlock()
-
- if isUpdating {
- log.Printf("Container %s is already being updated, skipping", containerName)
- result.Skipped++
- continue
- }
-
- s.mutex.Lock()
- s.updatingContainers[containerID] = true
- s.mutex.Unlock()
-
- func() {
+ if checkType == "all" || checkType == "stacks" {
+ wg.Add(1)
+ go func() {
defer func() {
- s.mutex.Lock()
- delete(s.updatingContainers, containerID)
- s.mutex.Unlock()
+ if r := recover(); r != nil {
+ log.Printf("Panic in stack check goroutine: %v", r)
+ errorsChan <- fmt.Errorf("stack check panic: %v", r)
+ }
+ wg.Done()
}()
+ s.checkStacks(ctx, req, settings, resultsChan, errorsChan)
+ }()
+ }
- log.Printf("Checking container for updates: %s", containerName)
-
- updateAvailable, err := s.checkContainerForUpdate(ctx, container, settings)
- if err != nil {
- log.Printf("Error checking container %s: %v", containerName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: containerID,
- Name: containerName,
- Type: "container",
- Error: err.Error(),
- ImageRef: container.Image,
- })
- return
- }
+ go func() {
+ wg.Wait()
+ close(resultsChan)
+ close(errorsChan)
+ }()
- if updateAvailable {
- log.Printf("Update available for container %s, recreating...", containerName)
-
- if err := s.recreateStandaloneContainer(ctx, container); err != nil {
- log.Printf("Error recreating container %s: %v", containerName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: containerID,
- Name: containerName,
- Type: "container",
- Error: fmt.Sprintf("Failed to recreate: %v", err),
- ImageRef: container.Image,
- })
- return
- }
+ for res := range resultsChan {
+ result.Results = append(result.Results, res)
+ result.Checked++
- log.Printf("Successfully updated container %s", containerName)
+ if res.UpdateAvailable {
+ if res.UpdateApplied {
result.Updated++
- } else {
- log.Printf("Container %s is up-to-date", containerName)
+ } else if req.DryRun {
+ result.Skipped++
}
- }()
+ }
+
+ if res.Error != "" {
+ result.Failed++
+ }
+
+ s.recordAutoUpdate(ctx, res)
}
- result.EndTime = time.Now()
- result.Duration = result.EndTime.Sub(result.StartTime).String()
+ for err := range errorsChan {
+ log.Printf("Auto-update error: %v", err)
+ }
- log.Printf("Container auto-update completed: %d checked, %d updated, %d skipped, %d errors",
- result.Checked, result.Updated, result.Skipped, len(result.Errors))
+ result.EndTime = time.Now().Format(time.RFC3339)
+ result.Duration = time.Since(startTime).String()
return result, nil
}
-func (s *AutoUpdateService) recreateStandaloneContainer(ctx context.Context, container container.Summary) error {
- containerName := s.getContainerName(container)
-
+func (s *AutoUpdateService) checkContainers(
+ ctx context.Context,
+ req dto.AutoUpdateCheckDto,
+ settings *models.Settings,
+ results chan<- dto.AutoUpdateResourceResult,
+ errors chan<- error,
+) {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
- return fmt.Errorf("failed to connect to Docker: %w", err)
+ errors <- fmt.Errorf("failed to connect to Docker: %w", err)
+ return
}
defer dockerClient.Close()
- containerJSON, err := dockerClient.ContainerInspect(ctx, container.ID)
+ containers, err := dockerClient.ContainerList(ctx, container.ListOptions{All: false})
if err != nil {
- return fmt.Errorf("failed to inspect container: %w", err)
- }
-
- log.Printf("Stopping container %s...", containerName)
- if err := s.containerService.StopContainer(ctx, container.ID); err != nil {
- return fmt.Errorf("failed to stop container: %w", err)
+ errors <- fmt.Errorf("failed to list containers: %w", err)
+ return
}
- log.Printf("Removing container %s...", containerName)
- if err := s.containerService.DeleteContainer(ctx, container.ID, false, false); err != nil {
- return fmt.Errorf("failed to remove container: %w", err)
- }
+ for _, cnt := range containers {
+ if len(req.ResourceIds) > 0 && !slices.Contains(req.ResourceIds, cnt.ID) {
+ continue
+ }
- config := containerJSON.Config
- hostConfig := containerJSON.HostConfig
- networkingConfig := &network.NetworkingConfig{
- EndpointsConfig: containerJSON.NetworkSettings.Networks,
- }
+ if !s.isContainerEligibleForUpdate(cnt) {
+ continue
+ }
- log.Printf("Creating new container %s with updated image...", containerName)
- _, err = s.containerService.CreateContainer(ctx, config, hostConfig, networkingConfig, containerName)
- if err != nil {
- return fmt.Errorf("failed to create new container: %w", err)
+ result := s.checkSingleContainer(ctx, cnt, settings, req.DryRun)
+ results <- result
}
-
- return nil
}
-// isPartOfStack checks if a container is part of a Docker Compose stack
-func (s *AutoUpdateService) isPartOfStack(labels map[string]string) bool {
- if labels == nil {
- return false
- }
-
- _, hasComposeProject := labels["com.docker.compose.project"]
- _, hasComposeService := labels["com.docker.compose.service"]
+func (s *AutoUpdateService) checkSingleContainer(
+ ctx context.Context,
+ cnt container.Summary,
+ settings *models.Settings,
+ dryRun bool,
+) dto.AutoUpdateResourceResult {
+ containerName := s.getContainerName(cnt)
- return hasComposeProject || hasComposeService
-}
+ result := dto.AutoUpdateResourceResult{
+ ResourceID: cnt.ID,
+ ResourceName: containerName,
+ ResourceType: "container",
+ Status: "checked",
+ OldImages: make(map[string]string),
+ NewImages: make(map[string]string),
+ }
-// CheckAndUpdateStacks checks and updates eligible stacks
-func (s *AutoUpdateService) CheckAndUpdateStacks(ctx context.Context) (*UpdateResult, error) {
- startTime := time.Now()
- result := &UpdateResult{
- StartTime: startTime,
- Errors: []UpdateError{},
+ s.mutex.Lock()
+ if s.updatingContainers[cnt.ID] {
+ s.mutex.Unlock()
+ result.Status = "skipped"
+ result.Error = "Already updating"
+ return result
}
+ s.updatingContainers[cnt.ID] = true
+ s.mutex.Unlock()
- settings, err := s.settingsService.GetSettings(ctx)
+ defer func() {
+ s.mutex.Lock()
+ delete(s.updatingContainers, cnt.ID)
+ s.mutex.Unlock()
+ }()
+
+ dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
- return nil, fmt.Errorf("failed to get settings: %w", err)
+ result.Status = "failed"
+ result.Error = fmt.Sprintf("Failed to connect to Docker: %v", err)
+ return result
}
+ defer dockerClient.Close()
- if !settings.AutoUpdate {
- result.EndTime = time.Now()
- result.Duration = result.EndTime.Sub(result.StartTime).String()
- return result, nil
+ containerJSON, err := dockerClient.ContainerInspect(ctx, cnt.ID)
+ if err != nil {
+ result.Status = "failed"
+ result.Error = fmt.Sprintf("Failed to inspect container: %v", err)
+ return result
}
- log.Println("Starting stack auto-update check...")
+ imageRef := containerJSON.Config.Image
+ result.OldImages["main"] = fmt.Sprintf("%s@%s", imageRef, cnt.ImageID)
- eligibleStacks, err := s.getEligibleStacks(ctx)
+ hasUpdate, newImageID, err := s.checkImageForUpdate(ctx, imageRef, cnt.ImageID, settings)
if err != nil {
- return nil, err
+ result.Status = "failed"
+ result.Error = fmt.Sprintf("Failed to check for updates: %v", err)
+ return result
}
- result.Checked = len(eligibleStacks)
- log.Printf("Found %d stacks eligible for auto-update", len(eligibleStacks))
-
- s.processStackUpdates(ctx, eligibleStacks, settings, result)
-
- result.EndTime = time.Now()
- result.Duration = result.EndTime.Sub(result.StartTime).String()
+ result.UpdateAvailable = hasUpdate
+ if hasUpdate {
+ result.NewImages["main"] = fmt.Sprintf("%s@%s", imageRef, newImageID)
- log.Printf("Stack auto-update completed: %d checked, %d updated, %d skipped, %d errors",
- result.Checked, result.Updated, result.Skipped, len(result.Errors))
+ if !dryRun {
+ if err := s.updateContainer(ctx, cnt, containerJSON, settings); err != nil {
+ result.Status = "failed"
+ result.Error = fmt.Sprintf("Failed to update container: %v", err)
+ return result
+ }
+ result.UpdateApplied = true
+ result.Status = "updated"
+ } else {
+ result.Status = "update_available"
+ }
+ } else {
+ result.Status = "up_to_date"
+ }
- return result, nil
+ return result
}
-func (s *AutoUpdateService) getEligibleStacks(ctx context.Context) ([]models.Stack, error) {
+func (s *AutoUpdateService) checkStacks(
+ ctx context.Context,
+ req dto.AutoUpdateCheckDto,
+ settings *models.Settings,
+ results chan<- dto.AutoUpdateResourceResult,
+ errors chan<- error,
+) {
stacks, err := s.stackService.ListStacks(ctx)
if err != nil {
- return nil, fmt.Errorf("failed to list stacks: %w", err)
+ errors <- fmt.Errorf("failed to list stacks: %w", err)
+ return
}
- var eligibleStacks []models.Stack
for _, stack := range stacks {
- if stack.Status != "running" && stack.Status != "partially running" {
+ if len(req.ResourceIds) > 0 && !slices.Contains(req.ResourceIds, stack.ID) {
continue
}
- eligible, err := s.isStackEligibleForAutoUpdate(ctx, stack)
- if err != nil {
- log.Printf("Error checking stack %s eligibility: %v", stack.Name, err)
- continue
- }
-
- if eligible {
- eligibleStacks = append(eligibleStacks, stack)
- }
- }
-
- return eligibleStacks, nil
-}
-
-func (s *AutoUpdateService) processStackUpdates(ctx context.Context, eligibleStacks []models.Stack, settings *models.Settings, result *UpdateResult) {
- for _, stack := range eligibleStacks {
- if s.shouldSkipStack(stack.ID, stack.Name, result) {
+ if !s.isStackEligibleForUpdate(ctx, stack) {
continue
}
- s.updateSingleStack(ctx, stack, settings, result)
+ result := s.checkSingleStack(ctx, stack, settings, req.DryRun)
+ results <- result
}
}
-func (s *AutoUpdateService) shouldSkipStack(stackID, stackName string, result *UpdateResult) bool {
- s.mutex.RLock()
- isUpdating := s.updatingStacks[stackID]
- s.mutex.RUnlock()
-
- if isUpdating {
- log.Printf("Stack %s is already being updated, skipping", stackName)
- result.Skipped++
- return true
+func (s *AutoUpdateService) checkSingleStack(
+ ctx context.Context,
+ stack models.Stack,
+ settings *models.Settings,
+ dryRun bool,
+) dto.AutoUpdateResourceResult {
+ result := dto.AutoUpdateResourceResult{
+ ResourceID: stack.ID,
+ ResourceName: stack.Name,
+ ResourceType: "stack",
+ Status: "checked",
+ OldImages: make(map[string]string),
+ NewImages: make(map[string]string),
+ Details: make(map[string]interface{}),
}
- return false
-}
-
-func (s *AutoUpdateService) updateSingleStack(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) {
- stackID := stack.ID
- stackName := stack.Name
-
s.mutex.Lock()
- s.updatingStacks[stackID] = true
+ if s.updatingStacks[stack.ID] {
+ s.mutex.Unlock()
+ result.Status = "skipped"
+ result.Error = "Already updating"
+ return result
+ }
+ s.updatingStacks[stack.ID] = true
s.mutex.Unlock()
defer func() {
s.mutex.Lock()
- delete(s.updatingStacks, stackID)
+ delete(s.updatingStacks, stack.ID)
s.mutex.Unlock()
}()
- log.Printf("Checking stack for updates: %s", stackName)
+ services, err := s.stackService.GetStackServices(ctx, stack.ID)
+ if err != nil {
+ result.Status = "failed"
+ result.Error = fmt.Sprintf("Failed to get stack services: %v", err)
+ return result
+ }
+
+ for _, svc := range services {
+ if svc.Image != "" {
+ result.OldImages[svc.Name] = svc.Image
+ }
+ }
- updateAvailable, err := s.checkStackForUpdate(ctx, stack, settings)
+ hasUpdates, imageUpdates, err := s.checkStackImagesForUpdates(ctx, stack, settings)
if err != nil {
- log.Printf("Error checking stack %s: %v", stackName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stackID,
- Name: stackName,
- Type: "stack",
- Error: err.Error(),
- })
- return
+ result.Status = "failed"
+ result.Error = fmt.Sprintf("Failed to check for updates: %v", err)
+ return result
}
- if updateAvailable {
- s.performStackUpdate(ctx, stack, settings, result)
+ result.UpdateAvailable = hasUpdates
+ if hasUpdates {
+ for svcName, newImage := range imageUpdates {
+ result.NewImages[svcName] = newImage
+ }
+
+ if !dryRun {
+ if err := s.updateStack(ctx, stack, settings); err != nil {
+ result.Status = "failed"
+ result.Error = fmt.Sprintf("Failed to update stack: %v", err)
+ return result
+ }
+ result.UpdateApplied = true
+ result.Status = "updated"
+ } else {
+ result.Status = "update_available"
+ }
} else {
- log.Printf("Stack %s is up-to-date", stackName)
+ result.Status = "up_to_date"
}
-}
-func (s *AutoUpdateService) performStackUpdate(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) {
- stackID := stack.ID
- stackName := stack.Name
+ return result
+}
- log.Printf("Updates available for stack %s, stopping, pulling images and redeploying...", stackName)
+func (s *AutoUpdateService) updateContainer(
+ ctx context.Context,
+ cnt container.Summary,
+ containerJSON container.InspectResponse,
+ settings *models.Settings,
+) error {
+ log.Printf("Updating container: %s", s.getContainerName(cnt))
- if err := s.stopStackForUpdate(ctx, stackID, stackName, result); err != nil {
- return
+ if err := s.containerService.StopContainer(ctx, cnt.ID); err != nil {
+ return fmt.Errorf("failed to stop container: %w", err)
}
- if err := s.pullStackImagesForUpdate(ctx, stack, settings, result); err != nil {
- return
+ if err := s.containerService.DeleteContainer(ctx, cnt.ID, false, false); err != nil {
+ return fmt.Errorf("failed to remove container: %w", err)
}
- if err := s.redeployStackAfterUpdate(ctx, stackID, stackName, result); err != nil {
- return
+ config := containerJSON.Config
+ hostConfig := containerJSON.HostConfig
+ networkingConfig := &network.NetworkingConfig{
+ EndpointsConfig: containerJSON.NetworkSettings.Networks,
}
- log.Printf("Successfully updated stack %s", stackName)
- result.Updated++
-}
+ containerName := strings.TrimPrefix(containerJSON.Name, "/")
-func (s *AutoUpdateService) stopStackForUpdate(ctx context.Context, stackID, stackName string, result *UpdateResult) error {
- log.Printf("Stopping stack %s...", stackName)
- if err := s.stackService.StopStack(ctx, stackID); err != nil {
- log.Printf("Error stopping stack %s: %v", stackName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stackID,
- Name: stackName,
- Type: "stack",
- Error: fmt.Sprintf("Failed to stop stack: %v", err),
- })
- return err
+ newContainer, err := s.containerService.CreateContainer(ctx, config, hostConfig, networkingConfig, containerName)
+ if err != nil {
+ return fmt.Errorf("failed to create new container: %w", err)
}
+
+ if err := s.containerService.StartContainer(ctx, newContainer.ID); err != nil {
+ return fmt.Errorf("failed to start new container: %w", err)
+ }
+
+ log.Printf("Successfully updated container: %s", s.getContainerName(cnt))
return nil
}
-func (s *AutoUpdateService) pullStackImagesForUpdate(ctx context.Context, stack models.Stack, settings *models.Settings, result *UpdateResult) error {
- log.Printf("Pulling updated images for stack %s...", stack.Name)
- if err := s.pullStackImages(ctx, stack, settings); err != nil {
- log.Printf("Error pulling images for stack %s: %v", stack.Name, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stack.ID,
- Name: stack.Name,
- Type: "stack",
- Error: fmt.Sprintf("Failed to pull images: %v", err),
- })
- return err
+func (s *AutoUpdateService) updateStack(
+ ctx context.Context,
+ stack models.Stack,
+ settings *models.Settings,
+) error {
+ log.Printf("Updating stack: %s", stack.Name)
+
+ log.Printf("Pulling latest images for stack: %s", stack.Name)
+ if err := s.stackService.PullStackImages(ctx, stack.ID); err != nil {
+ log.Printf("Warning: Failed to pull some images: %v", err)
+ }
+
+ log.Printf("Redeploying stack: %s", stack.Name)
+ if err := s.stackService.RedeployStack(ctx, stack.ID, nil, nil); err != nil {
+ return fmt.Errorf("failed to redeploy stack: %w", err)
}
+
+ log.Printf("Successfully updated stack: %s", stack.Name)
return nil
}
-func (s *AutoUpdateService) redeployStackAfterUpdate(ctx context.Context, stackID, stackName string, result *UpdateResult) error {
- log.Printf("Deploying stack %s with updated images...", stackName)
- if err := s.stackService.DeployStack(ctx, stackID); err != nil {
- log.Printf("Error redeploying stack %s: %v", stackName, err)
- result.Errors = append(result.Errors, UpdateError{
- ID: stackID,
- Name: stackName,
- Type: "stack",
- Error: fmt.Sprintf("Failed to redeploy: %v", err),
- })
- return err
+func (s *AutoUpdateService) checkImageForUpdate(
+ ctx context.Context,
+ imageRef string,
+ currentImageID string,
+ settings *models.Settings,
+) (bool, string, error) {
+ if s.isDigestBasedImage(imageRef) {
+ return false, "", nil
}
- return nil
+
+ log.Printf("Pulling image to check for updates: %s", imageRef)
+ if err := s.pullImageWithAuth(ctx, imageRef, settings); err != nil {
+ return false, "", fmt.Errorf("failed to pull image: %w", err)
+ }
+
+ newImageID, err := s.getImageID(ctx, imageRef)
+ if err != nil {
+ return false, "", fmt.Errorf("failed to get new image ID: %w", err)
+ }
+
+ hasUpdate := newImageID != currentImageID
+ if hasUpdate {
+ log.Printf("Update available for %s: %s -> %s", imageRef, currentImageID[:12], newImageID[:12])
+ }
+
+ return hasUpdate, newImageID, nil
}
-// pullStackImages pulls all images for a stack before redeployment
-func (s *AutoUpdateService) pullStackImages(ctx context.Context, stack models.Stack, settings *models.Settings) error {
+func (s *AutoUpdateService) checkStackImagesForUpdates(
+ ctx context.Context,
+ stack models.Stack,
+ settings *models.Settings,
+) (bool, map[string]string, error) {
composeContent, _, err := s.stackService.GetStackContent(ctx, stack.ID)
if err != nil {
- return fmt.Errorf("failed to get stack content: %w", err)
+ return false, nil, fmt.Errorf("failed to get stack content: %w", err)
}
imageRefs := s.extractImageReferences(composeContent)
if len(imageRefs) == 0 {
- return nil
+ return false, nil, nil
}
- log.Printf("Pulling %d images for stack %s", len(imageRefs), stack.Name)
+ hasUpdates := false
+ imageUpdates := make(map[string]string)
- for _, imageRef := range imageRefs {
+ for serviceName, imageRef := range imageRefs {
if s.isDigestBasedImage(imageRef) {
- log.Printf("Skipping digest-based image: %s", imageRef)
continue
}
- log.Printf("Pulling image: %s", imageRef)
- if err := s.pullImageWithAuth(ctx, imageRef, settings); err != nil {
- log.Printf("Warning: Failed to pull image %s: %v", imageRef, err)
+ currentID, _ := s.getImageID(ctx, imageRef)
+ hasUpdate, newID, err := s.checkImageForUpdate(ctx, imageRef, currentID, settings)
+ if err != nil {
+ log.Printf("Error checking image %s: %v", imageRef, err)
+ continue
+ }
+
+ if hasUpdate {
+ hasUpdates = true
+ imageUpdates[serviceName] = fmt.Sprintf("%s@%s", imageRef, newID)
}
}
- return nil
+ return hasUpdates, imageUpdates, nil
}
-// pullImageWithAuth pulls an image using appropriate registry credentials
func (s *AutoUpdateService) pullImageWithAuth(ctx context.Context, imageRef string, settings *models.Settings) error {
- registryHost := s.extractRegistryHost(imageRef)
- var authConfig *registry.AuthConfig
-
- registries, err := s.getEnabledRegistries(ctx)
- if err != nil {
- log.Printf("Warning: Failed to get registry credentials: %v", err)
- } else if len(registries) > 0 {
- for _, reg := range registries {
- if s.isRegistryMatch(reg.URL, registryHost) {
- decryptedToken, err := s.registryService.GetDecryptedToken(ctx, reg.ID)
- if err != nil {
- log.Printf("ERROR: Failed to decrypt token for registry %s: %v", reg.URL, err)
- continue
- }
-
- authConfig = &registry.AuthConfig{
- Username: reg.Username,
- Password: decryptedToken,
- ServerAddress: s.normalizeRegistryURL(reg.URL),
- }
- break
- }
- }
- }
-
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
return fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
+ authConfig, err := s.getAuthConfigForImage(ctx, imageRef)
+ if err != nil {
+ log.Printf("Failed to get auth config for %s: %v", imageRef, err)
+ }
+
pullOptions := image.PullOptions{}
if authConfig != nil {
- authBytes, err := json.Marshal(authConfig)
- if err != nil {
- return fmt.Errorf("failed to marshal auth config: %w", err)
- }
- pullOptions.RegistryAuth = base64.URLEncoding.EncodeToString(authBytes)
+ authJSON, _ := json.Marshal(authConfig)
+ pullOptions.RegistryAuth = base64.URLEncoding.EncodeToString(authJSON)
}
reader, err := dockerClient.ImagePull(ctx, imageRef, pullOptions)
if err != nil {
- switch {
- case strings.Contains(err.Error(), "not found"):
- return fmt.Errorf("image not found: %s - please verify the image exists and you have access", imageRef)
- case strings.Contains(err.Error(), "unauthorized"):
- return fmt.Errorf("authentication failed for %s - please verify your credentials", imageRef)
- case strings.Contains(err.Error(), "denied"):
- return fmt.Errorf("access denied for %s - please verify your permissions", imageRef)
- default:
- return fmt.Errorf("failed to pull image %s: %w", imageRef, err)
- }
+ return err
}
defer reader.Close()
- if err := s.consumeDockerResponse(reader); err != nil {
- return fmt.Errorf("error during image pull: %w", err)
- }
-
return nil
}
-// getEnabledRegistries gets enabled container registries from the database
-func (s *AutoUpdateService) getEnabledRegistries(ctx context.Context) ([]models.ContainerRegistry, error) {
- registries, err := s.registryService.GetEnabledRegistries(ctx)
+func (s *AutoUpdateService) getAuthConfigForImage(ctx context.Context, imageRef string) (*registry.AuthConfig, error) {
+ registryDomain := utils.ExtractRegistryDomain(imageRef)
+ normalizedImageDomain := s.normalizeRegistryURL(registryDomain)
+
+ registries, err := s.registryService.GetAllRegistries(ctx)
if err != nil {
- log.Printf("Failed to get registry credentials from database: %v", err)
- return []models.ContainerRegistry{}, nil
+ return nil, fmt.Errorf("failed to list registries: %w", err)
+ }
+
+ for _, reg := range registries {
+ normalizedRegURL := s.normalizeRegistryURL(reg.URL)
+ if normalizedRegURL == normalizedImageDomain {
+ return &registry.AuthConfig{
+ Username: reg.Username,
+ Password: reg.Token,
+ }, nil
+ }
}
- return registries, nil
+ return nil, nil
}
-// consumeDockerResponse consumes the Docker API response stream
-func (s *AutoUpdateService) consumeDockerResponse(reader io.ReadCloser) error {
- scanner := bufio.NewScanner(reader)
- for scanner.Scan() {
- var response map[string]interface{}
- if err := json.Unmarshal(scanner.Bytes(), &response); err != nil {
- continue
- }
+func (s *AutoUpdateService) normalizeRegistryURL(url string) string {
+ url = strings.TrimSpace(url)
+ url = strings.ToLower(url)
- if errorMsg, exists := response["error"]; exists {
- return fmt.Errorf("docker operation failed: %v", errorMsg)
- }
+ url = strings.TrimPrefix(url, "https://")
+ url = strings.TrimPrefix(url, "http://")
+
+ url = strings.TrimSuffix(url, "/")
+
+ if url == "docker.io" || url == "registry-1.docker.io" {
+ return "docker.io"
}
- return scanner.Err()
+ return url
}
-// checkContainerForUpdate checks if a container has an image update available
-func (s *AutoUpdateService) checkContainerForUpdate(ctx context.Context, container container.Summary, settings *models.Settings) (bool, error) {
- containerName := s.getContainerName(container)
-
+func (s *AutoUpdateService) getImageID(ctx context.Context, imageRef string) (string, error) {
dockerClient, err := s.dockerService.CreateConnection(ctx)
if err != nil {
- return false, fmt.Errorf("failed to connect to Docker: %w", err)
+ return "", fmt.Errorf("failed to connect to Docker: %w", err)
}
defer dockerClient.Close()
- containerJSON, err := dockerClient.ContainerInspect(ctx, container.ID)
+ imageInfo, _, err := dockerClient.ImageInspectWithRaw(ctx, imageRef)
if err != nil {
- return false, fmt.Errorf("failed to inspect container: %w", err)
+ return "", fmt.Errorf("failed to inspect image: %w", err)
}
- imageRef := containerJSON.Config.Image
- log.Printf("Container %s is using image: %s", containerName, imageRef)
+ return imageInfo.ID, nil
+}
- if s.isDigestBasedImage(imageRef) {
- log.Printf("Skipping digest-based image for container %s: %s", containerName, imageRef)
- return false, nil
+func (s *AutoUpdateService) isContainerEligibleForUpdate(cnt container.Summary) bool {
+ if cnt.State != "running" {
+ return false
}
- currentImageID := container.ImageID
- log.Printf("Container %s current image ID: %s", containerName, currentImageID)
-
- log.Printf("Pulling same tag for container %s: %s", containerName, imageRef)
- if err := s.pullImageWithAuth(ctx, imageRef, settings); err != nil {
- return false, fmt.Errorf("failed to pull image %s: %w", imageRef, err)
+ if s.isPartOfStack(cnt.Labels) {
+ return false
}
- newImageID, err := s.getImageID(ctx, imageRef)
- if err != nil {
- return false, fmt.Errorf("failed to get image ID after pull: %w", err)
- }
+ return s.hasAutoUpdateLabel(cnt.Labels)
+}
- log.Printf("Container %s after pull image ID: %s", containerName, newImageID)
+func (s *AutoUpdateService) isStackEligibleForUpdate(ctx context.Context, stack models.Stack) bool {
+ if stack.Status != models.StackStatusRunning && stack.Status != models.StackStatusPartiallyRunning {
+ return false
+ }
- hasUpdate := newImageID != currentImageID
- if hasUpdate {
- log.Printf("Update detected for container %s: %s -> %s (same tag: %s)", containerName, currentImageID, newImageID, imageRef)
- } else {
- log.Printf("Container %s is up-to-date (tag: %s)", containerName, imageRef)
+ eligible, err := s.stackHasAutoUpdateLabel(ctx, stack)
+ if err != nil {
+ log.Printf("Error checking stack eligibility: %v", err)
+ return false
}
- return hasUpdate, nil
+ return eligible
}
-// checkStackForUpdate checks if a stack has any image updates available
-func (s *AutoUpdateService) checkStackForUpdate(ctx context.Context, stack models.Stack, settings *models.Settings) (bool, error) {
+func (s *AutoUpdateService) stackHasAutoUpdateLabel(ctx context.Context, stack models.Stack) (bool, error) {
composeContent, _, err := s.stackService.GetStackContent(ctx, stack.ID)
if err != nil {
- return false, fmt.Errorf("failed to get stack content: %w", err)
+ return false, err
}
- if composeContent == "" {
- return false, fmt.Errorf("stack has no compose content")
+ var composeData map[string]interface{}
+ if err := yaml.Unmarshal([]byte(composeContent), &composeData); err != nil {
+ return false, err
}
- imageRefs := s.extractImageReferences(composeContent)
- if len(imageRefs) == 0 {
- log.Printf("No images found in stack %s", stack.Name)
+ services, ok := composeData["services"].(map[string]interface{})
+ if !ok {
return false, nil
}
- log.Printf("Checking %d images for stack %s", len(imageRefs), stack.Name)
-
- for _, imageRef := range imageRefs {
- if s.isDigestBasedImage(imageRef) {
- log.Printf("Skipping digest-based image in stack %s: %s", stack.Name, imageRef)
- continue
- }
-
- hasUpdate, err := s.checkImageForUpdate(ctx, imageRef, settings)
- if err != nil {
- log.Printf("Error checking image %s in stack %s: %v", imageRef, stack.Name, err)
- continue
- }
-
- if hasUpdate {
- log.Printf("Update found for image %s in stack %s", imageRef, stack.Name)
+ for _, service := range services {
+ if s.serviceHasAutoUpdateLabel(service) {
return true, nil
}
}
@@ -650,128 +624,136 @@ func (s *AutoUpdateService) checkStackForUpdate(ctx context.Context, stack model
return false, nil
}
-// checkImageForUpdate checks if a single image has an update available
-func (s *AutoUpdateService) checkImageForUpdate(ctx context.Context, imageRef string, settings *models.Settings) (bool, error) {
- currentImageID, err := s.getImageID(ctx, imageRef)
- if err != nil {
- log.Printf("Image %s not found locally, considering as new", imageRef)
- currentImageID = ""
+func (s *AutoUpdateService) serviceHasAutoUpdateLabel(service interface{}) bool {
+ serviceMap, ok := service.(map[string]interface{})
+ if !ok {
+ return false
}
- log.Printf("Pulling image: %s", imageRef)
- if err := s.pullImageWithAuth(ctx, imageRef, settings); err != nil {
- return false, fmt.Errorf("failed to pull image %s: %w", imageRef, err)
+ labels, ok := serviceMap["labels"].(map[string]interface{})
+ if !ok {
+ if labelsList, ok := serviceMap["labels"].([]interface{}); ok {
+ for _, label := range labelsList {
+ if labelStr, ok := label.(string); ok {
+ if strings.HasPrefix(labelStr, "arcane.auto-update=") && strings.Contains(labelStr, "true") {
+ return true
+ }
+ }
+ }
+ }
+ return false
}
- newImageID, err := s.getImageID(ctx, imageRef)
- if err != nil {
- return false, fmt.Errorf("failed to get image ID after pull: %w", err)
+ if autoUpdate, exists := labels["arcane.auto-update"]; exists {
+ if autoUpdateStr, ok := autoUpdate.(string); ok {
+ return strings.ToLower(autoUpdateStr) == "true"
+ }
}
- if currentImageID == "" {
- log.Printf("New image pulled: %s", imageRef)
- return true, nil
- }
+ return false
+}
- hasUpdate := newImageID != currentImageID
- if hasUpdate {
- log.Printf("Image updated: %s (%s -> %s)", imageRef, currentImageID, newImageID)
+func (s *AutoUpdateService) recordAutoUpdate(ctx context.Context, result dto.AutoUpdateResourceResult) error {
+ record := &models.AutoUpdateRecord{
+ ID: uuid.New().String(),
+ ResourceID: result.ResourceID,
+ ResourceType: result.ResourceType,
+ ResourceName: result.ResourceName,
+ Status: models.AutoUpdateStatus(result.Status),
+ StartTime: time.Now(),
+ UpdateAvailable: result.UpdateAvailable,
+ UpdateApplied: result.UpdateApplied,
}
- return hasUpdate, nil
-}
-
-// hasAutoUpdateLabel checks if labels contain auto-update flag
-func (s *AutoUpdateService) hasAutoUpdateLabel(labels map[string]string) bool {
- if labels == nil {
- return false
+ if result.Error != "" {
+ record.Error = &result.Error
}
- value, exists := labels["arcane.auto-update"]
- return exists && value == "true"
-}
+ if len(result.OldImages) > 0 {
+ oldImagesJSON := make(models.JSON)
+ for k, v := range result.OldImages {
+ oldImagesJSON[k] = v
+ }
+ record.OldImageVersions = oldImagesJSON
+ }
-// isStackEligibleForAutoUpdate checks if a stack is eligible for auto-update
-func (s *AutoUpdateService) isStackEligibleForAutoUpdate(ctx context.Context, stack models.Stack) (bool, error) {
- composeContent, _, err := s.stackService.GetStackContent(ctx, stack.ID)
- if err != nil {
- return false, fmt.Errorf("failed to get stack content: %w", err)
+ if len(result.NewImages) > 0 {
+ newImagesJSON := make(models.JSON)
+ for k, v := range result.NewImages {
+ newImagesJSON[k] = v
+ }
+ record.NewImageVersions = newImagesJSON
}
- if composeContent == "" {
- return false, nil
+ if len(result.Details) > 0 {
+ detailsJSON := make(models.JSON)
+ for k, v := range result.Details {
+ detailsJSON[k] = v
+ }
+ record.Details = detailsJSON
}
- var composeData map[string]interface{}
- if err := yaml.Unmarshal([]byte(composeContent), &composeData); err != nil {
- return false, fmt.Errorf("failed to parse compose file: %w", err)
+ endTime := time.Now()
+ record.EndTime = &endTime
+
+ if err := s.db.WithContext(ctx).Create(record).Error; err != nil {
+ return fmt.Errorf("failed to record auto-update: %w", err)
}
- services, ok := composeData["services"].(map[string]interface{})
- if !ok {
- return false, nil
+ return nil
+}
+
+func (s *AutoUpdateService) GetAutoUpdateHistory(ctx context.Context, limit int) ([]models.AutoUpdateRecord, error) {
+ var records []models.AutoUpdateRecord
+
+ query := s.db.WithContext(ctx).Order("start_time DESC")
+ if limit > 0 {
+ query = query.Limit(limit)
}
- for serviceName, service := range services {
- if s.serviceHasAutoUpdateLabel(service) {
- log.Printf("Found auto-update label in service %s of stack %s", serviceName, stack.Name)
- return true, nil
- }
+ if err := query.Find(&records).Error; err != nil {
+ return nil, fmt.Errorf("failed to get auto-update history: %w", err)
}
- return false, nil
+ return records, nil
}
-// serviceHasAutoUpdateLabel checks if a service has auto-update label
-func (s *AutoUpdateService) serviceHasAutoUpdateLabel(service interface{}) bool {
- serviceMap, ok := service.(map[string]interface{})
- if !ok {
- return false
- }
+func (s *AutoUpdateService) GetUpdateStatus() map[string]interface{} {
+ s.mutex.RLock()
+ defer s.mutex.RUnlock()
- labels, ok := serviceMap["labels"]
- if !ok {
- return false
+ containerIds := make([]string, 0, len(s.updatingContainers))
+ for id := range s.updatingContainers {
+ containerIds = append(containerIds, id)
}
- switch labelsType := labels.(type) {
- case []interface{}:
- for _, label := range labelsType {
- if labelStr, ok := label.(string); ok {
- if labelStr == "arcane.stack.auto-update=true" {
- return true
- }
- }
- }
- case map[string]interface{}:
- if value, exists := labelsType["arcane.stack.auto-update"]; exists {
- if valueStr, ok := value.(string); ok && valueStr == "true" {
- return true
- }
- if valueBool, ok := value.(bool); ok && valueBool {
- return true
- }
- }
+ stackIds := make([]string, 0, len(s.updatingStacks))
+ for id := range s.updatingStacks {
+ stackIds = append(stackIds, id)
}
- return false
+ return map[string]interface{}{
+ "updatingContainers": len(s.updatingContainers),
+ "updatingStacks": len(s.updatingStacks),
+ "containerIds": containerIds,
+ "stackIds": stackIds,
+ }
}
-// extractImageReferences extracts all image references from compose content
-func (s *AutoUpdateService) extractImageReferences(composeContent string) []string {
+func (s *AutoUpdateService) extractImageReferences(composeContent string) map[string]string {
+ images := make(map[string]string)
+
var composeData map[string]interface{}
if err := yaml.Unmarshal([]byte(composeContent), &composeData); err != nil {
- log.Printf("Error parsing compose content: %v", err)
- return []string{}
+ return images
}
- var images []string
services, ok := composeData["services"].(map[string]interface{})
if !ok {
return images
}
- for _, service := range services {
+ for serviceName, service := range services {
serviceMap, ok := service.(map[string]interface{})
if !ok {
continue
@@ -779,151 +761,76 @@ func (s *AutoUpdateService) extractImageReferences(composeContent string) []stri
if imageVal, exists := serviceMap["image"]; exists {
if imageStr, ok := imageVal.(string); ok {
- images = append(images, strings.TrimSpace(imageStr))
+ images[serviceName] = strings.TrimSpace(imageStr)
}
}
}
- return s.removeDuplicates(images)
+ return images
}
-// extractRegistryHost extracts the registry hostname from an image reference
-func (s *AutoUpdateService) extractRegistryHost(imageRef string) string {
- parts := strings.Split(imageRef, "@")
- if len(parts) > 1 {
- imageRef = parts[0]
- }
-
- parts = strings.Split(imageRef, ":")
- if len(parts) > 1 {
- imageRef = parts[0]
- }
-
- parts = strings.Split(imageRef, "/")
-
- if len(parts) == 1 {
+func (s *AutoUpdateService) extractRegistryDomain(imageRef string) string {
+ parts := strings.Split(imageRef, "/")
+ if len(parts) < 2 {
return "docker.io"
}
- firstPart := parts[0]
- if strings.Contains(firstPart, ".") || strings.Contains(firstPart, ":") {
- return firstPart
+ domain := parts[0]
+ if strings.Contains(domain, ".") || strings.Contains(domain, ":") {
+ return domain
}
return "docker.io"
}
-// isRegistryMatch checks if a credential URL matches a registry host
-func (s *AutoUpdateService) isRegistryMatch(credURL, registryHost string) bool {
- normalizedCred := s.normalizeRegistryForComparison(credURL)
- normalizedHost := s.normalizeRegistryForComparison(registryHost)
-
- return normalizedCred == normalizedHost
+func (s *AutoUpdateService) isDigestBasedImage(imageRef string) bool {
+ return strings.Contains(imageRef, "@sha256:")
}
-// normalizeRegistryForComparison normalizes registry URLs for comparison
-func (s *AutoUpdateService) normalizeRegistryForComparison(url string) string {
- url = strings.TrimPrefix(url, "https://")
- url = strings.TrimPrefix(url, "http://")
- url = strings.TrimSuffix(url, "/")
-
- if url == "docker.io" || url == "registry-1.docker.io" || url == "index.docker.io" {
- return "docker.io"
+func (s *AutoUpdateService) isPartOfStack(labels map[string]string) bool {
+ if labels == nil {
+ return false
}
- return url
-}
-
-// normalizeRegistryURL normalizes registry URL for Docker client
-func (s *AutoUpdateService) normalizeRegistryURL(url string) string {
- normalized := s.normalizeRegistryForComparison(url)
- if normalized == "docker.io" {
- return "https://index.docker.io/v1/"
+ if projectName, exists := labels["com.docker.compose.project"]; exists && projectName != "" {
+ return true
}
- // For other registries, return raw hostname without protocol
- result := strings.TrimPrefix(url, "https://")
- result = strings.TrimPrefix(result, "http://")
- result = strings.TrimSuffix(result, "/")
-
- return result
-}
+ if stackName, exists := labels["arcane.stack"]; exists && stackName != "" {
+ return true
+ }
-// isDigestBasedImage checks if an image reference uses a digest
-func (s *AutoUpdateService) isDigestBasedImage(imageRef string) bool {
- matched, _ := regexp.MatchString(`@sha256:[a-f0-9]{64}`, imageRef)
- return matched
+ return false
}
-// getImageID gets the ID of a local image
-func (s *AutoUpdateService) getImageID(ctx context.Context, imageRef string) (string, error) {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
- if err != nil {
- return "", fmt.Errorf("failed to connect to Docker: %w", err)
- }
- defer dockerClient.Close()
-
- images, err := dockerClient.ImageList(ctx, image.ListOptions{})
- if err != nil {
- return "", fmt.Errorf("failed to list images: %w", err)
+func (s *AutoUpdateService) hasAutoUpdateLabel(labels map[string]string) bool {
+ if labels == nil {
+ return false
}
- for _, img := range images {
- for _, tag := range img.RepoTags {
- if tag == imageRef {
- return img.ID, nil
- }
- }
+ if autoUpdate, exists := labels["arcane.auto-update"]; exists {
+ return strings.ToLower(autoUpdate) == "true"
}
- return "", fmt.Errorf("image not found: %s", imageRef)
+ return false
}
-// getContainerName gets a friendly name for a container
-func (s *AutoUpdateService) getContainerName(container container.Summary) string {
- if len(container.Names) > 0 {
- name := container.Names[0]
+func (s *AutoUpdateService) getContainerName(cnt container.Summary) string {
+ if len(cnt.Names) > 0 {
+ name := cnt.Names[0]
if strings.HasPrefix(name, "/") {
return name[1:]
}
return name
}
- return container.ID[:12]
+ return cnt.ID[:12]
}
-// removeDuplicates removes duplicate strings from a slice
-func (s *AutoUpdateService) removeDuplicates(items []string) []string {
- seen := make(map[string]bool)
- var result []string
-
- for _, item := range items {
- if !seen[item] {
- seen[item] = true
- result = append(result, item)
+func contains(slice []string, item string) bool {
+ for _, s := range slice {
+ if s == item {
+ return true
}
}
-
- return result
-}
-
-// GetUpdateStatus returns the current update status
-func (s *AutoUpdateService) GetUpdateStatus() map[string]interface{} {
- s.mutex.RLock()
- defer s.mutex.RUnlock()
-
- return map[string]interface{}{
- "updating_containers": len(s.updatingContainers),
- "updating_stacks": len(s.updatingStacks),
- "container_ids": s.getKeys(s.updatingContainers),
- "stack_ids": s.getKeys(s.updatingStacks),
- }
-}
-
-// getKeys returns the keys of a map
-func (s *AutoUpdateService) getKeys(m map[string]bool) []string {
- keys := make([]string, 0, len(m))
- for k := range m {
- keys = append(keys, k)
- }
- return keys
+ return false
}
diff --git a/backend/internal/services/container_registry_service.go b/backend/internal/services/container_registry_service.go
index 98a7e24ef..3776cd3f6 100644
--- a/backend/internal/services/container_registry_service.go
+++ b/backend/internal/services/container_registry_service.go
@@ -26,7 +26,7 @@ func generateID() string {
func (s *ContainerRegistryService) GetAllRegistries(ctx context.Context) ([]models.ContainerRegistry, error) {
var registries []models.ContainerRegistry
- if err := s.db.DB.WithContext(ctx).Find(&registries).Error; err != nil {
+ if err := s.db.WithContext(ctx).Find(&registries).Error; err != nil {
return nil, fmt.Errorf("failed to get container registries: %w", err)
}
return registries, nil
@@ -34,7 +34,7 @@ func (s *ContainerRegistryService) GetAllRegistries(ctx context.Context) ([]mode
func (s *ContainerRegistryService) GetRegistryByID(ctx context.Context, id string) (*models.ContainerRegistry, error) {
var registry models.ContainerRegistry
- if err := s.db.DB.WithContext(ctx).Where("id = ?", id).First(&registry).Error; err != nil {
+ if err := s.db.WithContext(ctx).Where("id = ?", id).First(&registry).Error; err != nil {
return nil, fmt.Errorf("failed to get container registry: %w", err)
}
return &registry, nil
@@ -67,7 +67,7 @@ func (s *ContainerRegistryService) CreateRegistry(ctx context.Context, req model
UpdatedAt: time.Now(),
}
- if err := s.db.DB.WithContext(ctx).Create(registry).Error; err != nil {
+ if err := s.db.WithContext(ctx).Create(registry).Error; err != nil {
return nil, fmt.Errorf("failed to create registry: %w", err)
}
@@ -107,7 +107,7 @@ func (s *ContainerRegistryService) UpdateRegistry(ctx context.Context, id string
registry.UpdatedAt = time.Now()
- if err := s.db.DB.WithContext(ctx).Save(registry).Error; err != nil {
+ if err := s.db.WithContext(ctx).Save(registry).Error; err != nil {
return nil, fmt.Errorf("failed to update registry: %w", err)
}
@@ -115,7 +115,7 @@ func (s *ContainerRegistryService) UpdateRegistry(ctx context.Context, id string
}
func (s *ContainerRegistryService) DeleteRegistry(ctx context.Context, id string) error {
- if err := s.db.DB.WithContext(ctx).Where("id = ?", id).Delete(&models.ContainerRegistry{}).Error; err != nil {
+ if err := s.db.WithContext(ctx).Where("id = ?", id).Delete(&models.ContainerRegistry{}).Error; err != nil {
return fmt.Errorf("failed to delete container registry: %w", err)
}
return nil
diff --git a/backend/internal/services/image_maturity_service.go b/backend/internal/services/image_maturity_service.go
index 4a3283d49..83ff10fe9 100644
--- a/backend/internal/services/image_maturity_service.go
+++ b/backend/internal/services/image_maturity_service.go
@@ -14,17 +14,20 @@ import (
"github.com/ofkm/arcane-backend/internal/database"
"github.com/ofkm/arcane-backend/internal/models"
"github.com/ofkm/arcane-backend/internal/utils"
+ "gorm.io/gorm"
)
type ImageMaturityService struct {
db *database.DB
settingsService *SettingsService
+ registryService *ContainerRegistryService
}
-func NewImageMaturityService(db *database.DB, settingsService *SettingsService) *ImageMaturityService {
+func NewImageMaturityService(db *database.DB, settingsService *SettingsService, registryService *ContainerRegistryService) *ImageMaturityService {
return &ImageMaturityService{
db: db,
settingsService: settingsService,
+ registryService: registryService,
}
}
@@ -36,7 +39,7 @@ func (s *ImageMaturityService) GetImageMaturity(ctx context.Context, imageID str
return &record, nil
}
-func (s *ImageMaturityService) CheckImageMaturity(ctx context.Context, imageID, repository, tag string, imageCreatedAt time.Time, registryCredentials *RegistryCredentials) (*models.ImageMaturity, error) {
+func (s *ImageMaturityService) CheckImageMaturity(ctx context.Context, imageID, repository, tag string, imageCreatedAt time.Time) (*models.ImageMaturity, error) {
settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get settings: %w", err)
@@ -54,7 +57,8 @@ func (s *ImageMaturityService) CheckImageMaturity(ctx context.Context, imageID,
latestVersion := ""
var checkError error
- registryManifest, err := s.getImageManifest(ctx, repository, tag, registryCredentials)
+ registry := s.getRegistryForImage(ctx, repository)
+ registryManifest, err := s.getImageManifest(ctx, repository, tag, registry)
if err != nil {
checkError = err
} else {
@@ -62,7 +66,7 @@ func (s *ImageMaturityService) CheckImageMaturity(ctx context.Context, imageID,
}
if checkError == nil && !s.isSpecialTag(tag) {
- allTags, err := s.getImageTags(ctx, repository, registryCredentials)
+ allTags, err := s.getImageTags(ctx, repository, registry)
if err == nil {
hasNewerVersions, newerVersion := s.hasNewerVersions(tag, allTags)
if hasNewerVersions {
@@ -72,7 +76,7 @@ func (s *ImageMaturityService) CheckImageMaturity(ctx context.Context, imageID,
}
}
- status := s.determineMaturityStatus(tag, isMaturedByAge, hasUpdates, checkError)
+ status := s.determineMaturityStatus(isMaturedByAge, hasUpdates, checkError)
maturity := &models.ImageMaturity{
Version: tag,
@@ -83,7 +87,7 @@ func (s *ImageMaturityService) CheckImageMaturity(ctx context.Context, imageID,
}
metadata := map[string]interface{}{
- "registryDomain": s.extractRegistryDomain(repository),
+ "registryDomain": utils.ExtractRegistryDomain(repository),
"isPrivateRegistry": s.isPrivateRegistry(repository),
"currentImageDate": imageCreatedAt,
"daysSinceCreation": int(imageAge.Hours() / 24),
@@ -158,7 +162,46 @@ func (s *ImageMaturityService) SetImageMaturity(ctx context.Context, imageID, re
return nil
}
-func (s *ImageMaturityService) getImageManifest(ctx context.Context, repository, tag string, credentials *RegistryCredentials) (*RegistryManifest, error) {
+func (s *ImageMaturityService) getRegistryForImage(ctx context.Context, repository string) *models.ContainerRegistry {
+ registryDomain := utils.ExtractRegistryDomain(repository)
+ normalizedImageDomain := s.normalizeRegistryURL(registryDomain)
+
+ registries, err := s.registryService.GetAllRegistries(ctx)
+ if err != nil {
+ return nil
+ }
+
+ for _, reg := range registries {
+ if !reg.Enabled {
+ continue
+ }
+
+ normalizedRegURL := s.normalizeRegistryURL(reg.URL)
+ if normalizedRegURL == normalizedImageDomain {
+ return &reg
+ }
+ }
+
+ return nil
+}
+
+func (s *ImageMaturityService) normalizeRegistryURL(url string) string {
+ url = strings.TrimSpace(url)
+ url = strings.ToLower(url)
+
+ url = strings.TrimPrefix(url, "https://")
+ url = strings.TrimPrefix(url, "http://")
+
+ url = strings.TrimSuffix(url, "/")
+
+ if url == "docker.io" || url == "registry-1.docker.io" || url == "index.docker.io" {
+ return "docker.io"
+ }
+
+ return url
+}
+
+func (s *ImageMaturityService) getImageManifest(ctx context.Context, repository, tag string, registry *models.ContainerRegistry) (*RegistryManifest, error) {
registryURL := s.buildRegistryURL(repository)
normalizedRepo := s.normalizeRepository(repository)
@@ -170,8 +213,8 @@ func (s *ImageMaturityService) getImageManifest(ctx context.Context, repository,
return nil, fmt.Errorf("failed to create manifest request: %w", err)
}
- if credentials != nil {
- token, err := s.getRegistryToken(ctx, repository, credentials)
+ if registry != nil {
+ token, err := s.getRegistryToken(ctx, repository, registry)
if err == nil && token != "" {
req.Header.Set("Authorization", "Bearer "+token)
}
@@ -215,7 +258,7 @@ func (s *ImageMaturityService) getImageManifest(ctx context.Context, repository,
}, nil
}
-func (s *ImageMaturityService) getImageTags(ctx context.Context, repository string, credentials *RegistryCredentials) ([]string, error) {
+func (s *ImageMaturityService) getImageTags(ctx context.Context, repository string, registry *models.ContainerRegistry) ([]string, error) {
registryURL := s.buildRegistryURL(repository)
normalizedRepo := s.normalizeRepository(repository)
@@ -227,8 +270,8 @@ func (s *ImageMaturityService) getImageTags(ctx context.Context, repository stri
return nil, fmt.Errorf("failed to create tags request: %w", err)
}
- if credentials != nil {
- token, err := s.getRegistryToken(ctx, repository, credentials)
+ if registry != nil {
+ token, err := s.getRegistryToken(ctx, repository, registry)
if err == nil && token != "" {
req.Header.Set("Authorization", "Bearer "+token)
}
@@ -254,17 +297,17 @@ func (s *ImageMaturityService) getImageTags(ctx context.Context, repository stri
return tagsResp.Tags, nil
}
-func (s *ImageMaturityService) getRegistryToken(ctx context.Context, repository string, credentials *RegistryCredentials) (string, error) {
+func (s *ImageMaturityService) getRegistryToken(ctx context.Context, repository string, registry *models.ContainerRegistry) (string, error) {
domain := s.extractRegistryDomain(repository)
switch domain {
case "docker.io", "registry-1.docker.io", "index.docker.io":
return utils.GetDockerHubToken(ctx, repository)
default:
- if credentials != nil {
+ if registry != nil {
creds := &utils.RegistryCredentials{
- Username: credentials.Username,
- Token: credentials.Password,
+ Username: registry.Username,
+ Token: registry.Token,
}
return utils.GetRegistryToken(ctx, domain, repository, creds)
}
@@ -273,35 +316,36 @@ func (s *ImageMaturityService) getRegistryToken(ctx context.Context, repository
}
func (s *ImageMaturityService) buildRegistryURL(repository string) string {
- domain := s.extractRegistryDomain(repository)
+ domain := utils.ExtractRegistryDomain(repository)
- switch domain {
- case "docker.io", "index.docker.io":
+ if domain == "docker.io" {
return "https://registry-1.docker.io"
- case "registry-1.docker.io":
- return "https://registry-1.docker.io"
- default:
- if strings.HasPrefix(domain, "http://") || strings.HasPrefix(domain, "https://") {
- return domain
- }
+ }
+
+ if !strings.HasPrefix(domain, "http") {
return "https://" + domain
}
+
+ return domain
}
func (s *ImageMaturityService) normalizeRepository(repository string) string {
- parts := strings.Split(repository, "/")
+ domain := utils.ExtractRegistryDomain(repository)
- if s.extractRegistryDomain(repository) == "docker.io" || s.extractRegistryDomain(repository) == "registry-1.docker.io" {
- repoWithoutRegistry := strings.TrimPrefix(repository, s.extractRegistryDomain(repository)+"/")
- if !strings.Contains(repoWithoutRegistry, "/") {
- return "library/" + repoWithoutRegistry
+ if domain == "docker.io" {
+ if !strings.Contains(repository, "/") {
+ return "library/" + repository
}
- return repoWithoutRegistry
- }
- if len(parts) > 1 {
- return strings.Join(parts[1:], "/")
+ if utils.ExtractRegistryDomain(repository) == "docker.io" || utils.ExtractRegistryDomain(repository) == "registry-1.docker.io" {
+ repoWithoutRegistry := strings.TrimPrefix(repository, utils.ExtractRegistryDomain(repository)+"/")
+ if !strings.Contains(repoWithoutRegistry, "/") {
+ return "library/" + repoWithoutRegistry
+ }
+ return repoWithoutRegistry
+ }
}
+
return repository
}
@@ -321,7 +365,7 @@ func (s *ImageMaturityService) extractRegistryDomain(repository string) string {
}
func (s *ImageMaturityService) isPrivateRegistry(repository string) bool {
- domain := s.extractRegistryDomain(repository)
+ domain := utils.ExtractRegistryDomain(repository)
publicRegistries := []string{"docker.io", "registry-1.docker.io", "index.docker.io", "ghcr.io", "quay.io", "gcr.io"}
for _, public := range publicRegistries {
@@ -372,7 +416,7 @@ func (s *ImageMaturityService) hasNewerVersions(currentTag string, allTags []str
return hasNewer, newestTag
}
-func (s *ImageMaturityService) determineMaturityStatus(tag string, isMaturedByAge, hasUpdates bool, checkError error) string {
+func (s *ImageMaturityService) determineMaturityStatus(isMaturedByAge, hasUpdates bool, checkError error) string {
if checkError != nil {
if isMaturedByAge {
return models.ImageStatusMatured
@@ -500,7 +544,7 @@ func (s *ImageMaturityService) ProcessImagesForMaturityCheck(ctx context.Context
tag := parts[1]
imageCreatedAt := time.Unix(img.Created, 0)
- _, err := s.CheckImageMaturity(ctx, img.ID, repo, tag, imageCreatedAt, nil)
+ _, err := s.CheckImageMaturity(ctx, img.ID, repo, tag, imageCreatedAt)
if err != nil {
continue
}
@@ -613,19 +657,18 @@ func (s *ImageMaturityService) UpdateCheckStatus(ctx context.Context, imageID st
}
func (s *ImageMaturityService) CleanupOrphanedRecords(ctx context.Context, existingImageIDs []string) (int64, error) {
- var result any
+ var result *gorm.DB
if len(existingImageIDs) == 0 {
result = s.db.WithContext(ctx).Delete(&models.ImageMaturityRecord{})
} else {
result = s.db.WithContext(ctx).Where("id NOT IN ?", existingImageIDs).Delete(&models.ImageMaturityRecord{})
}
- dbResult := result.(*database.DB)
- if dbResult.Error != nil {
- return 0, fmt.Errorf("failed to cleanup orphaned records: %w", dbResult.Error)
+ if result.Error != nil {
+ return 0, fmt.Errorf("failed to cleanup orphaned records: %w", result.Error)
}
- return dbResult.RowsAffected, nil
+ return result.RowsAffected, nil
}
func (s *ImageMaturityService) CheckMaturityBatch(ctx context.Context, imageIDs []string) (map[string]interface{}, error) {
diff --git a/backend/internal/services/stack_service.go b/backend/internal/services/stack_service.go
index 3a3b43eda..09df8165a 100644
--- a/backend/internal/services/stack_service.go
+++ b/backend/internal/services/stack_service.go
@@ -82,12 +82,12 @@ func (s *StackService) CreateStack(ctx context.Context, name, composeContent str
RunningCount: 0,
}
- if err := s.db.DB.WithContext(ctx).Create(stack).Error; err != nil {
+ if err := s.db.WithContext(ctx).Create(stack).Error; err != nil {
return nil, fmt.Errorf("failed to create stack: %w", err)
}
if err := s.saveStackFiles(stackPath, composeContent, envContent); err != nil {
- s.db.DB.WithContext(ctx).Delete(stack)
+ s.db.WithContext(ctx).Delete(stack)
return nil, fmt.Errorf("failed to save stack files: %w", err)
}
@@ -400,14 +400,14 @@ func (s *StackService) PullStackImages(ctx context.Context, stackID string) erro
func (s *StackService) ListStacks(ctx context.Context) ([]models.Stack, error) {
var stacks []models.Stack
- if err := s.db.DB.WithContext(ctx).Find(&stacks).Error; err != nil {
+ if err := s.db.WithContext(ctx).Find(&stacks).Error; err != nil {
return nil, fmt.Errorf("failed to get stacks: %w", err)
}
return stacks, nil
}
func (s *StackService) UpdateStack(ctx context.Context, stack *models.Stack) (*models.Stack, error) {
- if err := s.db.DB.WithContext(ctx).Save(stack).Error; err != nil {
+ if err := s.db.WithContext(ctx).Save(stack).Error; err != nil {
return nil, fmt.Errorf("failed to update stack: %w", err)
}
return stack, nil
@@ -481,7 +481,7 @@ func (s *StackService) DeleteStack(ctx context.Context, stackID string) error {
}
}
- if err := s.db.DB.WithContext(ctx).Delete(stack).Error; err != nil {
+ if err := s.db.WithContext(ctx).Delete(stack).Error; err != nil {
return fmt.Errorf("failed to delete stack from database: %w", err)
}
@@ -514,7 +514,7 @@ func (s *StackService) DestroyStack(ctx context.Context, stackID string, removeF
}
}
- if err := s.db.DB.WithContext(ctx).Delete(stack).Error; err != nil {
+ if err := s.db.WithContext(ctx).Delete(stack).Error; err != nil {
return fmt.Errorf("failed to delete stack from database: %w", err)
}
@@ -561,7 +561,7 @@ func (s *StackService) DiscoverExternalStacks(ctx context.Context) ([]models.Sta
continue
}
var count int64
- s.db.DB.WithContext(ctx).
+ s.db.WithContext(ctx).
Model(&models.Stack{}).
Where("path = ?", path).
Or("dir_name = ?", name).
@@ -603,7 +603,7 @@ func (s *StackService) ImportExternalStack(ctx context.Context, dirName, stackNa
ServiceCount: 0,
RunningCount: 0,
}
- if err := s.db.DB.WithContext(ctx).Create(stack).Error; err != nil {
+ if err := s.db.WithContext(ctx).Create(stack).Error; err != nil {
return nil, fmt.Errorf("failed to import stack: %w", err)
}
return stack, nil
@@ -778,7 +778,7 @@ func (s *StackService) ConvertDockerRun(ctx context.Context, dockerRunCommand st
func (s *StackService) GetStackByID(ctx context.Context, id string) (*models.Stack, error) {
var stack models.Stack
- if err := s.db.DB.WithContext(ctx).Where("id = ?", id).First(&stack).Error; err != nil {
+ if err := s.db.WithContext(ctx).Where("id = ?", id).First(&stack).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fmt.Errorf("stack not found")
}
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 57be8056c..51c3cb185 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -12,6 +12,7 @@
"@codemirror/legacy-modes": "^6.5.1",
"@sveltejs/adapter-static": "^3.0.8",
"@tanstack/table-core": "^8.21.3",
+ "@uiw/codemirror-theme-github": "^4.23.14",
"axios": "^1.10.0",
"codemirror": "^6.0.2",
"date-fns": "^4.1.0",
@@ -19,38 +20,39 @@
"prettier": "^3.5.3",
"prettier-plugin-svelte": "^3.4.0",
"prettier-plugin-tailwindcss": "^0.6.13",
- "runed": "^0.29.0",
- "svelte-codemirror-editor": "^1.4.1",
- "thememirror": "^2.0.1"
+ "svelte-codemirror-editor": "^1.4.1"
},
"devDependencies": {
"@eslint/compat": "^1.3.0",
"@eslint/js": "^9.29.0",
- "@lucide/svelte": "^0.522.0",
+ "@lucide/svelte": "^0.525.0",
"@playwright/test": "^1.52.0",
- "@sveltejs/kit": "^2.22.0",
+ "@sveltejs/kit": "^2.22.2",
"@sveltejs/vite-plugin-svelte": "^5.1.0",
"@tailwindcss/vite": "^4.1.10",
- "@types/dockerode": "^3.3.40",
+ "@types/dockerode": "^3.3.42",
"@types/js-yaml": "^4.0.9",
- "bits-ui": "^2.8.8",
+ "bits-ui": "^2.8.10",
"clsx": "^2.1.1",
"eslint": "^9.28.0",
"eslint-plugin-svelte": "^3.9.1",
"formsnap": "^2.0.1",
"globals": "^16.2.0",
+ "isomorphic-dompurify": "^2.25.0",
"mode-watcher": "^1.0.8",
"paneforge": "^1.0.0-next.5",
- "svelte": "5.34.7",
+ "runed": "^0.29.1",
+ "svelte": "^5.34.7",
"svelte-check": "^4.2.2",
"svelte-sonner": "^1.0.5",
+ "svelte-toolbelt": "^0.9.3",
"sveltekit-superforms": "^2.27.0",
"tailwind-merge": "^3.3.1",
"tailwind-variants": "^1.0.0",
- "tailwindcss": "^4.1.7",
+ "tailwindcss": "^4.1.11",
"tsx": "^4.20.3",
"tw-animate-css": "^1.3.4",
- "typescript": "^5.8.0",
+ "typescript": "^5.8.3",
"typescript-eslint": "^8.34.1",
"vite": "^6.3.5",
"zod": "^3.25.67"
@@ -88,6 +90,20 @@
"license": "MIT",
"optional": true
},
+ "node_modules/@asamuzakjp/css-color": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-3.2.0.tgz",
+ "integrity": "sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@csstools/css-calc": "^2.1.3",
+ "@csstools/css-color-parser": "^3.0.9",
+ "@csstools/css-parser-algorithms": "^3.0.4",
+ "@csstools/css-tokenizer": "^3.0.3",
+ "lru-cache": "^10.4.3"
+ }
+ },
"node_modules/@babel/runtime": {
"version": "7.27.1",
"resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz",
@@ -203,6 +219,121 @@
"w3c-keyname": "^2.2.4"
}
},
+ "node_modules/@csstools/color-helpers": {
+ "version": "5.0.2",
+ "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.0.2.tgz",
+ "integrity": "sha512-JqWH1vsgdGcw2RR6VliXXdA0/59LttzlU8UlRT/iUUsEeWfYq8I+K0yhihEUTTHLRm1EXvpsCx3083EU15ecsA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT-0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@csstools/css-calc": {
+ "version": "2.1.4",
+ "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+ "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "peerDependencies": {
+ "@csstools/css-parser-algorithms": "^3.0.5",
+ "@csstools/css-tokenizer": "^3.0.4"
+ }
+ },
+ "node_modules/@csstools/css-color-parser": {
+ "version": "3.0.10",
+ "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.0.10.tgz",
+ "integrity": "sha512-TiJ5Ajr6WRd1r8HSiwJvZBiJOqtH86aHpUjq5aEKWHiII2Qfjqd/HCWKPOW8EP4vcspXbHnXrwIDlu5savQipg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "@csstools/color-helpers": "^5.0.2",
+ "@csstools/css-calc": "^2.1.4"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "peerDependencies": {
+ "@csstools/css-parser-algorithms": "^3.0.5",
+ "@csstools/css-tokenizer": "^3.0.4"
+ }
+ },
+ "node_modules/@csstools/css-parser-algorithms": {
+ "version": "3.0.5",
+ "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+ "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "peerDependencies": {
+ "@csstools/css-tokenizer": "^3.0.4"
+ }
+ },
+ "node_modules/@csstools/css-tokenizer": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+ "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/csstools"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/csstools"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/@esbuild/aix-ppc64": {
"version": "0.25.4",
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.4.tgz",
@@ -1037,9 +1168,9 @@
}
},
"node_modules/@lucide/svelte": {
- "version": "0.522.0",
- "resolved": "https://registry.npmjs.org/@lucide/svelte/-/svelte-0.522.0.tgz",
- "integrity": "sha512-Q10WkheTfb0sZ6y+EQVTqW4DN8nD2mym00gVpinbe3dJWRW3/R7SeTGF9pW+Ux4PrzkNV9dUdUTWcbO/AdKwQQ==",
+ "version": "0.525.0",
+ "resolved": "https://registry.npmjs.org/@lucide/svelte/-/svelte-0.525.0.tgz",
+ "integrity": "sha512-dyUxkXzepagLUzL8jHQNdeH286nC66ClLACsg+Neu/bjkRJWPWMzkT+H0DKlE70QdkicGCfs1ZGmXCc351hmZA==",
"dev": true,
"license": "ISC",
"peerDependencies": {
@@ -1445,9 +1576,9 @@
}
},
"node_modules/@sveltejs/kit": {
- "version": "2.22.0",
- "resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.22.0.tgz",
- "integrity": "sha512-DJm0UxVgzXq+1MUfiJK4Ridk7oIQsIets6JwHiEl97sI6nXScfXe+BeqNhzB7jQIVBb3BM51U4hNk8qQxRXBAA==",
+ "version": "2.22.2",
+ "resolved": "https://registry.npmjs.org/@sveltejs/kit/-/kit-2.22.2.tgz",
+ "integrity": "sha512-2MvEpSYabUrsJAoq5qCOBGAlkICjfjunrnLcx3YAk2XV7TvAIhomlKsAgR4H/4uns5rAfYmj7Wet5KRtc8dPIg==",
"license": "MIT",
"dependencies": {
"@sveltejs/acorn-typescript": "^1.0.5",
@@ -1541,6 +1672,13 @@
"tailwindcss": "4.1.10"
}
},
+ "node_modules/@tailwindcss/node/node_modules/tailwindcss": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.10.tgz",
+ "integrity": "sha512-P3nr6WkvKV/ONsTzj6Gb57sWPMX29EPNPopo7+FcpkQaNsrNpZ1pv8QmrYI2RqEKD7mlGqLnGovlcYnBK0IqUA==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/@tailwindcss/oxide": {
"version": "4.1.10",
"resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.1.10.tgz",
@@ -1802,6 +1940,13 @@
"vite": "^5.2.0 || ^6"
}
},
+ "node_modules/@tailwindcss/vite/node_modules/tailwindcss": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.10.tgz",
+ "integrity": "sha512-P3nr6WkvKV/ONsTzj6Gb57sWPMX29EPNPopo7+FcpkQaNsrNpZ1pv8QmrYI2RqEKD7mlGqLnGovlcYnBK0IqUA==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/@tanstack/table-core": {
"version": "8.21.3",
"resolved": "https://registry.npmjs.org/@tanstack/table-core/-/table-core-8.21.3.tgz",
@@ -1833,9 +1978,9 @@
}
},
"node_modules/@types/dockerode": {
- "version": "3.3.40",
- "resolved": "https://registry.npmjs.org/@types/dockerode/-/dockerode-3.3.40.tgz",
- "integrity": "sha512-O1ckSFYbcYv/KcnAHMLCnKQYY8/5+6CRzpsOPcQIePHRX2jG4Gmz8uXPMCXIxTGN9OYkE5eox/L67l2sGY1UYg==",
+ "version": "3.3.42",
+ "resolved": "https://registry.npmjs.org/@types/dockerode/-/dockerode-3.3.42.tgz",
+ "integrity": "sha512-U1jqHMShibMEWHdxYhj3rCMNCiLx5f35i4e3CEUuW+JSSszc/tVqc6WCAPdhwBymG5R/vgbcceagK0St7Cq6Eg==",
"dev": true,
"license": "MIT",
"dependencies": {
@@ -1901,6 +2046,14 @@
"dev": true,
"license": "MIT"
},
+ "node_modules/@types/trusted-types": {
+ "version": "2.0.7",
+ "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+ "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
"node_modules/@types/validator": {
"version": "13.15.1",
"resolved": "https://registry.npmjs.org/@types/validator/-/validator-13.15.1.tgz",
@@ -2201,6 +2354,37 @@
"url": "https://opencollective.com/typescript-eslint"
}
},
+ "node_modules/@uiw/codemirror-theme-github": {
+ "version": "4.23.14",
+ "resolved": "https://registry.npmjs.org/@uiw/codemirror-theme-github/-/codemirror-theme-github-4.23.14.tgz",
+ "integrity": "sha512-D7zIfRG+SyYqDWw2tYx46i81VVIc6hllj67++jg8jexhSVG1/UFBSumCxm9ssJRY4Q0P/0qv8t0rHQl0bkerVQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@uiw/codemirror-themes": "4.23.14"
+ },
+ "funding": {
+ "url": "https://jaywcjlove.github.io/#/sponsor"
+ }
+ },
+ "node_modules/@uiw/codemirror-themes": {
+ "version": "4.23.14",
+ "resolved": "https://registry.npmjs.org/@uiw/codemirror-themes/-/codemirror-themes-4.23.14.tgz",
+ "integrity": "sha512-VoctEjY2fDOzTb0gSNRB8VcTbt11azUKLJzxXC/s4YNgz59C9i4X5vM99NgQAnEQ9vWaUBDgkmfkt1JiHBD++A==",
+ "license": "MIT",
+ "dependencies": {
+ "@codemirror/language": "^6.0.0",
+ "@codemirror/state": "^6.0.0",
+ "@codemirror/view": "^6.0.0"
+ },
+ "funding": {
+ "url": "https://jaywcjlove.github.io/#/sponsor"
+ },
+ "peerDependencies": {
+ "@codemirror/language": ">=6.0.0",
+ "@codemirror/state": ">=6.0.0",
+ "@codemirror/view": ">=6.0.0"
+ }
+ },
"node_modules/@vinejs/compiler": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/@vinejs/compiler/-/compiler-3.0.0.tgz",
@@ -2255,6 +2439,16 @@
"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
}
},
+ "node_modules/agent-base": {
+ "version": "7.1.3",
+ "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
+ "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 14"
+ }
+ },
"node_modules/ajv": {
"version": "6.12.6",
"resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
@@ -2349,17 +2543,17 @@
"license": "MIT"
},
"node_modules/bits-ui": {
- "version": "2.8.8",
- "resolved": "https://registry.npmjs.org/bits-ui/-/bits-ui-2.8.8.tgz",
- "integrity": "sha512-SFBFztROZf04e/zUsOlsbm4l6Nn5rBKAXS1nTWYJDxgbcFA+8DtjlZgbr03oFEkTcVZ5GAmLDIjbZ/KNg5GFxw==",
+ "version": "2.8.10",
+ "resolved": "https://registry.npmjs.org/bits-ui/-/bits-ui-2.8.10.tgz",
+ "integrity": "sha512-MOobkqapDZNrpcNmeL2g664xFmH4tZBOKBTxFmsQYMZQuybSZHQnPXy+AjM5XZEXRmCFx5+XRmo6+fC3vHh1hQ==",
"dev": true,
"license": "MIT",
"dependencies": {
"@floating-ui/core": "^1.7.1",
"@floating-ui/dom": "^1.7.1",
"esm-env": "^1.1.2",
- "runed": "^0.28.0",
- "svelte-toolbelt": "^0.9.2",
+ "runed": "^0.29.1",
+ "svelte-toolbelt": "^0.9.3",
"tabbable": "^6.2.0"
},
"engines": {
@@ -2373,44 +2567,6 @@
"svelte": "^5.33.0"
}
},
- "node_modules/bits-ui/node_modules/runed": {
- "version": "0.28.0",
- "resolved": "https://registry.npmjs.org/runed/-/runed-0.28.0.tgz",
- "integrity": "sha512-k2xx7RuO9hWcdd9f+8JoBeqWtYrm5CALfgpkg2YDB80ds/QE4w0qqu34A7fqiAwiBBSBQOid7TLxwxVC27ymWQ==",
- "dev": true,
- "funding": [
- "https://github.com/sponsors/huntabyte",
- "https://github.com/sponsors/tglide"
- ],
- "license": "MIT",
- "dependencies": {
- "esm-env": "^1.0.0"
- },
- "peerDependencies": {
- "svelte": "^5.7.0"
- }
- },
- "node_modules/bits-ui/node_modules/svelte-toolbelt": {
- "version": "0.9.2",
- "resolved": "https://registry.npmjs.org/svelte-toolbelt/-/svelte-toolbelt-0.9.2.tgz",
- "integrity": "sha512-REb1cENGnFbhNSmIdCb1SDIpjEa3n1kXhNVHqGNEesjmPX3bG87gUZiCG8cqOt9AAarqzTzOtI2jEEWr/ZbHwA==",
- "dev": true,
- "funding": [
- "https://github.com/sponsors/huntabyte"
- ],
- "dependencies": {
- "clsx": "^2.1.1",
- "runed": "^0.28.0",
- "style-to-object": "^1.0.8"
- },
- "engines": {
- "node": ">=18",
- "pnpm": ">=8.7.0"
- },
- "peerDependencies": {
- "svelte": "^5.30.2"
- }
- },
"node_modules/brace-expansion": {
"version": "1.1.11",
"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
@@ -2642,6 +2798,34 @@
"node": ">=4"
}
},
+ "node_modules/cssstyle": {
+ "version": "4.6.0",
+ "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-4.6.0.tgz",
+ "integrity": "sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@asamuzakjp/css-color": "^3.2.0",
+ "rrweb-cssom": "^0.8.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/data-urls": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-5.0.0.tgz",
+ "integrity": "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "whatwg-mimetype": "^4.0.0",
+ "whatwg-url": "^14.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/date-fns": {
"version": "4.1.0",
"resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz",
@@ -2677,6 +2861,13 @@
}
}
},
+ "node_modules/decimal.js": {
+ "version": "10.5.0",
+ "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.5.0.tgz",
+ "integrity": "sha512-8vDa8Qxvr/+d94hSh5P3IJwI5t8/c0KsMp+g8bNw9cY2icONa5aPfvKeieW1WlG0WQYwwhJ7mjui2xtiePQSXw==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/deep-is": {
"version": "0.1.4",
"resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -2726,6 +2917,16 @@
"license": "MIT",
"optional": true
},
+ "node_modules/dompurify": {
+ "version": "3.2.6",
+ "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.2.6.tgz",
+ "integrity": "sha512-/2GogDQlohXPZe6D6NOgQvXLPSYBqIWMnZ8zzOhn09REE4eyAzb+Hed3jhoM9OkuaJ8P6ZGTTVWQKAi8ieIzfQ==",
+ "dev": true,
+ "license": "(MPL-2.0 OR Apache-2.0)",
+ "optionalDependencies": {
+ "@types/trusted-types": "^2.0.7"
+ }
+ },
"node_modules/dunder-proto": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
@@ -2766,6 +2967,19 @@
"node": ">=10.13.0"
}
},
+ "node_modules/entities": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+ "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=0.12"
+ },
+ "funding": {
+ "url": "https://github.com/fb55/entities?sponsor=1"
+ }
+ },
"node_modules/es-define-property": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
@@ -3520,6 +3734,60 @@
"node": ">= 0.4"
}
},
+ "node_modules/html-encoding-sniffer": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
+ "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "whatwg-encoding": "^3.1.1"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/http-proxy-agent": {
+ "version": "7.0.2",
+ "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+ "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "^7.1.0",
+ "debug": "^4.3.4"
+ },
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/https-proxy-agent": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+ "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "^7.1.2",
+ "debug": "4"
+ },
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/iconv-lite": {
+ "version": "0.6.3",
+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+ "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "safer-buffer": ">= 2.1.2 < 3.0.0"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
"node_modules/ignore": {
"version": "5.3.2",
"resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
@@ -3597,6 +3865,13 @@
"node": ">=0.12.0"
}
},
+ "node_modules/is-potential-custom-element-name": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+ "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/isexe": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -3604,6 +3879,20 @@
"dev": true,
"license": "ISC"
},
+ "node_modules/isomorphic-dompurify": {
+ "version": "2.25.0",
+ "resolved": "https://registry.npmjs.org/isomorphic-dompurify/-/isomorphic-dompurify-2.25.0.tgz",
+ "integrity": "sha512-bcpJzu9DOjN21qaCVpcoCwUX1ytpvA6EFqCK5RNtPg5+F0Jz9PX50jl6jbEicBNeO87eDDfC7XtPs4zjDClZJg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "dompurify": "^3.2.6",
+ "jsdom": "^26.1.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/jiti": {
"version": "2.4.2",
"resolved": "https://registry.npmjs.org/jiti/-/jiti-2.4.2.tgz",
@@ -3641,6 +3930,46 @@
"js-yaml": "bin/js-yaml.js"
}
},
+ "node_modules/jsdom": {
+ "version": "26.1.0",
+ "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-26.1.0.tgz",
+ "integrity": "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cssstyle": "^4.2.1",
+ "data-urls": "^5.0.0",
+ "decimal.js": "^10.5.0",
+ "html-encoding-sniffer": "^4.0.0",
+ "http-proxy-agent": "^7.0.2",
+ "https-proxy-agent": "^7.0.6",
+ "is-potential-custom-element-name": "^1.0.1",
+ "nwsapi": "^2.2.16",
+ "parse5": "^7.2.1",
+ "rrweb-cssom": "^0.8.0",
+ "saxes": "^6.0.0",
+ "symbol-tree": "^3.2.4",
+ "tough-cookie": "^5.1.1",
+ "w3c-xmlserializer": "^5.0.0",
+ "webidl-conversions": "^7.0.0",
+ "whatwg-encoding": "^3.1.1",
+ "whatwg-mimetype": "^4.0.0",
+ "whatwg-url": "^14.1.1",
+ "ws": "^8.18.0",
+ "xml-name-validator": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "peerDependencies": {
+ "canvas": "^3.0.0"
+ },
+ "peerDependenciesMeta": {
+ "canvas": {
+ "optional": true
+ }
+ }
+ },
"node_modules/json-buffer": {
"version": "3.0.1",
"resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
@@ -3993,6 +4322,13 @@
"dev": true,
"license": "MIT"
},
+ "node_modules/lru-cache": {
+ "version": "10.4.3",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+ "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+ "dev": true,
+ "license": "ISC"
+ },
"node_modules/magic-string": {
"version": "0.30.17",
"resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
@@ -4158,6 +4494,43 @@
"svelte": "^5.7.0"
}
},
+ "node_modules/mode-watcher/node_modules/svelte-toolbelt": {
+ "version": "0.7.1",
+ "resolved": "https://registry.npmjs.org/svelte-toolbelt/-/svelte-toolbelt-0.7.1.tgz",
+ "integrity": "sha512-HcBOcR17Vx9bjaOceUvxkY3nGmbBmCBBbuWLLEWO6jtmWH8f/QoWmbyUfQZrpDINH39en1b8mptfPQT9VKQ1xQ==",
+ "dev": true,
+ "funding": [
+ "https://github.com/sponsors/huntabyte"
+ ],
+ "dependencies": {
+ "clsx": "^2.1.1",
+ "runed": "^0.23.2",
+ "style-to-object": "^1.0.8"
+ },
+ "engines": {
+ "node": ">=18",
+ "pnpm": ">=8.7.0"
+ },
+ "peerDependencies": {
+ "svelte": "^5.0.0"
+ }
+ },
+ "node_modules/mode-watcher/node_modules/svelte-toolbelt/node_modules/runed": {
+ "version": "0.23.4",
+ "resolved": "https://registry.npmjs.org/runed/-/runed-0.23.4.tgz",
+ "integrity": "sha512-9q8oUiBYeXIDLWNK5DfCWlkL0EW3oGbk845VdKlPeia28l751VpfesaB/+7pI6rnbx1I6rqoZ2fZxptOJLxILA==",
+ "dev": true,
+ "funding": [
+ "https://github.com/sponsors/huntabyte",
+ "https://github.com/sponsors/tglide"
+ ],
+ "dependencies": {
+ "esm-env": "^1.0.0"
+ },
+ "peerDependencies": {
+ "svelte": "^5.7.0"
+ }
+ },
"node_modules/mri": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
@@ -4203,6 +4576,13 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/nwsapi": {
+ "version": "2.2.20",
+ "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.20.tgz",
+ "integrity": "sha512-/ieB+mDe4MrrKMT8z+mQL8klXydZWGR5Dowt4RAGKbJ3kIGEx3X4ljUo+6V73IXtUPWgfOlU5B9MlGxFO5T+cA==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/optionator": {
"version": "0.9.4",
"resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -4283,6 +4663,27 @@
"svelte": "^5.7.0"
}
},
+ "node_modules/paneforge/node_modules/svelte-toolbelt": {
+ "version": "0.7.1",
+ "resolved": "https://registry.npmjs.org/svelte-toolbelt/-/svelte-toolbelt-0.7.1.tgz",
+ "integrity": "sha512-HcBOcR17Vx9bjaOceUvxkY3nGmbBmCBBbuWLLEWO6jtmWH8f/QoWmbyUfQZrpDINH39en1b8mptfPQT9VKQ1xQ==",
+ "dev": true,
+ "funding": [
+ "https://github.com/sponsors/huntabyte"
+ ],
+ "dependencies": {
+ "clsx": "^2.1.1",
+ "runed": "^0.23.2",
+ "style-to-object": "^1.0.8"
+ },
+ "engines": {
+ "node": ">=18",
+ "pnpm": ">=8.7.0"
+ },
+ "peerDependencies": {
+ "svelte": "^5.0.0"
+ }
+ },
"node_modules/parent-module": {
"version": "1.0.1",
"resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
@@ -4296,6 +4697,19 @@
"node": ">=6"
}
},
+ "node_modules/parse5": {
+ "version": "7.3.0",
+ "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+ "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "entities": "^6.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/inikulin/parse5?sponsor=1"
+ }
+ },
"node_modules/path-exists": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -4780,6 +5194,13 @@
"fsevents": "~2.3.2"
}
},
+ "node_modules/rrweb-cssom": {
+ "version": "0.8.0",
+ "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
+ "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/run-parallel": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -4805,9 +5226,10 @@
}
},
"node_modules/runed": {
- "version": "0.29.0",
- "resolved": "https://registry.npmjs.org/runed/-/runed-0.29.0.tgz",
- "integrity": "sha512-8aewcEjcaHk/dDsAWdPHQMUtsB2J9KSeL/c3USD58/3ijhUYEk0D/XT+BQSHt12ikbHNfaEf/ytJ3fmpBcf0YQ==",
+ "version": "0.29.1",
+ "resolved": "https://registry.npmjs.org/runed/-/runed-0.29.1.tgz",
+ "integrity": "sha512-RGQEB8ZiWv4OvzBJhbMj2hMgRM8QrEptzTrDr7TDfkHaRePKjiUka4vJ9QHGY+8s87KymNvFoZAxFdQ4jtZNcA==",
+ "dev": true,
"funding": [
"https://github.com/sponsors/huntabyte",
"https://github.com/sponsors/tglide"
@@ -4832,6 +5254,26 @@
"node": ">=6"
}
},
+ "node_modules/safer-buffer": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/saxes": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+ "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "xmlchars": "^2.2.0"
+ },
+ "engines": {
+ "node": ">=v12.22.7"
+ }
+ },
"node_modules/semver": {
"version": "7.7.2",
"resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
@@ -5092,16 +5534,16 @@
}
},
"node_modules/svelte-toolbelt": {
- "version": "0.7.1",
- "resolved": "https://registry.npmjs.org/svelte-toolbelt/-/svelte-toolbelt-0.7.1.tgz",
- "integrity": "sha512-HcBOcR17Vx9bjaOceUvxkY3nGmbBmCBBbuWLLEWO6jtmWH8f/QoWmbyUfQZrpDINH39en1b8mptfPQT9VKQ1xQ==",
+ "version": "0.9.3",
+ "resolved": "https://registry.npmjs.org/svelte-toolbelt/-/svelte-toolbelt-0.9.3.tgz",
+ "integrity": "sha512-HCSWxCtVmv+c6g1ACb8LTwHVbDqLKJvHpo6J8TaqwUme2hj9ATJCpjCPNISR1OCq2Q4U1KT41if9ON0isINQZw==",
"dev": true,
"funding": [
"https://github.com/sponsors/huntabyte"
],
"dependencies": {
"clsx": "^2.1.1",
- "runed": "^0.23.2",
+ "runed": "^0.29.0",
"style-to-object": "^1.0.8"
},
"engines": {
@@ -5109,23 +5551,7 @@
"pnpm": ">=8.7.0"
},
"peerDependencies": {
- "svelte": "^5.0.0"
- }
- },
- "node_modules/svelte-toolbelt/node_modules/runed": {
- "version": "0.23.4",
- "resolved": "https://registry.npmjs.org/runed/-/runed-0.23.4.tgz",
- "integrity": "sha512-9q8oUiBYeXIDLWNK5DfCWlkL0EW3oGbk845VdKlPeia28l751VpfesaB/+7pI6rnbx1I6rqoZ2fZxptOJLxILA==",
- "dev": true,
- "funding": [
- "https://github.com/sponsors/huntabyte",
- "https://github.com/sponsors/tglide"
- ],
- "dependencies": {
- "esm-env": "^1.0.0"
- },
- "peerDependencies": {
- "svelte": "^5.7.0"
+ "svelte": "^5.30.2"
}
},
"node_modules/svelte/node_modules/is-reference": {
@@ -5234,6 +5660,13 @@
}
}
},
+ "node_modules/symbol-tree": {
+ "version": "3.2.4",
+ "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+ "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/tabbable": {
"version": "6.2.0",
"resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.2.0.tgz",
@@ -5281,9 +5714,9 @@
}
},
"node_modules/tailwindcss": {
- "version": "4.1.10",
- "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.10.tgz",
- "integrity": "sha512-P3nr6WkvKV/ONsTzj6Gb57sWPMX29EPNPopo7+FcpkQaNsrNpZ1pv8QmrYI2RqEKD7mlGqLnGovlcYnBK0IqUA==",
+ "version": "4.1.11",
+ "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.11.tgz",
+ "integrity": "sha512-2E9TBm6MDD/xKYe+dvJZAmg3yxIEDNRc0jwlNyDg/4Fil2QcSLjFKGVff0lAf1jjeaArlG/M75Ey/EYr/OJtBA==",
"dev": true,
"license": "MIT"
},
@@ -5315,17 +5748,6 @@
"node": ">=18"
}
},
- "node_modules/thememirror": {
- "version": "2.0.1",
- "resolved": "https://registry.npmjs.org/thememirror/-/thememirror-2.0.1.tgz",
- "integrity": "sha512-d5i6FVvWWPkwrm4cHLI3t9AT1OrkAt7Ig8dtdYSofgF7C/eiyNuq6zQzSTusWTde3jpW9WLvA9J/fzNKMUsd0w==",
- "license": "MIT",
- "peerDependencies": {
- "@codemirror/language": "^6.0.0",
- "@codemirror/state": "^6.0.0",
- "@codemirror/view": "^6.0.0"
- }
- },
"node_modules/tiny-case": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/tiny-case/-/tiny-case-1.0.3.tgz",
@@ -5350,6 +5772,26 @@
"url": "https://github.com/sponsors/SuperchupuDev"
}
},
+ "node_modules/tldts": {
+ "version": "6.1.86",
+ "resolved": "https://registry.npmjs.org/tldts/-/tldts-6.1.86.tgz",
+ "integrity": "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tldts-core": "^6.1.86"
+ },
+ "bin": {
+ "tldts": "bin/cli.js"
+ }
+ },
+ "node_modules/tldts-core": {
+ "version": "6.1.86",
+ "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-6.1.86.tgz",
+ "integrity": "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
@@ -5380,6 +5822,32 @@
"node": ">=6"
}
},
+ "node_modules/tough-cookie": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz",
+ "integrity": "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "tldts": "^6.1.32"
+ },
+ "engines": {
+ "node": ">=16"
+ }
+ },
+ "node_modules/tr46": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",
+ "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "punycode": "^2.3.1"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/ts-algebra": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
@@ -5689,6 +6157,66 @@
"integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
"license": "MIT"
},
+ "node_modules/w3c-xmlserializer": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+ "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "xml-name-validator": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/webidl-conversions": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
+ "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/whatwg-encoding": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
+ "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "iconv-lite": "0.6.3"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/whatwg-mimetype": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+ "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/whatwg-url": {
+ "version": "14.2.0",
+ "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
+ "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tr46": "^5.1.0",
+ "webidl-conversions": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
"node_modules/which": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -5715,6 +6243,45 @@
"node": ">=0.10.0"
}
},
+ "node_modules/ws": {
+ "version": "8.18.3",
+ "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+ "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10.0.0"
+ },
+ "peerDependencies": {
+ "bufferutil": "^4.0.1",
+ "utf-8-validate": ">=5.0.2"
+ },
+ "peerDependenciesMeta": {
+ "bufferutil": {
+ "optional": true
+ },
+ "utf-8-validate": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/xml-name-validator": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+ "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/xmlchars": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+ "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+ "dev": true,
+ "license": "MIT"
+ },
"node_modules/yallist": {
"version": "5.0.0",
"resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index 7178a439e..26dd9d180 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -26,6 +26,7 @@
"@codemirror/legacy-modes": "^6.5.1",
"@sveltejs/adapter-static": "^3.0.8",
"@tanstack/table-core": "^8.21.3",
+ "@uiw/codemirror-theme-github": "^4.23.14",
"axios": "^1.10.0",
"codemirror": "^6.0.2",
"date-fns": "^4.1.0",
@@ -33,38 +34,39 @@
"prettier": "^3.5.3",
"prettier-plugin-svelte": "^3.4.0",
"prettier-plugin-tailwindcss": "^0.6.13",
- "runed": "^0.29.0",
- "svelte-codemirror-editor": "^1.4.1",
- "thememirror": "^2.0.1"
+ "svelte-codemirror-editor": "^1.4.1"
},
"devDependencies": {
"@eslint/compat": "^1.3.0",
"@eslint/js": "^9.29.0",
- "@lucide/svelte": "^0.522.0",
+ "@lucide/svelte": "^0.525.0",
"@playwright/test": "^1.52.0",
- "@sveltejs/kit": "^2.22.0",
+ "@sveltejs/kit": "^2.22.2",
"@sveltejs/vite-plugin-svelte": "^5.1.0",
"@tailwindcss/vite": "^4.1.10",
- "@types/dockerode": "^3.3.40",
+ "@types/dockerode": "^3.3.42",
"@types/js-yaml": "^4.0.9",
- "bits-ui": "^2.8.8",
+ "bits-ui": "^2.8.10",
"clsx": "^2.1.1",
"eslint": "^9.28.0",
"eslint-plugin-svelte": "^3.9.1",
"formsnap": "^2.0.1",
"globals": "^16.2.0",
+ "isomorphic-dompurify": "^2.25.0",
"mode-watcher": "^1.0.8",
"paneforge": "^1.0.0-next.5",
- "svelte": "5.34.7",
+ "runed": "^0.29.1",
+ "svelte": "^5.34.7",
"svelte-check": "^4.2.2",
"svelte-sonner": "^1.0.5",
+ "svelte-toolbelt": "^0.9.3",
"sveltekit-superforms": "^2.27.0",
"tailwind-merge": "^3.3.1",
"tailwind-variants": "^1.0.0",
- "tailwindcss": "^4.1.7",
+ "tailwindcss": "^4.1.11",
"tsx": "^4.20.3",
"tw-animate-css": "^1.3.4",
- "typescript": "^5.8.0",
+ "typescript": "^5.8.3",
"typescript-eslint": "^8.34.1",
"vite": "^6.3.5",
"zod": "^3.25.67"
diff --git a/frontend/src/lib/components/yaml-editor.svelte b/frontend/src/lib/components/editor.svelte
similarity index 53%
rename from frontend/src/lib/components/yaml-editor.svelte
rename to frontend/src/lib/components/editor.svelte
index df1f4debe..18afe6334 100644
--- a/frontend/src/lib/components/yaml-editor.svelte
+++ b/frontend/src/lib/components/editor.svelte
@@ -1,16 +1,46 @@
<script lang="ts">
import CodeMirror from 'svelte-codemirror-editor';
+ import { browser } from '$app/environment';
import { yaml } from '@codemirror/lang-yaml';
+ import { StreamLanguage } from '@codemirror/language';
+ import { properties } from '@codemirror/legacy-modes/mode/properties';
import { linter, lintGutter } from '@codemirror/lint';
- import { browser } from '$app/environment';
import jsyaml from 'js-yaml';
- import { coolGlow } from 'thememirror';
+ import { githubDark } from '@uiw/codemirror-theme-github';
import type { EditorView } from 'codemirror';
+ import type { Extension } from '@codemirror/state';
+
+ type CodeLanguage = 'yaml' | 'env';
- let { value = $bindable(''), placeholder = 'Enter YAML content', readOnly = false } = $props();
+ let {
+ value = $bindable(''),
+ language = 'yaml' as CodeLanguage,
+ placeholder = 'Enter code...',
+ readOnly = false,
+ height = '550px',
+ fontSize = '11px'
+ } = $props();
let editorView: EditorView;
+ function getLanguageExtension(lang: CodeLanguage): Extension[] {
+ const extensions: Extension[] = [];
+
+ switch (lang) {
+ case 'yaml':
+ extensions.push(yaml());
+ if (!readOnly) {
+ extensions.push(lintGutter(), linter(yamlLinter));
+ }
+ break;
+ case 'env':
+ extensions.push(StreamLanguage.define(properties));
+ break;
+ }
+
+ return extensions;
+ }
+
function yamlLinter(view: { state: { doc: { toString(): string } } }) {
const diagnostics = [];
try {
@@ -18,7 +48,8 @@
} catch (e: unknown) {
const err = e as { mark?: { position: number }; message: string };
const start = err.mark?.position || 0;
- const end = err.mark?.position !== undefined ? Math.max(start + 1, err.mark.position + 1) : start + 1;
+ const end =
+ err.mark?.position !== undefined ? Math.max(start + 1, err.mark.position + 1) : start + 1;
diagnostics.push({
from: start,
to: end,
@@ -28,8 +59,6 @@
}
return diagnostics;
}
-
- const lintExtension = linter(yamlLinter);
</script>
{#if browser}
@@ -37,13 +66,12 @@
<CodeMirror
bind:value
on:ready={(e) => (editorView = e.detail)}
- lang={yaml()}
- theme={coolGlow}
- extensions={[lintGutter(), lintExtension]}
+ theme={githubDark}
+ extensions={getLanguageExtension(language)}
styles={{
'&': {
- height: '550px',
- fontSize: '11px'
+ height,
+ fontSize
},
'&.cm-editor[contenteditable=false]': {
cursor: 'not-allowed'
diff --git a/frontend/src/lib/components/env-editor.svelte b/frontend/src/lib/components/env-editor.svelte
deleted file mode 100644
index f48385a63..000000000
--- a/frontend/src/lib/components/env-editor.svelte
+++ /dev/null
@@ -1,37 +0,0 @@
-<script lang="ts">
- import CodeMirror from 'svelte-codemirror-editor';
- import { browser } from '$app/environment';
- import { coolGlow } from 'thememirror';
- import { StreamLanguage } from '@codemirror/language';
- import { properties } from '@codemirror/legacy-modes/mode/properties';
-
- let { value = $bindable(''), placeholder = '# Add environment variables here', readOnly = false } = $props();
-</script>
-
-{#if browser}
- <div class="overflow-hidden rounded-md border">
- <CodeMirror
- bind:value
- theme={coolGlow}
- extensions={[StreamLanguage.define(properties)]}
- styles={{
- '&': {
- height: '550px',
- fontSize: '11px'
- },
- '&.cm-editor[contenteditable=false]': {
- cursor: 'not-allowed'
- },
- '.cm-content[contenteditable=false]': {
- cursor: 'not-allowed'
- },
- '.cm-line': {
- padding: '2px 4px'
- }
- }}
- {placeholder}
- readonly={readOnly}
- nodebounce={true}
- />
- </div>
-{/if}
diff --git a/frontend/src/lib/components/ui/button/button.svelte b/frontend/src/lib/components/ui/button/button.svelte
index 498144763..cee02c35f 100644
--- a/frontend/src/lib/components/ui/button/button.svelte
+++ b/frontend/src/lib/components/ui/button/button.svelte
@@ -67,7 +67,7 @@
<script lang="ts">
import { cn } from '$lib/utils/utils.js';
- import { LoaderCircleIcon } from '@lucide/svelte';
+ import LoaderCircleIcon from '@lucide/svelte/icons/loader-circle';
let {
ref = $bindable(null),
diff --git a/frontend/src/lib/components/ui/copy-button/copy-button.svelte b/frontend/src/lib/components/ui/copy-button/copy-button.svelte
index 04e5f7140..7ec9c7aec 100644
--- a/frontend/src/lib/components/ui/copy-button/copy-button.svelte
+++ b/frontend/src/lib/components/ui/copy-button/copy-button.svelte
@@ -6,7 +6,9 @@
import { Button } from '$lib/components/ui/button';
import { UseClipboard } from '$lib/hooks/use-clipboard.svelte';
import { cn } from '$lib/utils/utils';
- import { CheckIcon, CopyIcon, XIcon } from '@lucide/svelte';
+ import CheckIcon from '@lucide/svelte/icons/check';
+ import CopyIcon from '@lucide/svelte/icons/copy';
+ import XIcon from '@lucide/svelte/icons/x';
import { scale } from 'svelte/transition';
import type { CopyButtonProps } from './types';
diff --git a/frontend/src/lib/components/universal-table.svelte b/frontend/src/lib/components/universal-table.svelte
index 376e6e26d..c138b9ede 100644
--- a/frontend/src/lib/components/universal-table.svelte
+++ b/frontend/src/lib/components/universal-table.svelte
@@ -1,5 +1,12 @@
<script lang="ts" generics="TData extends Record<string, any>">
- import { getCoreRowModel, getPaginationRowModel, getSortedRowModel, getFilteredRowModel, type SortingState, type ColumnFiltersState } from '@tanstack/table-core';
+ import {
+ getCoreRowModel,
+ getPaginationRowModel,
+ getSortedRowModel,
+ getFilteredRowModel,
+ type SortingState,
+ type ColumnFiltersState
+ } from '@tanstack/table-core';
import { createSvelteTable, FlexRender } from '$lib/components/ui/data-table/index.js';
import * as Table from '$lib/components/ui/table/index.js';
import * as Pagination from '$lib/components/ui/pagination/index.js';
@@ -62,11 +69,24 @@
} = $props();
// Destructure with proper defaults
- const { sorting: enableSorting = true, filtering: enableFiltering = true, selection: enableSelection = true }: TableFeatures = features;
-
- const { pageSize: initialPageSize = 10, pageSizeOptions = [10, 20, 50, 100], itemsPerPageLabel = 'Items per page' }: TablePagination = pagination;
-
- const { filterPlaceholder = 'Search...', noResultsMessage = 'No results found', isDashboardTable = false, class: className = '' }: TableDisplay = display;
+ const {
+ sorting: enableSorting = true,
+ filtering: enableFiltering = true,
+ selection: enableSelection = true
+ }: TableFeatures = features;
+
+ const {
+ pageSize: initialPageSize = 10,
+ pageSizeOptions = [10, 20, 50, 100],
+ itemsPerPageLabel = 'Items per page'
+ }: TablePagination = pagination;
+
+ const {
+ filterPlaceholder = 'Search...',
+ noResultsMessage = 'No results found',
+ isDashboardTable = false,
+ class: className = ''
+ }: TableDisplay = display;
const { defaultSort }: TableSort = sort;
@@ -181,13 +201,19 @@
});
// Memoized computations
- const validPageSizeOptions = $derived(pageSizeOptions.filter((size) => size > 0).sort((a, b) => a - b));
+ const validPageSizeOptions = $derived(
+ pageSizeOptions.filter((size) => size > 0).sort((a, b) => a - b)
+ );
- const shouldShowPagination = $derived(!isDashboardTable && (table.getPageCount() > 1 || validPageSizeOptions.length > 1));
+ const shouldShowPagination = $derived(
+ !isDashboardTable && (table.getPageCount() > 1 || validPageSizeOptions.length > 1)
+ );
const shouldShowFiltering = $derived(enableFiltering && !isDashboardTable);
- const allRowsSelected = $derived(table.getIsAllPageRowsSelected() && table.getRowModel().rows.length > 0);
+ const allRowsSelected = $derived(
+ table.getIsAllPageRowsSelected() && table.getRowModel().rows.length > 0
+ );
const filteredRowCount = $derived(table.getFilteredRowModel().rows.length);
@@ -229,33 +255,58 @@
<!-- Search Filter -->
{#if shouldShowFiltering}
<div class="flex items-center">
- <Input placeholder={filterPlaceholder} value={globalFilter} oninput={(e) => handleFilterChange(e.currentTarget.value)} class="max-w-sm" />
+ <Input
+ placeholder={filterPlaceholder}
+ value={globalFilter}
+ oninput={(e) => handleFilterChange(e.currentTarget.value)}
+ class="max-w-sm"
+ />
</div>
{/if}
<!-- Table -->
<div class={cn('rounded-md border', isDashboardTable && 'rounded-none border-none')}>
- <Table.Root>
+ <Table.Root class="w-full table-auto">
<Table.Header>
{#each table.getHeaderGroups() as headerGroup (headerGroup.id)}
<Table.Row>
{#if enableSelection}
- <Table.Head class="size-12">
- <Checkbox checked={allRowsSelected} onCheckedChange={handleSelectAllChange} aria-label="Select all rows" />
+ <Table.Head class="w-12">
+ <Checkbox
+ checked={allRowsSelected}
+ onCheckedChange={handleSelectAllChange}
+ aria-label="Select all rows"
+ />
</Table.Head>
{/if}
- {#each headerGroup.headers as header (header.id)}
- <Table.Head>
+ {#each headerGroup.headers as header, index (header.id)}
+ <Table.Head class={cn(index === 0 ? '' : 'w-0 whitespace-nowrap', 'px-4')}>
{#if !header.isPlaceholder}
{#if header.column.getCanSort()}
- <Button variant="ghost" class="flex items-center p-0 hover:bg-transparent" onclick={() => handleSortChange(header)} aria-label="Sort by {header.column.columnDef.header}">
- <FlexRender content={header.column.columnDef.header} context={header.getContext()} />
+ <Button
+ variant="ghost"
+ class="flex items-center p-0 hover:bg-transparent"
+ onclick={() => handleSortChange(header)}
+ aria-label="Sort by {header.column.columnDef.header}"
+ >
+ <FlexRender
+ content={header.column.columnDef.header}
+ context={header.getContext()}
+ />
{#if header.column.getIsSorted()}
- <ChevronDown class={cn('ml-2 size-4 transition-transform', header.column.getIsSorted() === 'asc' && 'rotate-180')} />
+ <ChevronDown
+ class={cn(
+ 'ml-2 size-4 transition-transform',
+ header.column.getIsSorted() === 'asc' && 'rotate-180'
+ )}
+ />
{/if}
</Button>
{:else}
- <FlexRender content={header.column.columnDef.header} context={header.getContext()} />
+ <FlexRender
+ content={header.column.columnDef.header}
+ context={header.getContext()}
+ />
{/if}
{/if}
</Table.Head>
@@ -269,16 +320,21 @@
{@const isDisabled = row.original?.isExternal ?? false}
<Table.Row data-state={row.getIsSelected() ? 'selected' : undefined}>
{#if enableSelection}
- <Table.Cell class="size-12">
- <Checkbox checked={row.getIsSelected()} disabled={isDisabled} onCheckedChange={(checked) => handleRowSelectionChange(row, !!checked)} aria-label="Select row" />
+ <Table.Cell class="w-12">
+ <Checkbox
+ checked={row.getIsSelected()}
+ disabled={isDisabled}
+ onCheckedChange={(checked) => handleRowSelectionChange(row, !!checked)}
+ aria-label="Select row"
+ />
</Table.Cell>
{/if}
{#if rows}
{@render rows({ item: row.original, index: row.index })}
{:else}
- {#each row.getVisibleCells() as cell (cell.id)}
- <Table.Cell class="w-32">
+ {#each row.getVisibleCells() as cell, index (cell.id)}
+ <Table.Cell class={cn(index === 0 ? '' : 'w-0 whitespace-nowrap', 'px-4')}>
<FlexRender content={cell.column.columnDef.cell} context={cell.getContext()} />
</Table.Cell>
{/each}
@@ -287,7 +343,10 @@
{/each}
{:else}
<Table.Row>
- <Table.Cell colspan={enableSelection ? columns.length + 1 : columns.length} class="size-24 text-center">
+ <Table.Cell
+ colspan={enableSelection ? columns.length + 1 : columns.length}
+ class="size-24 text-center"
+ >
{noResultsMessage}
</Table.Cell>
</Table.Row>
@@ -302,7 +361,11 @@
{#if validPageSizeOptions.length > 1}
<div class="flex items-center gap-4">
<span class="text-sm whitespace-nowrap">{itemsPerPageLabel}</span>
- <Select.Root type="single" value={pageSize.toString()} onValueChange={handlePageSizeChange}>
+ <Select.Root
+ type="single"
+ value={pageSize.toString()}
+ onValueChange={handlePageSizeChange}
+ >
<Select.Trigger class="h-8 w-[70px]" aria-label="Items per page">
<span>{pageSize}</span>
</Select.Trigger>
diff --git a/frontend/src/lib/models/image.type.ts b/frontend/src/lib/models/image.type.ts
index f1979075f..fd953b083 100644
--- a/frontend/src/lib/models/image.type.ts
+++ b/frontend/src/lib/models/image.type.ts
@@ -1,17 +1,36 @@
import type Docker from 'dockerode';
-/**
- * Represents a Docker image, extending Dockerode's ImageInfo with parsed repo and tag.
- * Properties like Id, RepoTags, Created, Size, etc., are inherited from Docker.ImageInfo.
- */
export type ServiceImage = Docker.ImageInfo & {
- repo: string; // Parsed repository name
- tag: string; // Parsed tag
+ repo: string;
+ tag: string;
+ Architecture?: string;
+ Os?: string;
+ Config?: {
+ User?: string;
+ ExposedPorts?: Record<string, any>;
+ Env?: string[];
+ Entrypoint?: string[];
+ WorkingDir?: string;
+ Labels?: Record<string, string>;
+ };
+ GraphDriver?: {
+ Data: any;
+ Name: string;
+ };
+ RootFS?: {
+ Type: string;
+ Layers: string[];
+ };
+ Metadata?: {
+ LastTagTime?: string;
+ };
+ Descriptor?: {
+ mediaType: string;
+ digest: string;
+ size: number;
+ };
};
-/**
- * Represents the maturity status of a Docker image.
- */
export interface ImageMaturity {
version: string;
date: string;
@@ -19,9 +38,6 @@ export interface ImageMaturity {
updatesAvailable: boolean;
}
-/**
- * Extends ServiceImage with application-specific information like usage status and maturity.
- */
export type EnhancedImageInfo = ServiceImage & {
InUse: boolean;
maturity?: ImageMaturity;
diff --git a/frontend/src/lib/services/api/autoupdate-api-service.ts b/frontend/src/lib/services/api/autoupdate-api-service.ts
index ed9fdbbfc..1337bac80 100644
--- a/frontend/src/lib/services/api/autoupdate-api-service.ts
+++ b/frontend/src/lib/services/api/autoupdate-api-service.ts
@@ -1,13 +1,43 @@
import BaseAPIService from './api-service';
+import type {
+ AutoUpdateCheck,
+ AutoUpdateResult,
+ AutoUpdateRecord,
+ AutoUpdateStatus
+} from '$lib/types/auto-update.type';
export default class AutoUpdateAPIService extends BaseAPIService {
- async checkContainers(): Promise<boolean> {
- const response = await this.api.post('/updates/check/containers');
- return response.data;
- }
-
- async checkStack(): Promise<boolean> {
- const response = await this.api.post('/updates/check/compose');
- return response.data;
- }
+ async checkForUpdates(options?: AutoUpdateCheck): Promise<AutoUpdateResult> {
+ const response = await this.api.post('/updates/check', options || {});
+ return response.data;
+ }
+
+ async checkContainers(): Promise<AutoUpdateResult> {
+ const response = await this.api.post('/updates/check/containers');
+ return response.data;
+ }
+
+ async checkStacks(): Promise<AutoUpdateResult> {
+ const response = await this.api.post('/updates/check/compose');
+ return response.data;
+ }
+
+ async getUpdateHistory(limit?: number): Promise<AutoUpdateRecord[]> {
+ const params = limit ? { limit } : {};
+ const response = await this.api.get('/updates/history', { params });
+ return response.data.data;
+ }
+
+ async getUpdateStatus(): Promise<AutoUpdateStatus> {
+ const response = await this.api.get('/updates/status');
+ return response.data.data;
+ }
+
+ async dryRun(type: 'containers' | 'stacks' | 'all' = 'all'): Promise<AutoUpdateResult> {
+ const response = await this.api.post('/updates/check', {
+ type,
+ dryRun: true
+ });
+ return response.data;
+ }
}
diff --git a/frontend/src/lib/types/auto-update.type.ts b/frontend/src/lib/types/auto-update.type.ts
new file mode 100644
index 000000000..f062c33bb
--- /dev/null
+++ b/frontend/src/lib/types/auto-update.type.ts
@@ -0,0 +1,54 @@
+export interface AutoUpdateCheck {
+ type?: 'containers' | 'stacks' | 'all';
+ resourceIds?: string[];
+ forceUpdate?: boolean;
+ dryRun?: boolean;
+}
+
+export interface AutoUpdateResult {
+ success: boolean;
+ checked: number;
+ updated: number;
+ skipped: number;
+ failed: number;
+ startTime: string;
+ endTime: string;
+ duration: string;
+ results: AutoUpdateResourceResult[];
+}
+
+export interface AutoUpdateResourceResult {
+ resourceId: string;
+ resourceName: string;
+ resourceType: 'container' | 'stack';
+ status: 'checked' | 'up_to_date' | 'update_available' | 'updated' | 'failed' | 'skipped';
+ updateAvailable: boolean;
+ updateApplied: boolean;
+ oldImages?: Record<string, string>;
+ newImages?: Record<string, string>;
+ error?: string;
+ details?: Record<string, any>;
+}
+
+export interface AutoUpdateRecord {
+ id: string;
+ resourceId: string;
+ resourceType: string;
+ resourceName: string;
+ status: string;
+ startTime: string;
+ endTime?: string;
+ updateAvailable: boolean;
+ updateApplied: boolean;
+ oldImageVersions?: Record<string, string>;
+ newImageVersions?: Record<string, string>;
+ error?: string;
+ details?: Record<string, any>;
+}
+
+export interface AutoUpdateStatus {
+ updatingContainers: number;
+ updatingStacks: number;
+ containerIds: string[];
+ stackIds: string[];
+}
\ No newline at end of file
diff --git a/frontend/src/routes/compose/+page.svelte b/frontend/src/routes/compose/+page.svelte
index b44755f15..45a134c1d 100644
--- a/frontend/src/routes/compose/+page.svelte
+++ b/frontend/src/routes/compose/+page.svelte
@@ -153,7 +153,7 @@
async function handleCheckForUpdates() {
isLoading.update = true;
handleApiResultWithCallbacks({
- result: await tryCatch(autoUpdateAPI.checkStack()),
+ result: await tryCatch(autoUpdateAPI.checkStacks()),
message: 'Failed to Check Compose Projects for Updates',
setLoadingState: (value) => (isLoading.update = value),
async onSuccess() {
diff --git a/frontend/src/routes/compose/[composeId]/+page.svelte b/frontend/src/routes/compose/[composeId]/+page.svelte
index 5c5db6c82..ce07a513a 100644
--- a/frontend/src/routes/compose/[composeId]/+page.svelte
+++ b/frontend/src/routes/compose/[composeId]/+page.svelte
@@ -3,7 +3,18 @@
import type { Stack, StackService, StackPort } from '$lib/models/stack.type';
import * as Card from '$lib/components/ui/card/index.js';
import { Button } from '$lib/components/ui/button/index.js';
- import { ArrowLeft, AlertCircle, FileStack, Layers, ArrowRight, ExternalLink, RefreshCw, Terminal, Settings, Activity } from '@lucide/svelte';
+ import {
+ ArrowLeft,
+ AlertCircle,
+ FileStack,
+ Layers,
+ ArrowRight,
+ ExternalLink,
+ RefreshCw,
+ Terminal,
+ Settings,
+ Activity
+ } from '@lucide/svelte';
import * as Alert from '$lib/components/ui/alert/index.js';
import { Input } from '$lib/components/ui/input/index.js';
import { Label } from '$lib/components/ui/label/index.js';
@@ -13,13 +24,13 @@
import { capitalizeFirstLetter } from '$lib/utils/string.utils';
import { invalidateAll, goto } from '$app/navigation';
import { toast } from 'svelte-sonner';
- import YamlEditor from '$lib/components/yaml-editor.svelte';
- import EnvEditor from '$lib/components/env-editor.svelte';
+ import CodeEditor from '$lib/components/editor.svelte';
import { tryCatch } from '$lib/utils/try-catch';
import { environmentAPI } from '$lib/services/api';
import { handleApiResultWithCallbacks } from '$lib/utils/api.util';
import ArcaneButton from '$lib/components/arcane-button.svelte';
import LogViewer from '$lib/components/LogViewer.svelte';
+ import { browser } from '$app/environment';
let { data }: { data: PageData } = $props();
let { stack, editorState, servicePorts, settings } = $derived(data);
@@ -43,7 +54,11 @@
let originalComposeContent = $derived(editorState.originalComposeContent);
let originalEnvContent = $derived(editorState.originalEnvContent || '');
- let hasChanges = $derived(name !== originalName || composeContent !== originalComposeContent || envContent !== originalEnvContent);
+ let hasChanges = $derived(
+ name !== originalName ||
+ composeContent !== originalComposeContent ||
+ envContent !== originalEnvContent
+ );
const baseServerUrl = $derived(settings?.baseServerUrl || 'localhost');
@@ -51,6 +66,19 @@
let autoScrollStackLogs = $state(true);
let isStackLogsStreaming = $state(false);
let stackLogViewer = $state<LogViewer>();
+ let showFloatingHeader = $state(false);
+ let mainContainer = $state<HTMLElement>();
+
+ $effect(() => {
+ if (browser) {
+ const handleScroll = () => {
+ showFloatingHeader = window.scrollY > 100;
+ };
+
+ window.addEventListener('scroll', handleScroll);
+ return () => window.removeEventListener('scroll', handleScroll);
+ }
+ });
$effect(() => {
isLoading.deploying = false;
@@ -66,7 +94,9 @@
const currentStackId = stack.id;
handleApiResultWithCallbacks({
- result: await tryCatch(environmentAPI.updateStack(currentStackId, composeContent, envContent)),
+ result: await tryCatch(
+ environmentAPI.updateStack(currentStackId, composeContent, envContent)
+ ),
message: 'Failed to Save Compose Project',
setLoadingState: (value) => (isLoading.saving = value),
onSuccess: async (updatedStack: Stack) => {
@@ -80,7 +110,9 @@
await new Promise((resolve) => setTimeout(resolve, 200));
if (updatedStack && updatedStack.id !== currentStackId) {
- console.log(`Stack ID changed from ${currentStackId} to ${updatedStack.id}. Navigating...`);
+ console.log(
+ `Stack ID changed from ${currentStackId} to ${updatedStack.id}. Navigating...`
+ );
await goto(`/compose/${name}`, { invalidateAll: true });
} else {
await invalidateAll();
@@ -103,7 +135,11 @@
return baseServerUrl;
}
- function getServicePortUrl(service: StackService, port: string | number | StackPort, protocol = 'http'): string {
+ function getServicePortUrl(
+ service: StackService,
+ port: string | number | StackPort,
+ protocol = 'http'
+ ): string {
const host = getHostForService(service);
if (typeof port === 'string') {
@@ -164,7 +200,12 @@
<div class="bg-background min-h-screen">
{#if stack}
- <div class="bg-background/95 sticky top-0 z-10 border-b backdrop-blur">
+ <div
+ class="bg-background/95 sticky top-0 z-20 border-b backdrop-blur transition-all duration-300"
+ style="opacity: {showFloatingHeader ? 0 : 1}; pointer-events: {showFloatingHeader
+ ? 'none'
+ : 'auto'};"
+ >
<div class="max-w-full px-4 py-3">
<div class="flex items-center justify-between">
<div class="flex items-center gap-3">
@@ -178,12 +219,38 @@
{stack.name}
</h1>
{#if stack.status}
- <StatusBadge variant={statusVariantMap[stack.status.toLowerCase()] || 'gray'} text={capitalizeFirstLetter(stack.status)} />
+ <StatusBadge
+ variant={statusVariantMap[stack.status.toLowerCase()] || 'gray'}
+ text={capitalizeFirstLetter(stack.status)}
+ />
{/if}
</div>
</div>
+ </div>
+ </div>
+ </div>
- <div class="flex items-center gap-2">
+ {#if showFloatingHeader}
+ <div
+ class="fixed top-4 left-1/2 -translate-x-1/2 z-30 transition-all duration-300 ease-in-out"
+ >
+ <div
+ class="bg-background/90 backdrop-blur-xl border border-border/50 rounded-lg shadow-xl px-4 py-3"
+ >
+ <div class="flex items-center gap-4">
+ <div class="flex items-center gap-2">
+ <h2 class="text-sm font-medium truncate max-w-[150px]" title={stack.name}>
+ {stack.name}
+ </h2>
+ {#if stack.status}
+ <StatusBadge
+ variant={statusVariantMap[stack.status.toLowerCase()] || 'gray'}
+ text={capitalizeFirstLetter(stack.status)}
+ class="text-xs"
+ />
+ {/if}
+ </div>
+ <div class="bg-border h-4 w-px"></div>
<ActionButtons
id={stack.id}
type="stack"
@@ -199,7 +266,7 @@
</div>
</div>
</div>
- </div>
+ {/if}
{#if data.error}
<div class="max-w-full px-4 py-4">
@@ -211,21 +278,25 @@
</div>
{/if}
- <div class="flex h-[calc(100vh-64px)]">
- <div class="bg-background/50 w-48 shrink-0 border-r">
- <div class="sticky top-16 p-3">
+ <div class="flex">
+ <div class="bg-background/50 w-16 shrink-0 border-r">
+ <div class="sticky top-16 p-2">
<nav class="space-y-1">
{#each navigationSections as section}
{@const IconComponent = section.icon}
<button
onclick={() => scrollToSection(section.id)}
- class="flex w-full items-center gap-2 rounded-md px-3 py-2 text-sm font-medium transition-colors
- {activeSection === section.id ? 'bg-primary/10 text-primary border-primary/20 border' : 'text-muted-foreground hover:text-foreground hover:bg-muted/50'}"
+ class="relative flex w-full items-center justify-center rounded-md p-3 text-sm font-medium transition-colors
+ {activeSection === section.id
+ ? 'bg-primary/10 text-primary border-primary/20 border'
+ : 'text-muted-foreground hover:text-foreground hover:bg-muted/50'}"
+ title={section.label}
>
- <IconComponent class="size-4 shrink-0" />
- <span class="truncate">{section.label}</span>
+ <IconComponent class="size-4" />
{#if section.id === 'services' && stack.serviceCount}
- <span class="bg-muted ml-auto shrink-0 rounded px-1.5 py-0.5 text-xs">
+ <span
+ class="bg-primary text-primary-foreground absolute -top-1 -right-1 rounded-full text-xs min-w-[18px] h-[18px] flex items-center justify-center px-1"
+ >
{stack.serviceCount}
</span>
{/if}
@@ -235,7 +306,7 @@
</div>
</div>
- <div class="flex-1 overflow-y-auto">
+ <div class="flex-1" bind:this={mainContainer}>
<div class="max-w-none p-6">
<div class="space-y-8">
<section id="overview" class="scroll-mt-20">
@@ -282,6 +353,39 @@
</div>
</Card.Content>
</Card.Root>
+
+ {#if servicePorts && Object.keys(servicePorts).length > 0}
+ {@const allUniquePorts = [...new Set(Object.values(servicePorts).flat())]}
+ <Card.Root class="border">
+ <Card.Header class="pb-4">
+ <Card.Title>Exposed Ports</Card.Title>
+ </Card.Header>
+ <Card.Content>
+ <div class="flex flex-wrap gap-2">
+ {#each allUniquePorts as port (port)}
+ {@const portValue =
+ typeof port === 'string' ||
+ typeof port === 'number' ||
+ (typeof port === 'object' && port !== null)
+ ? port
+ : String(port)}
+ {@const serviceWithPort = stack.services?.find((s) =>
+ s.ports?.includes(String(port))
+ ) || { container_id: '', name: '', status: '' }}
+ <a
+ href={getServicePortUrl(serviceWithPort, portValue)}
+ target="_blank"
+ rel="noopener noreferrer"
+ class="inline-flex items-center rounded-md bg-blue-500/10 px-3 py-2 font-medium text-blue-600 transition-colors hover:bg-blue-500/20 dark:text-blue-400"
+ >
+ Port {port}
+ <ExternalLink class="ml-2 size-4" />
+ </a>
+ {/each}
+ </div>
+ </Card.Content>
+ </Card.Root>
+ {/if}
</div>
{#if servicePorts && Object.keys(servicePorts).length > 0}
@@ -293,9 +397,21 @@
<Card.Content>
<div class="flex flex-wrap gap-2">
{#each allUniquePorts as port (port)}
- {@const portValue = typeof port === 'string' || typeof port === 'number' || (typeof port === 'object' && port !== null) ? port : String(port)}
- {@const serviceWithPort = stack.services?.find((s) => s.ports?.includes(String(port))) || { container_id: '', name: '', status: '' }}
- <a href={getServicePortUrl(serviceWithPort, portValue)} target="_blank" rel="noopener noreferrer" class="inline-flex items-center rounded-md bg-blue-500/10 px-3 py-2 font-medium text-blue-600 transition-colors hover:bg-blue-500/20 dark:text-blue-400">
+ {@const portValue =
+ typeof port === 'string' ||
+ typeof port === 'number' ||
+ (typeof port === 'object' && port !== null)
+ ? port
+ : String(port)}
+ {@const serviceWithPort = stack.services?.find((s) =>
+ s.ports?.includes(String(port))
+ ) || { container_id: '', name: '', status: '' }}
+ <a
+ href={getServicePortUrl(serviceWithPort, portValue)}
+ target="_blank"
+ rel="noopener noreferrer"
+ class="inline-flex items-center rounded-md bg-blue-500/10 px-3 py-2 font-medium text-blue-600 transition-colors hover:bg-blue-500/20 dark:text-blue-400"
+ >
Port {port}
<ExternalLink class="ml-2 size-4" />
</a>
@@ -312,68 +428,79 @@
Services ({stack.serviceCount})
</h2>
- <Card.Root class="border">
- <Card.Content class="p-6">
- {#if stack.services && stack.services.length > 0}
- <div class="space-y-4">
- {#each stack.services as service (service.container_id || service.name)}
- {@const status = service.status || 'unknown'}
- {@const variant = statusVariantMap[status.toLowerCase()] || 'gray'}
-
- {#if service.container_id}
- <a href={`/containers/${service.container_id}`} class="hover:bg-muted/50 flex items-center justify-between rounded-lg border p-4 transition-colors">
- <div class="flex items-center gap-3">
- <div class="bg-primary/10 rounded-full p-2">
- <Layers class="text-primary size-4" />
- </div>
- <div>
- <p class="font-medium">{service.name}</p>
- <p class="text-muted-foreground text-sm">
- ID: {service.container_id.substring(0, 12)}
- </p>
- {#if service.image}
- <p class="text-muted-foreground text-xs">
- Image: {service.image}
- </p>
- {/if}
- </div>
+ {#if stack.services && stack.services.length > 0}
+ <div class="rounded-lg border bg-card">
+ <div class="grid grid-cols-1 gap-2 p-4 sm:grid-cols-2 lg:grid-cols-3">
+ {#each stack.services as service (service.container_id || service.name)}
+ {@const status = service.status || 'unknown'}
+ {@const variant = statusVariantMap[status.toLowerCase()] || 'gray'}
+
+ {#if service.container_id}
+ <a
+ href={`/containers/${service.container_id}`}
+ class="group flex items-center gap-3 rounded-lg border bg-background p-3 transition-all hover:bg-muted/50"
+ >
+ <div class="bg-primary/10 rounded-full p-2 shrink-0">
+ <Layers class="text-primary size-3" />
+ </div>
+ <div class="min-w-0 flex-1">
+ <div class="flex items-center justify-between">
+ <p class="text-sm font-medium truncate" title={service.name}>
+ {service.name}
+ </p>
+ <ArrowRight
+ class="text-primary size-3 shrink-0 opacity-0 group-hover:opacity-100 transition-opacity"
+ />
</div>
- <div class="flex items-center gap-3">
- <StatusBadge {variant} text={capitalizeFirstLetter(status)} />
- <ArrowRight class="text-primary size-4" />
+ <div class="flex items-center gap-2 mt-1">
+ <StatusBadge
+ {variant}
+ text={capitalizeFirstLetter(status)}
+ class="text-xs"
+ />
+ {#if service.ports && service.ports.length > 0}
+ <span
+ class="bg-muted text-muted-foreground px-1.5 py-0.5 rounded text-xs"
+ >
+ {service.ports.length} port{service.ports.length > 1 ? 's' : ''}
+ </span>
+ {/if}
</div>
- </a>
- {:else}
- <div class="bg-muted/20 flex items-center justify-between rounded-lg border p-4">
- <div class="flex items-center gap-3">
- <div class="bg-muted/50 rounded-full p-2">
- <Layers class="text-muted-foreground size-4" />
- </div>
- <div>
- <p class="font-medium">{service.name}</p>
- <p class="text-muted-foreground text-sm">Not created</p>
- {#if service.image}
- <p class="text-muted-foreground text-xs">
- Image: {service.image}
- </p>
- {/if}
- </div>
+ </div>
+ </a>
+ {:else}
+ <div class="flex items-center gap-3 rounded-lg border bg-muted/10 p-3">
+ <div class="bg-muted/50 rounded-full p-2 shrink-0">
+ <Layers class="text-muted-foreground size-3" />
+ </div>
+ <div class="min-w-0 flex-1">
+ <p class="text-sm font-medium truncate" title={service.name}>
+ {service.name}
+ </p>
+ <div class="flex items-center gap-2 mt-1">
+ <StatusBadge
+ {variant}
+ text={capitalizeFirstLetter(status)}
+ class="text-xs"
+ />
+ <span class="text-muted-foreground text-xs">Not created</span>
</div>
- <StatusBadge {variant} text={capitalizeFirstLetter(status)} />
</div>
- {/if}
- {/each}
- </div>
- {:else}
- <div class="py-12 text-center">
- <div class="bg-muted/50 mx-auto mb-4 flex size-16 items-center justify-center rounded-full">
- <Layers class="text-muted-foreground size-6" />
- </div>
- <div class="text-muted-foreground">No services found for this stack</div>
- </div>
- {/if}
- </Card.Content>
- </Card.Root>
+ </div>
+ {/if}
+ {/each}
+ </div>
+ </div>
+ {:else}
+ <div class="py-12 text-center">
+ <div
+ class="bg-muted/50 mx-auto mb-4 flex size-16 items-center justify-center rounded-full"
+ >
+ <Layers class="text-muted-foreground size-6" />
+ </div>
+ <div class="text-muted-foreground">No services found for this stack</div>
+ </div>
+ {/if}
</section>
<section id="config" class="scroll-mt-20">
@@ -383,54 +510,64 @@
Configuration
</h2>
{#if hasChanges}
- <ArcaneButton action="save" loading={isLoading.saving} onClick={handleSaveChanges} disabled={!hasChanges} label="Save Changes" loadingLabel="Saving..." class="bg-green-600 text-white hover:bg-green-700" />
+ <ArcaneButton
+ action="save"
+ loading={isLoading.saving}
+ onClick={handleSaveChanges}
+ disabled={!hasChanges}
+ label="Save Changes"
+ loadingLabel="Saving..."
+ class="bg-green-600 text-white hover:bg-green-700"
+ />
{/if}
</div>
- <Card.Root class="mb-6 border">
- <Card.Header class="pb-4">
- <Card.Title>Stack Settings</Card.Title>
- </Card.Header>
- <Card.Content>
- <div class="max-w-md">
- <Label for="name" class="mb-2 block">Stack Name</Label>
- <Input type="text" id="name" name="name" bind:value={name} required disabled={isLoading.saving || stack?.status === 'running' || stack?.status === 'partially running'} />
- {#if stack?.status === 'running' || stack?.status === 'partially running'}
- <p class="text-muted-foreground mt-2 text-sm">Stack name cannot be changed while running. Please stop the stack first.</p>
- {/if}
- </div>
- </Card.Content>
- </Card.Root>
+ <div class="mb-6 space-y-2">
+ <Label for="name" class="text-sm font-medium">Stack Name</Label>
+ <div class="max-w-md">
+ <Input
+ type="text"
+ id="name"
+ name="name"
+ bind:value={name}
+ required
+ disabled={isLoading.saving ||
+ stack?.status === 'running' ||
+ stack?.status === 'partially running'}
+ />
+ {#if stack?.status === 'running' || stack?.status === 'partially running'}
+ <p class="text-muted-foreground mt-2 text-sm">
+ Stack name cannot be changed while running. Please stop the stack first.
+ </p>
+ {/if}
+ </div>
+ </div>
<div class="grid grid-cols-1 gap-6 lg:grid-cols-3">
<div class="lg:col-span-2">
- <Card.Root class="h-full border">
- <Card.Header class="flex-shrink-0 pb-4">
- <Card.Title>Docker Compose File</Card.Title>
- </Card.Header>
- <Card.Content class="flex h-full flex-col p-4">
- <div class="h-[590px] w-full flex-shrink-0 overflow-hidden rounded-md">
- <YamlEditor bind:value={composeContent} readOnly={isLoading.saving || isLoading.deploying || isLoading.stopping || isLoading.restarting || isLoading.removing} />
- </div>
- <p class="text-muted-foreground flex-shrink-0 text-sm">
- Edit your <span class="font-medium">compose.yaml</span> file directly. Syntax errors will be highlighted.
- </p>
- </Card.Content>
- </Card.Root>
+ <div class="space-y-4">
+ <h3 class="text-lg font-semibold">Docker Compose File</h3>
+ <div class="h-[590px] w-full overflow-hidden rounded-md">
+ <CodeEditor
+ bind:value={composeContent}
+ language="yaml"
+ placeholder="Enter YAML..."
+ />
+ </div>
+ </div>
</div>
<div class="lg:col-span-1">
- <Card.Root class="h-full border">
- <Card.Header class="flex-shrink-0 pb-4">
- <Card.Title>Environment (.env)</Card.Title>
- </Card.Header>
- <Card.Content class="flex h-full flex-col p-4">
- <div class="h-[590px] w-full flex-shrink-0 overflow-hidden rounded-md">
- <EnvEditor bind:value={envContent} readOnly={isLoading.saving || isLoading.deploying || isLoading.stopping || isLoading.restarting || isLoading.removing} />
- </div>
- <p class="text-muted-foreground flex-shrink-0 text-sm">Define environment variables in KEY=value format.</p>
- </Card.Content>
- </Card.Root>
+ <div class="space-y-4">
+ <h3 class="text-lg font-semibold">Environment (.env)</h3>
+ <div class="h-[590px] w-full overflow-hidden rounded-md">
+ <CodeEditor
+ bind:value={envContent}
+ language="env"
+ placeholder="Enter environment variables..."
+ />
+ </div>
+ </div>
</div>
</div>
</section>
@@ -446,15 +583,26 @@
<input type="checkbox" bind:checked={autoScrollStackLogs} class="size-4" />
Auto-scroll
</label>
- <Button variant="outline" size="sm" onclick={() => stackLogViewer?.clearLogs()}>Clear</Button>
+ <Button variant="outline" size="sm" onclick={() => stackLogViewer?.clearLogs()}
+ >Clear</Button
+ >
{#if isStackLogsStreaming}
<div class="flex items-center gap-2">
<div class="size-2 animate-pulse rounded-full bg-green-500"></div>
<span class="text-sm font-medium text-green-600">Live</span>
</div>
- <Button variant="outline" size="sm" onclick={() => stackLogViewer?.stopLogStream()}>Stop</Button>
+ <Button
+ variant="outline"
+ size="sm"
+ onclick={() => stackLogViewer?.stopLogStream()}>Stop</Button
+ >
{:else}
- <Button variant="outline" size="sm" onclick={() => stackLogViewer?.startLogStream()} disabled={!stack?.id}>Start</Button>
+ <Button
+ variant="outline"
+ size="sm"
+ onclick={() => stackLogViewer?.startLogStream()}
+ disabled={!stack?.id}>Start</Button
+ >
{/if}
<Button
variant="outline"
@@ -498,7 +646,10 @@
<FileStack class="text-muted-foreground size-10" />
</div>
<h2 class="mb-3 text-2xl font-medium">Stack Not Found</h2>
- <p class="text-muted-foreground mb-8 max-w-md text-center">Could not load stack data. It may have been removed or the Docker engine is not accessible.</p>
+ <p class="text-muted-foreground mb-8 max-w-md text-center">
+ Could not load stack data. It may have been removed or the Docker engine is not
+ accessible.
+ </p>
<Button variant="outline" href="/compose">
<ArrowLeft class="mr-2 size-4" />
Back to Stacks
diff --git a/frontend/src/routes/compose/new/+page.svelte b/frontend/src/routes/compose/new/+page.svelte
index 3982a2aa5..a22fdbba9 100644
--- a/frontend/src/routes/compose/new/+page.svelte
+++ b/frontend/src/routes/compose/new/+page.svelte
@@ -1,24 +1,20 @@
<script lang="ts">
- import * as Card from '$lib/components/ui/card/index.js';
import { Button } from '$lib/components/ui/button/index.js';
- import { ArrowLeft, FileStack, Terminal, Copy, Loader2, Wand } from '@lucide/svelte';
- import * as Breadcrumb from '$lib/components/ui/breadcrumb/index.js';
+ import { ArrowLeft, Terminal, Copy, Loader2, Wand } from '@lucide/svelte';
import { Input } from '$lib/components/ui/input/index.js';
import { Label } from '$lib/components/ui/label/index.js';
- import { goto, invalidateAll } from '$app/navigation'; // Import invalidateAll
+ import { goto, invalidateAll } from '$app/navigation';
import { toast } from 'svelte-sonner';
- import YamlEditor from '$lib/components/yaml-editor.svelte';
+ import CodeEditor from '$lib/components/editor.svelte';
import { preventDefault } from '$lib/utils/form.utils';
import { tryCatch } from '$lib/utils/try-catch';
import { handleApiResultWithCallbacks } from '$lib/utils/api.util';
- import EnvEditor from '$lib/components/env-editor.svelte';
import { defaultEnvTemplate, defaultComposeTemplate } from '$lib/constants';
import ArcaneButton from '$lib/components/arcane-button.svelte';
import { Textarea } from '$lib/components/ui/textarea/index.js';
- import DropdownCard from '$lib/components/dropdown-card.svelte';
- import * as Resizable from '$lib/components/ui/resizable/index.js';
+ import * as Dialog from '$lib/components/ui/dialog/index.js';
import TemplateSelectionDialog from '$lib/components/dialogs/template-selection-dialog.svelte';
- import { environmentAPI, converterAPI, templateAPI } from '$lib/services/api';
+ import { environmentAPI, converterAPI } from '$lib/services/api';
import type { Template } from '$lib/types/template.type';
import type { PageProps } from './+page';
@@ -27,6 +23,7 @@
let saving = $state(false);
let converting = $state(false);
let showTemplateDialog = $state(false);
+ let showConverterDialog = $state(false);
let isLoadingTemplateContent = $state(false);
let name = $state('');
@@ -68,16 +65,14 @@
toast.success('Docker run command converted successfully!');
dockerRunCommand = '';
+ showConverterDialog = false;
}
});
}
async function handleTemplateSelect(template: Template) {
- showTemplateDialog = false; // Close the dialog immediately
+ showTemplateDialog = false;
- // The template object passed here already has content and envContent
- // because the TemplateSelectionDialog now calls getTemplateContent
- // before calling onSelect.
composeContent = template.content;
if (template.envContent) {
envContent = template.envContent;
@@ -89,11 +84,6 @@
name = template.name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
}
toast.success(`Template "${template.name}" loaded successfully!`);
-
- // No need for isLoadingTemplateContent state or API call here anymore
- // as the dialog handles fetching content before calling onSelect.
- // The state was primarily for the API call within this function.
- // Keep it if other parts of the page depend on it.
}
const exampleCommands = [
@@ -107,125 +97,110 @@
}
</script>
-<div class="space-y-6 pb-8">
- <div class="flex flex-col justify-between gap-4 sm:flex-row sm:items-center">
- <div>
- <Breadcrumb.Root>
- <Breadcrumb.List>
- <Breadcrumb.Item>
- <Breadcrumb.Link href="/">Dashboard</Breadcrumb.Link>
- </Breadcrumb.Item>
- <Breadcrumb.Separator />
- <Breadcrumb.Item>
- <Breadcrumb.Link href="/compose">Compose</Breadcrumb.Link>
- </Breadcrumb.Item>
- <Breadcrumb.Separator />
- <Breadcrumb.Item>
- <Breadcrumb.Page>New Project</Breadcrumb.Page>
- </Breadcrumb.Item>
- </Breadcrumb.List>
- </Breadcrumb.Root>
-
- <h1 class="mt-2 text-2xl font-bold tracking-tight">Create New Compose Project</h1>
- </div>
- </div>
-
- <!-- Docker Run to Compose Converter -->
- <DropdownCard
- id="docker-run-converter"
- title="Docker Run to Compose Converter"
- description="Convert existing docker run commands to Docker Compose format"
- icon={Terminal}
- >
- <div class="space-y-4">
- <div class="space-y-2">
- <Label for="dockerRunCommand">Docker Run Command</Label>
- <Textarea
- id="dockerRunCommand"
- bind:value={dockerRunCommand}
- placeholder="docker run -d --name my-app -p 8080:80 nginx:alpine"
- rows={3}
- disabled={converting}
- class="font-mono text-sm"
- />
- </div>
-
- <div class="flex items-center gap-2">
- <Button
- type="button"
- disabled={!dockerRunCommand.trim() || converting}
- size="sm"
- onclick={handleConvertDockerRun}
- >
- {#if converting}
- <Loader2 class="mr-2 size-4 animate-spin" />
- Converting...
- {:else}
- <Wand class="mr-2 size-4" />
- Convert to Compose
- {/if}
- </Button>
- </div>
+<div class="bg-background min-h-screen">
+ <div class="bg-background/95 sticky top-0 z-20 border-b backdrop-blur">
+ <div class="max-w-full px-4 py-3">
+ <div class="flex items-center justify-between">
+ <div class="flex items-center gap-3">
+ <Button variant="ghost" size="sm" href="/compose">
+ <ArrowLeft class="mr-2 size-4" />
+ Back
+ </Button>
+ <div class="bg-border h-4 w-px"></div>
+ <div class="flex items-center gap-2">
+ <h1 class="text-lg font-semibold">Create New Compose Project</h1>
+ </div>
+ </div>
+ <div class="flex items-center gap-2">
+ <Dialog.Root bind:open={showConverterDialog}>
+ <Dialog.Trigger>
+ <Button
+ variant="outline"
+ class="arcane-button-restart"
+ disabled={saving || converting || isLoadingTemplateContent}
+ >
+ <Terminal class="mr-2 size-4" />
+ Convert Docker Run
+ </Button>
+ </Dialog.Trigger>
+ <Dialog.Content class="sm:max-w-[800px] max-h-[80vh]">
+ <Dialog.Header>
+ <Dialog.Title>Docker Run to Compose Converter</Dialog.Title>
+ <Dialog.Description>
+ Convert existing docker run commands to Docker Compose format
+ </Dialog.Description>
+ </Dialog.Header>
+ <div class="space-y-4 max-h-[60vh] overflow-y-auto">
+ <div class="space-y-2">
+ <Label for="dockerRunCommand">Docker Run Command</Label>
+ <Textarea
+ id="dockerRunCommand"
+ bind:value={dockerRunCommand}
+ placeholder="docker run -d --name my-app -p 8080:80 nginx:alpine"
+ rows={3}
+ disabled={converting}
+ class="font-mono text-sm"
+ />
+ </div>
- <div class="space-y-2">
- <Label class="text-muted-foreground text-xs">Example Commands:</Label>
- <div class="space-y-1">
- {#each exampleCommands as command}
- <Button
- type="button"
- variant="ghost"
- size="sm"
- class="h-auto w-full justify-start p-2 text-left font-mono text-xs"
- onclick={() => useExample(command)}
- >
- <Copy class="mr-2 size-3" />
- {command}
- </Button>
- {/each}
+ <div class="space-y-2">
+ <Label class="text-muted-foreground text-xs">Example Commands:</Label>
+ <div class="space-y-1">
+ {#each exampleCommands as command}
+ <Button
+ type="button"
+ variant="ghost"
+ size="sm"
+ class="h-auto w-full justify-start p-2 text-left font-mono text-xs break-all whitespace-normal"
+ onclick={() => useExample(command)}
+ >
+ <Copy class="mr-2 size-3 shrink-0" />
+ <span class="truncate">{command}</span>
+ </Button>
+ {/each}
+ </div>
+ </div>
+ </div>
+ <div class="flex w-full justify-end pt-4">
+ <Button
+ type="button"
+ disabled={!dockerRunCommand.trim() || converting}
+ onclick={handleConvertDockerRun}
+ >
+ {#if converting}
+ <Loader2 class="mr-2 size-4 animate-spin" />
+ Converting...
+ {:else}
+ <Wand class="mr-2 size-4" />
+ Convert to Compose
+ {/if}
+ </Button>
+ </div>
+ </Dialog.Content>
+ </Dialog.Root>
+ <ArcaneButton
+ action="template"
+ onClick={() => (showTemplateDialog = true)}
+ loading={saving || isLoadingTemplateContent}
+ disabled={saving || converting || isLoadingTemplateContent}
+ />
+ <ArcaneButton
+ action="create"
+ onClick={handleSubmit}
+ loading={saving}
+ disabled={!name || !composeContent || saving || converting || isLoadingTemplateContent}
+ />
</div>
</div>
</div>
- </DropdownCard>
+ </div>
- <form class="space-y-6" onsubmit={preventDefault(handleSubmit)}>
- <Card.Root class="border shadow-sm">
- <Card.Header>
- <div class="flex w-full items-center justify-between">
- <div class="flex items-center gap-3">
- <div class="bg-primary/10 rounded-full p-2">
- <FileStack class="text-primary size-5" />
- </div>
- <div>
- <Card.Title>Compose Project Configuration</Card.Title>
- <Card.Description
- >Create a new Docker Compose Project with environment variables</Card.Description
- >
- </div>
- </div>
- <div class="flex items-center gap-2">
- <ArcaneButton
- action="template"
- onClick={() => (showTemplateDialog = true)}
- loading={saving || isLoadingTemplateContent}
- disabled={saving || converting || isLoadingTemplateContent}
- />
- <ArcaneButton
- action="create"
- onClick={handleSubmit}
- loading={saving}
- disabled={!name ||
- !composeContent ||
- saving ||
- converting ||
- isLoadingTemplateContent}
- />
- </div>
- </div>
- </Card.Header>
- <Card.Content>
- <div class="space-y-4">
- <div class="grid w-full max-w-sm items-center gap-1.5">
- <Label for="name">Compose Project Name</Label>
+ <div class="max-w-none p-6">
+ <div class="space-y-8">
+ <form class="space-y-6" onsubmit={preventDefault(handleSubmit)}>
+ <div class="mb-6 space-y-2">
+ <Label for="name" class="text-sm font-medium">Stack Name</Label>
+ <div class="max-w-md">
<Input
type="text"
id="name"
@@ -236,50 +211,40 @@
disabled={saving || isLoadingTemplateContent}
/>
</div>
+ </div>
- <Resizable.PaneGroup direction="horizontal">
- <Resizable.Pane>
- <div class="mr-3 space-y-2">
- <Label for="compose-editor" class="mb-2">Docker Compose File</Label>
- <div class="mt-2 h-[550px] overflow-hidden rounded-md border">
- <YamlEditor
- bind:value={composeContent}
- readOnly={saving || isLoadingTemplateContent}
- />
- </div>
+ <div class="grid grid-cols-1 gap-6 lg:grid-cols-3">
+ <div class="lg:col-span-2">
+ <div class="space-y-4">
+ <h3 class="text-lg font-semibold">Docker Compose File</h3>
+ <div class="h-[590px] w-full overflow-hidden rounded-md">
+ <CodeEditor
+ bind:value={composeContent}
+ language="yaml"
+ placeholder="Enter YAML..."
+ readOnly={saving || isLoadingTemplateContent}
+ />
</div>
- </Resizable.Pane>
- <Resizable.Handle />
- <Resizable.Pane defaultSize={25}>
- <div class="ml-3 space-y-2">
- <Label for="env-editor" class="mb-2">Environment Configuration (.env)</Label>
- <div class="mt-2 h-[550px] overflow-hidden rounded-md border">
- <!-- Add a unique key to force re-render -->
- {#key `env-${envContent.length}`}
- <EnvEditor
- bind:value={envContent}
- readOnly={saving || isLoadingTemplateContent}
- />
- {/key}
- </div>
+ </div>
+ </div>
+
+ <div class="lg:col-span-1">
+ <div class="space-y-4">
+ <h3 class="text-lg font-semibold">Environment (.env)</h3>
+ <div class="h-[590px] w-full overflow-hidden rounded-md">
+ <CodeEditor
+ bind:value={envContent}
+ language="env"
+ placeholder="Enter environment variables..."
+ readOnly={saving || isLoadingTemplateContent}
+ />
</div>
- </Resizable.Pane>
- </Resizable.PaneGroup>
+ </div>
+ </div>
</div>
- </Card.Content>
- <Card.Footer class="flex justify-between">
- <Button
- variant="outline"
- type="button"
- onclick={() => window.history.back()}
- disabled={saving || isLoadingTemplateContent}
- >
- <ArrowLeft class="mr-2 size-4" />
- Cancel
- </Button>
- </Card.Footer>
- </Card.Root>
- </form>
+ </form>
+ </div>
+ </div>
</div>
<TemplateSelectionDialog
diff --git a/frontend/src/routes/images/[imageId]/+page.svelte b/frontend/src/routes/images/[imageId]/+page.svelte
index 172f83e82..a745fb2a9 100644
--- a/frontend/src/routes/images/[imageId]/+page.svelte
+++ b/frontend/src/routes/images/[imageId]/+page.svelte
@@ -24,11 +24,26 @@
refreshing: false
});
- const shortId = $derived(image?.Id.split(':')[1]?.substring(0, 12) || 'N/A');
- const createdDate = $derived(image?.Created ? formatDate(new Date(image.Created * 1000).toISOString()) : 'N/A');
+ const shortId = $derived(image?.Id?.split(':')[1]?.substring(0, 12) || 'N/A');
+
+ const createdDate = $derived(() => {
+ if (!image?.Created) {
+ return 'N/A';
+ }
+ try {
+ const date = new Date(image.Created);
+ if (isNaN(date.getTime())) {
+ return 'N/A';
+ }
+ return formatDate(date.toISOString());
+ } catch {
+ return 'N/A';
+ }
+ });
+
const imageSize = $derived(formatBytes(image?.Size || 0));
- const architecture = $derived(image?.Manifests?.[0]?.ImageData?.Platform?.architecture || 'N/A');
- const osName = $derived(image?.Manifests?.[0]?.ImageData?.Platform?.os || 'N/A');
+ const architecture = $derived(image?.Architecture || 'N/A');
+ const osName = $derived(image?.Os || 'N/A');
async function handleImageRemove(id: string) {
openConfirmDialog({
@@ -76,7 +91,13 @@
</div>
<div class="flex flex-wrap gap-2">
- <ArcaneButton action="remove" onClick={() => handleImageRemove(image.Id)} loading={isLoading.removing} disabled={isLoading.removing} size="sm" />
+ <ArcaneButton
+ action="remove"
+ onClick={() => handleImageRemove(image.Id)}
+ loading={isLoading.removing}
+ disabled={isLoading.removing}
+ size="sm"
+ />
</div>
</div>
@@ -90,7 +111,9 @@
<div class="grid grid-cols-1 gap-6 sm:grid-cols-2 lg:grid-cols-3">
<!-- ID -->
<div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-gray-500/10 p-2">
+ <div
+ class="flex size-10 shrink-0 items-center justify-center rounded-full bg-gray-500/10 p-2"
+ >
<Hash class="size-5 text-gray-500" />
</div>
<div class="min-w-0 flex-1">
@@ -101,7 +124,9 @@
<!-- Size -->
<div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-blue-500/10 p-2">
+ <div
+ class="flex size-10 shrink-0 items-center justify-center rounded-full bg-blue-500/10 p-2"
+ >
<HardDrive class="size-5 text-blue-500" />
</div>
<div class="min-w-0 flex-1">
@@ -112,18 +137,22 @@
<!-- Created -->
<div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-green-500/10 p-2">
+ <div
+ class="flex size-10 shrink-0 items-center justify-center rounded-full bg-green-500/10 p-2"
+ >
<Clock class="size-5 text-green-500" />
</div>
<div class="min-w-0 flex-1">
<p class="text-muted-foreground text-sm font-medium">Created</p>
- <p class="mt-1 text-base font-semibold">{createdDate}</p>
+ <p class="mt-1 text-base font-semibold">{createdDate()}</p>
</div>
</div>
<!-- Architecture -->
<div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-orange-500/10 p-2">
+ <div
+ class="flex size-10 shrink-0 items-center justify-center rounded-full bg-orange-500/10 p-2"
+ >
<Cpu class="size-5 text-orange-500" />
</div>
<div class="min-w-0 flex-1">
@@ -134,7 +163,9 @@
<!-- OS -->
<div class="flex items-start gap-3">
- <div class="flex size-10 shrink-0 items-center justify-center rounded-full bg-indigo-500/10 p-2">
+ <div
+ class="flex size-10 shrink-0 items-center justify-center rounded-full bg-indigo-500/10 p-2"
+ >
<Layers class="size-5 text-indigo-500" />
</div>
<div class="min-w-0 flex-1">
@@ -150,7 +181,9 @@
{#if image.RepoTags && image.RepoTags.length > 0}
<Card.Root class="border shadow-sm">
<Card.Header>
- <Card.Title class="flex items-center gap-2"><Tag class="text-muted-foreground size-5" /> Tags</Card.Title>
+ <Card.Title class="flex items-center gap-2"
+ ><Tag class="text-muted-foreground size-5" /> Tags</Card.Title
+ >
</Card.Header>
<Card.Content>
<div class="flex flex-wrap gap-2">
@@ -163,18 +196,44 @@
{/if}
<!-- Labels Card -->
- {#if image.Labels && Object.keys(image.Labels).length > 0}
+ {#if image.Config?.Labels && Object.keys(image.Config.Labels).length > 0}
<Card.Root class="border shadow-sm">
<Card.Header>
<Card.Title>Labels</Card.Title>
</Card.Header>
<Card.Content class="space-y-2">
- {#each Object.entries(image.Labels) as [key, value] (key)}
+ {#each Object.entries(image.Config.Labels) as [key, value] (key)}
+ <div class="flex flex-col text-sm sm:flex-row sm:items-center">
+ <span class="text-muted-foreground w-full font-medium break-all sm:w-1/4"
+ >{key}:</span
+ >
+ <span class="w-full font-mono text-xs break-all sm:w-3/4 sm:text-sm">{value}</span>
+ </div>
+ {#if !Object.is(Object.keys(image.Config.Labels).length - 1, Object.keys(image.Config.Labels).indexOf(key))}
+ <Separator class="my-2" />
+ {/if}
+ {/each}
+ </Card.Content>
+ </Card.Root>
+ {/if}
+
+ <!-- Environment Variables Card -->
+ {#if image.Config?.Env && image.Config.Env.length > 0}
+ <Card.Root class="border shadow-sm">
+ <Card.Header>
+ <Card.Title>Environment Variables</Card.Title>
+ </Card.Header>
+ <Card.Content class="space-y-2">
+ {#each image.Config.Env as env (env)}
+ {@const [key, ...valueParts] = env.split('=')}
+ {@const value = valueParts.join('=')}
<div class="flex flex-col text-sm sm:flex-row sm:items-center">
- <span class="text-muted-foreground w-full font-medium break-all sm:w-1/4">{key}:</span>
+ <span class="text-muted-foreground w-full font-medium break-all sm:w-1/4"
+ >{key}:</span
+ >
<span class="w-full font-mono text-xs break-all sm:w-3/4 sm:text-sm">{value}</span>
</div>
- {#if !Object.is(Object.keys(image.Labels).length - 1, Object.keys(image.Labels).indexOf(key))}
+ {#if env !== image.Config.Env[image.Config.Env.length - 1]}
<Separator class="my-2" />
{/if}
{/each}
@@ -185,7 +244,13 @@
{:else}
<div class="py-12 text-center">
<p class="text-muted-foreground text-lg font-medium">Image not found.</p>
- <ArcaneButton action="cancel" customLabel="Back to Images" onClick={() => goto('/images')} size="sm" class="mt-4" />
+ <ArcaneButton
+ action="cancel"
+ customLabel="Back to Images"
+ onClick={() => goto('/images')}
+ size="sm"
+ class="mt-4"
+ />
</div>
{/if}
</div>