Skip to content

Modern Docker Management, Designed for Everyone

feat(autoupdate/compose): implement docker compose aware update logic (#1875)

Alessandrocea81408118b
diff --git a/backend/internal/huma/handlers/updater.go b/backend/internal/huma/handlers/updater.go
index 072ae073d..2452470aa 100644
--- a/backend/internal/huma/handlers/updater.go
+++ b/backend/internal/huma/handlers/updater.go
@@ -104,7 +104,7 @@ func RegisterUpdater(api huma.API, updaterService *services.UpdaterService) {
Method: http.MethodPost,
Path: "/environments/{id}/containers/{containerId}/update",
Summary: "Update a single container",
- Description: "Pull the latest image and recreate a specific container",
+ Description: "Pull the latest image and apply the appropriate update strategy for a specific container",
Tags: []string{"Updater", "Containers"},
Security: []map[string][]string{
{"BearerAuth": {}},
@@ -177,7 +177,7 @@ func (h *UpdaterHandler) GetUpdaterHistory(ctx context.Context, input *GetUpdate
}, nil
}
-// UpdateContainer updates a single container by pulling the latest image and recreating it.
+// UpdateContainer updates a single container by pulling the latest image and applying the appropriate update flow.
func (h *UpdaterHandler) UpdateContainer(ctx context.Context, input *UpdateContainerInput) (*UpdateContainerOutput, error) {
if h.updaterService == nil {
return nil, huma.Error500InternalServerError("service not available")
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 3df6b9c53..6d522e02d 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -11,6 +11,7 @@ import (
"os"
"path/filepath"
"strings"
+ "sync"
"time"
"github.com/compose-spec/compose-go/v2/dotenv"
@@ -42,6 +43,9 @@ type ProjectService struct {
imageService *ImageService
dockerService *DockerClientService
buildService *BuildService
+
+ composeNameCacheMu sync.RWMutex
+ composeNameToProjID map[string]string
}
func NewProjectService(db *database.DB, settingsService *SettingsService, eventService *EventService, imageService *ImageService, dockerService *DockerClientService, buildService *BuildService) *ProjectService {
@@ -205,6 +209,96 @@ func normalizeComposeProjectName(name string) string {
return normalized
}
+func (s *ProjectService) getCachedComposeProjectIDInternal(normalizedName string) (string, bool) {
+ if normalizedName == "" {
+ return "", false
+ }
+
+ s.composeNameCacheMu.RLock()
+ defer s.composeNameCacheMu.RUnlock()
+
+ if s.composeNameToProjID == nil {
+ return "", false
+ }
+
+ projectID, ok := s.composeNameToProjID[normalizedName]
+ return projectID, ok
+}
+
+func (s *ProjectService) cacheComposeProjectIDInternal(normalizedName, projectID string) {
+ if normalizedName == "" || projectID == "" {
+ return
+ }
+
+ s.composeNameCacheMu.Lock()
+ defer s.composeNameCacheMu.Unlock()
+
+ if s.composeNameToProjID == nil {
+ s.composeNameToProjID = make(map[string]string)
+ }
+ s.composeNameToProjID[normalizedName] = projectID
+}
+
+func (s *ProjectService) invalidateCachedComposeProjectIDInternal(normalizedName string) {
+ if normalizedName == "" {
+ return
+ }
+
+ s.composeNameCacheMu.Lock()
+ defer s.composeNameCacheMu.Unlock()
+
+ delete(s.composeNameToProjID, normalizedName)
+}
+
+func (s *ProjectService) lookupProjectByCachedComposeNameInternal(ctx context.Context, normalizedName string) (*models.Project, bool, error) {
+ projectID, ok := s.getCachedComposeProjectIDInternal(normalizedName)
+ if !ok {
+ return nil, false, nil
+ }
+
+ var project models.Project
+ if err := s.db.WithContext(ctx).Where("id = ?", projectID).First(&project).Error; err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ s.invalidateCachedComposeProjectIDInternal(normalizedName)
+ return nil, false, nil
+ }
+ if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+ return nil, false, fmt.Errorf("request canceled or timed out: %w", err)
+ }
+ return nil, false, fmt.Errorf("failed to get project by cached compose name: %w", err)
+ }
+ if normalizeComposeProjectName(project.Name) != normalizedName {
+ s.invalidateCachedComposeProjectIDInternal(normalizedName)
+ return nil, false, nil
+ }
+
+ return &project, true, nil
+}
+
+func (s *ProjectService) rebuildComposeNameCacheInternal(ctx context.Context) error {
+ var projects []models.Project
+ if err := s.db.WithContext(ctx).Select("id", "name").Find(&projects).Error; err != nil {
+ return err
+ }
+
+ cache := make(map[string]string, len(projects))
+ for i := range projects {
+ normalizedName := normalizeComposeProjectName(projects[i].Name)
+ if normalizedName == "" {
+ continue
+ }
+ if _, exists := cache[normalizedName]; !exists {
+ cache[normalizedName] = projects[i].ID
+ }
+ }
+
+ s.composeNameCacheMu.Lock()
+ s.composeNameToProjID = cache
+ s.composeNameCacheMu.Unlock()
+
+ return nil
+}
+
func (s *ProjectService) GetProjectFromDatabaseByID(ctx context.Context, id string) (*models.Project, error) {
var project models.Project
if err := s.db.WithContext(ctx).Where("id = ?", id).First(&project).Error; err != nil {
@@ -219,6 +313,102 @@ func (s *ProjectService) GetProjectFromDatabaseByID(ctx context.Context, id stri
return &project, nil
}
+func (s *ProjectService) GetProjectByComposeName(ctx context.Context, name string) (*models.Project, error) {
+ if name == "" {
+ return nil, fmt.Errorf("project name is empty")
+ }
+ normalized := normalizeComposeProjectName(name)
+
+ var proj models.Project
+ err := s.db.WithContext(ctx).Where("name = ? OR name = ?", name, normalized).First(&proj).Error
+ if err == nil {
+ s.cacheComposeProjectIDInternal(normalized, proj.ID)
+ return &proj, nil
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("failed to get project by name: %w", err)
+ }
+
+ if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeNameInternal(ctx, normalized); cacheErr != nil {
+ return nil, cacheErr
+ } else if found {
+ return cachedProject, nil
+ }
+
+ if err := s.rebuildComposeNameCacheInternal(ctx); err != nil {
+ return nil, fmt.Errorf("failed to list projects by compose name: %w", err)
+ }
+
+ if cachedProject, found, cacheErr := s.lookupProjectByCachedComposeNameInternal(ctx, normalized); cacheErr != nil {
+ return nil, cacheErr
+ } else if found {
+ return cachedProject, nil
+ }
+
+ return nil, fmt.Errorf("project not found: %s", name)
+}
+
+func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user models.User) error {
+ projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)
+ if err != nil {
+ return err
+ }
+
+ // 1. Load project
+ projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")
+ projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))
+ if err != nil {
+ projectsDirectory = "/app/data/projects"
+ }
+
+ pathMapper, _ := s.getPathMapper(ctx)
+ autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)
+ compProj, _, err := projects.LoadComposeProjectFromDir(ctx, projectFromDb.Path, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)
+ if err != nil {
+ return fmt.Errorf("failed to load compose project: %w", err)
+ }
+
+ // 2. Set status to deploying/restarting
+ if err := s.updateProjectStatusInternal(ctx, projectID, models.ProjectStatusDeploying); err != nil {
+ return err
+ }
+
+ // 3. Pull images for specific services
+ if err := projects.ComposePull(ctx, compProj, servicesToUpdate); err != nil {
+ slog.WarnContext(ctx, "compose pull failed, continuing", "error", err)
+ }
+
+ // 4. Stop specific services
+ if err := projects.ComposeStop(ctx, compProj, servicesToUpdate); err != nil {
+ slog.WarnContext(ctx, "compose stop failed, continuing", "error", err)
+ }
+
+ // 5. Up specific services
+ if err := projects.ComposeUp(ctx, compProj, servicesToUpdate, false, false); err != nil {
+ if statusErr := s.updateProjectStatusandCountsInternal(ctx, projectID, models.ProjectStatusStopped); statusErr != nil {
+ slog.ErrorContext(ctx, "UpdateProjectServices: failed to set stopped status after compose up failure", "projectID", projectID, "error", statusErr)
+ }
+ return fmt.Errorf("failed to up services: %w", err)
+ }
+
+ // 6. Finalize status
+ if err := s.updateProjectStatusandCountsInternal(ctx, projectID, models.ProjectStatusRunning); err != nil {
+ return err
+ }
+
+ metadata := models.JSON{
+ "action": "update_services",
+ "projectID": projectID,
+ "projectName": projectFromDb.Name,
+ "services": append([]string(nil), servicesToUpdate...),
+ }
+ if logErr := s.eventService.LogProjectEvent(ctx, models.EventTypeProjectUpdate, projectID, projectFromDb.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.ErrorContext(ctx, "could not log project service update action", "error", logErr)
+ }
+
+ return nil
+}
+
func (s *ProjectService) getServiceCounts(services []ProjectServiceInfo) (total int, running int) {
total = len(services)
for _, service := range services {
@@ -1491,6 +1681,14 @@ func resolveDockerfilePathInternal(svc composetypes.ServiceConfig) (string, erro
return dockerfilePath, nil
}
+func translateBuildPathInternal(path string, pathMapper *projects.PathMapper) (string, error) {
+ if pathMapper == nil || strings.TrimSpace(path) == "" || !filepath.IsAbs(path) {
+ return path, nil
+ }
+
+ return pathMapper.ContainerToHost(path)
+}
+
func buildArgsFromCompose(args map[string]*string) map[string]string {
buildArgs := map[string]string{}
for key, value := range args {
@@ -1623,6 +1821,10 @@ func (s *ProjectService) prepareServiceBuildRequest(
if err != nil {
return imagetypes.BuildRequest{}, updatedSvc, updated, err
}
+ contextDir, err = translateBuildPathInternal(contextDir, pathMapper)
+ if err != nil {
+ return imagetypes.BuildRequest{}, updatedSvc, updated, fmt.Errorf("translate build context for service %s: %w", serviceName, err)
+ }
dockerfileInline := updatedSvc.Build.DockerfileInline
if strings.TrimSpace(updatedSvc.Build.Dockerfile) != "" && strings.TrimSpace(dockerfileInline) != "" {
@@ -1635,6 +1837,10 @@ func (s *ProjectService) prepareServiceBuildRequest(
if err != nil {
return imagetypes.BuildRequest{}, updatedSvc, updated, err
}
+ dockerfilePath, err = translateBuildPathInternal(dockerfilePath, pathMapper)
+ if err != nil {
+ return imagetypes.BuildRequest{}, updatedSvc, updated, fmt.Errorf("translate Dockerfile path for service %s: %w", serviceName, err)
+ }
}
buildReq := imagetypes.BuildRequest{
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
index fa86cd36e..77062ec10 100644
--- a/backend/internal/services/project_service_test.go
+++ b/backend/internal/services/project_service_test.go
@@ -274,6 +274,127 @@ func TestProjectService_NormalizeComposeProjectName(t *testing.T) {
}
}
+func TestProjectService_GetProjectByComposeName(t *testing.T) {
+ ctx := context.Background()
+
+ t.Run("exact match", func(t *testing.T) {
+ db := setupProjectTestDB(t)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil)
+
+ proj := &models.Project{
+ BaseModel: models.BaseModel{ID: "p1"},
+ Name: "myproject",
+ Path: "/tmp/myproject",
+ }
+ require.NoError(t, db.Create(proj).Error)
+
+ found, err := svc.GetProjectByComposeName(ctx, "myproject")
+ require.NoError(t, err)
+ assert.Equal(t, proj.ID, found.ID)
+ })
+
+ t.Run("normalized fallback", func(t *testing.T) {
+ db := setupProjectTestDB(t)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil)
+
+ proj := &models.Project{
+ BaseModel: models.BaseModel{ID: "p1"},
+ Name: "myproject",
+ Path: "/tmp/myproject",
+ }
+ require.NoError(t, db.Create(proj).Error)
+
+ found, err := svc.GetProjectByComposeName(ctx, "My Project!")
+ require.NoError(t, err)
+ assert.Equal(t, proj.ID, found.ID)
+ })
+
+ t.Run("display name in db, normalized compose label input", func(t *testing.T) {
+ db := setupProjectTestDB(t)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil)
+
+ display := &models.Project{
+ BaseModel: models.BaseModel{ID: "p2"},
+ Name: "My Project!",
+ Path: "/tmp/my-project",
+ }
+ require.NoError(t, db.Create(display).Error)
+
+ found, err := svc.GetProjectByComposeName(ctx, "myproject")
+ require.NoError(t, err)
+ assert.Equal(t, display.ID, found.ID)
+ })
+
+ t.Run("invalidates stale normalized cache entries after deletion", func(t *testing.T) {
+ db := setupProjectTestDB(t)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil)
+
+ original := &models.Project{
+ BaseModel: models.BaseModel{ID: "p3"},
+ Name: "My Project!",
+ Path: "/tmp/my-project",
+ }
+ require.NoError(t, db.Create(original).Error)
+
+ found, err := svc.GetProjectByComposeName(ctx, "myproject")
+ require.NoError(t, err)
+ assert.Equal(t, original.ID, found.ID)
+
+ cachedProjectID, cached := svc.getCachedComposeProjectIDInternal("myproject")
+ require.True(t, cached)
+ assert.Equal(t, original.ID, cachedProjectID)
+
+ require.NoError(t, db.Delete(&models.Project{}, "id = ?", original.ID).Error)
+
+ replacement := &models.Project{
+ BaseModel: models.BaseModel{ID: "p4"},
+ Name: "My Project!",
+ Path: "/tmp/my-project-recreated",
+ }
+ require.NoError(t, db.Create(replacement).Error)
+
+ found, err = svc.GetProjectByComposeName(ctx, "myproject")
+ require.NoError(t, err)
+ assert.Equal(t, replacement.ID, found.ID)
+
+ cachedProjectID, cached = svc.getCachedComposeProjectIDInternal("myproject")
+ require.True(t, cached)
+ assert.Equal(t, replacement.ID, cachedProjectID)
+ })
+
+ t.Run("invalidates stale normalized cache entries after rename", func(t *testing.T) {
+ db := setupProjectTestDB(t)
+ svc := NewProjectService(db, nil, nil, nil, nil, nil)
+
+ original := &models.Project{
+ BaseModel: models.BaseModel{ID: "p5"},
+ Name: "My App!",
+ Path: "/tmp/my-app",
+ }
+ require.NoError(t, db.Create(original).Error)
+
+ found, err := svc.GetProjectByComposeName(ctx, "myapp")
+ require.NoError(t, err)
+ assert.Equal(t, original.ID, found.ID)
+
+ cachedProjectID, cached := svc.getCachedComposeProjectIDInternal("myapp")
+ require.True(t, cached)
+ assert.Equal(t, original.ID, cachedProjectID)
+
+ require.NoError(t, db.Model(&models.Project{}).Where("id = ?", original.ID).Updates(map[string]any{
+ "name": "New Service",
+ "path": "/tmp/new-service",
+ }).Error)
+
+ _, err = svc.GetProjectByComposeName(ctx, "myapp")
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "project not found")
+
+ _, cached = svc.getCachedComposeProjectIDInternal("myapp")
+ assert.False(t, cached)
+ })
+}
+
func TestResolveServiceImagePullMode(t *testing.T) {
tests := []struct {
name string
@@ -1346,8 +1467,8 @@ func TestProjectService_PrepareServiceBuildRequest_UsesExecutorVisiblePaths(t *t
)
require.NoError(t, err)
- assert.Equal(t, "/app/data/projects/demo", req.ContextDir)
- assert.Equal(t, "/app/data/projects/demo/Dockerfile.custom", req.Dockerfile)
+ assert.Equal(t, "/docker-data/arcane/projects/demo", req.ContextDir)
+ assert.Equal(t, "/docker-data/arcane/projects/demo/Dockerfile.custom", req.Dockerfile)
}
func TestProjectService_PrepareServiceBuildRequest_UsesInlineDockerfile(t *testing.T) {
diff --git a/backend/internal/services/updater_service.go b/backend/internal/services/updater_service.go
index a263c631f..8f3220970 100644
--- a/backend/internal/services/updater_service.go
+++ b/backend/internal/services/updater_service.go
@@ -392,9 +392,7 @@ func (s *UpdaterService) ApplyPending(ctx context.Context, dryRun bool) (*update
func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID string) (*updater.Result, error) {
start := time.Now()
out := &updater.Result{Items: []updater.ResourceResult{}}
-
slog.InfoContext(ctx, "UpdateSingleContainer: starting", "containerID", containerID)
-
dcli, err := s.dockerService.GetClient(ctx)
if err != nil {
return nil, fmt.Errorf("docker connect: %w", err)
@@ -593,6 +591,50 @@ func (s *UpdaterService) UpdateSingleContainer(ctx context.Context, containerID
}
// Update the container
+ projectName := inspect.Config.Labels["com.docker.compose.project"]
+ serviceName := inspect.Config.Labels["com.docker.compose.service"]
+
+ if projectName != "" && serviceName != "" {
+ slog.InfoContext(ctx, "UpdateSingleContainer: detected compose container, using project-based update", "containerID", containerID, "project", projectName, "service", serviceName)
+
+ proj, err := s.projectService.GetProjectByComposeName(ctx, projectName)
+ if err == nil {
+ // The direct image pull above is still required to compare digests and
+ // skip no-op updates. Compose project updates intentionally pull again
+ // inside UpdateProjectServices to keep project redeploy behavior unified.
+ if err := s.projectService.UpdateProjectServices(ctx, proj.ID, []string{serviceName}, systemUser); err != nil {
+ out.Items = append(out.Items, updater.ResourceResult{
+ ResourceID: targetContainer.ID,
+ ResourceType: "container",
+ ResourceName: containerName,
+ Status: "failed",
+ Error: fmt.Sprintf("project update failed: %v", err),
+ })
+ out.Failed++
+ out.Duration = time.Since(start).String()
+ return out, nil
+ }
+
+ out.Items = append(out.Items, updater.ResourceResult{
+ ResourceID: targetContainer.ID,
+ ResourceType: "container",
+ ResourceName: containerName,
+ Status: "updated",
+ })
+ out.Updated++
+ out.Checked = 1
+ out.Duration = time.Since(start).String()
+
+ // Prune old image if no longer in use
+ if inspectBefore.Image != "" {
+ _ = s.pruneImageIDsWithInUseSetInternal(ctx, []string{inspectBefore.Image}, nil)
+ }
+
+ return out, nil
+ }
+ slog.WarnContext(ctx, "UpdateSingleContainer: compose labels found but project not found in DB, falling back to standalone update", "project", projectName, "err", err)
+ }
+
if err := s.updateContainer(ctx, *targetContainer, inspect, normalizedRef); err != nil {
out.Items = append(out.Items, updater.ResourceResult{
ResourceID: targetContainer.ID,
@@ -1144,6 +1186,15 @@ func (s *UpdaterService) resolveLocalImageIDsForRef(ctx context.Context, ref str
return ids, nil
}
+type restartPlan struct {
+ cnt container.Summary
+ inspect *container.InspectResponse
+ newRef string
+ match string
+ explicit bool
+ implicit bool
+}
+
//nolint:gocognit
func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldIDToNewRef map[string]string, oldRefToNewRef map[string]string) ([]updater.ResourceResult, error) {
dcli, err := s.dockerService.GetClient(ctx)
@@ -1173,15 +1224,6 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
updatedNorm[s.normalizeRef(oldRef)] = nr
}
- type restartPlan struct {
- cnt container.Summary
- inspect *container.InspectResponse
- newRef string
- match string
- explicit bool
- implicit bool
- }
-
plansByName := map[string]*restartPlan{}
markedForRestart := map[string]bool{}
containersWithDeps := make([]libupdater.ContainerWithDeps, 0, len(list))
@@ -1302,6 +1344,45 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
sorted = candidates
}
+ // Pre-scan sorted containers to group compose project services that need updates.
+ // We only group containers that are explicitly marked for restart (p.newRef != "").
+ projectToServices := make(map[string][]string) // projectID -> []serviceName
+ projectToSeenServices := make(map[string]map[string]struct{}) // projectID -> set(serviceName)
+ projectIDToObj := make(map[string]*models.Project)
+ projectNameToID := make(map[string]string)
+
+ for _, cd := range sorted {
+ p := plansByName[cd.Name]
+ if p == nil || p.newRef == "" || p.inspect == nil || p.inspect.Config == nil {
+ continue
+ }
+ projectName := p.inspect.Config.Labels["com.docker.compose.project"]
+ serviceName := p.inspect.Config.Labels["com.docker.compose.service"]
+ if projectName != "" && serviceName != "" {
+ projectID, ok := lookupComposeProjectIDInternal(projectName, projectNameToID)
+ if !ok {
+ proj, err := s.projectService.GetProjectByComposeName(ctx, projectName)
+ if err != nil {
+ continue
+ }
+ projectID = proj.ID
+ projectIDToObj[proj.ID] = proj
+ projectNameToID[proj.Name] = proj.ID
+ projectNameToID[loader.NormalizeProjectName(proj.Name)] = proj.ID
+ }
+ if _, ok := projectToSeenServices[projectID]; !ok {
+ projectToSeenServices[projectID] = make(map[string]struct{})
+ }
+ if _, seen := projectToSeenServices[projectID][serviceName]; !seen {
+ projectToServices[projectID] = append(projectToServices[projectID], serviceName)
+ projectToSeenServices[projectID][serviceName] = struct{}{}
+ }
+ }
+ }
+
+ processedProjectServices := make(map[string]map[string]struct{})
+ projectResults := make(map[string]error) // stores error from the project-level update run
+
var results []updater.ResourceResult
for _, cd := range sorted {
p := plansByName[cd.Name]
@@ -1327,6 +1408,11 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
inspect := inspectResult.Container
inspectCopy := inspect
p.inspect = &inspectCopy
+
+ // If this container belongs to a compose project that was missed during the
+ // pre-scan (inspect was nil), register it now so the main loop routes it
+ // through the compose-aware update path instead of standalone stop/rm/run.
+ s.lazyRegisterComposeProjectInternal(ctx, p, projectNameToID, projectIDToObj, projectToServices, projectToSeenServices)
}
if p.inspect.Config != nil && p.inspect.Config.Labels != nil {
labels = p.inspect.Config.Labels
@@ -1348,7 +1434,7 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
continue
}
- slog.DebugContext(ctx, "restartContainersUsingOldIDs: restarting container", "containerId", p.cnt.ID, "container", name, "match", p.match, "newRef", p.newRef, "implicit", p.implicit)
+ slog.DebugContext(ctx, "restartContainersUsingOldIDs: processing container", "containerId", p.cnt.ID, "container", name, "match", p.match, "newRef", p.newRef, "implicit", p.implicit)
func() {
endContainerStatus := s.beginContainerUpdateInternal(p.cnt.ID)
@@ -1356,7 +1442,47 @@ func (s *UpdaterService) restartContainersUsingOldIDs(ctx context.Context, oldID
endProjectStatus := s.beginProjectUpdateInternal(composeProjectNameFromLabelsInternal(labels))
defer endProjectStatus()
- // Arcane self-updates must go through the detached CLI upgrader.
+ projectName := labels["com.docker.compose.project"]
+ serviceName := labels["com.docker.compose.service"]
+ var proj *models.Project
+ if projectName != "" {
+ if projectID, ok := lookupComposeProjectIDInternal(projectName, projectNameToID); ok {
+ proj = projectIDToObj[projectID]
+ }
+ }
+
+ if proj != nil && serviceName != "" && !libupdater.IsArcaneContainer(labels) {
+ if pErr, failed := projectResults[proj.ID]; failed {
+ res.Status = "failed"
+ res.Error = fmt.Sprintf("project-level update failed: %v", pErr)
+ } else {
+ pendingServices := pendingComposeProjectServicesInternal(processedProjectServices, proj.ID, projectToServices[proj.ID])
+ if len(pendingServices) > 0 {
+ slog.InfoContext(ctx, "restartContainersUsingOldIDs: executing project-level update", "project", proj.Name, "services", pendingServices)
+ err := s.projectService.UpdateProjectServices(ctx, proj.ID, pendingServices, systemUser)
+ markComposeProjectServicesProcessedInternal(processedProjectServices, proj.ID, pendingServices)
+ if err != nil {
+ slog.ErrorContext(ctx, "restartContainersUsingOldIDs: project update failed", "project", proj.Name, "err", err)
+ projectResults[proj.ID] = err
+ }
+ }
+
+ if pErr, failed := projectResults[proj.ID]; failed {
+ res.Status = "failed"
+ res.Error = fmt.Sprintf("project-level update failed: %v", pErr)
+ } else {
+ res.Status = "updated"
+ res.UpdateAvailable = true
+ res.UpdateApplied = true
+ // Send notification
+ if s.notificationService != nil {
+ if notifErr := s.notificationService.SendContainerUpdateNotification(ctx, name, p.newRef, p.match, s.normalizeRef(p.newRef)); notifErr != nil {
+ slog.WarnContext(ctx, "Failed to send container update notification", "containerId", p.cnt.ID, "containerName", name, "imageRef", p.newRef, "error", notifErr.Error())
+ }
+ }
+ }
+ }
+ } else // Arcane self-updates must go through the detached CLI upgrader.
if libupdater.IsArcaneContainer(labels) {
if err := s.triggerSelfUpdateViaCLIInternal(ctx, "restartContainersUsingOldIDs", p.cnt.ID, name, labels); err != nil {
res.Status = "failed"
@@ -1429,6 +1555,80 @@ func (s *UpdaterService) triggerSelfUpdateViaCLIInternal(ctx context.Context, so
return nil
}
+func pendingComposeProjectServicesInternal(processedProjectServices map[string]map[string]struct{}, projectID string, services []string) []string {
+ if len(services) == 0 {
+ return nil
+ }
+
+ processed := processedProjectServices[projectID]
+ pending := make([]string, 0, len(services))
+ for _, service := range services {
+ if processed == nil {
+ pending = append(pending, service)
+ continue
+ }
+ if _, alreadyProcessed := processed[service]; !alreadyProcessed {
+ pending = append(pending, service)
+ }
+ }
+
+ return pending
+}
+
+func markComposeProjectServicesProcessedInternal(processedProjectServices map[string]map[string]struct{}, projectID string, services []string) {
+ if len(services) == 0 {
+ return
+ }
+
+ if _, exists := processedProjectServices[projectID]; !exists {
+ processedProjectServices[projectID] = make(map[string]struct{}, len(services))
+ }
+ for _, service := range services {
+ processedProjectServices[projectID][service] = struct{}{}
+ }
+}
+
+// lazyRegisterComposeProjectInternal registers a compose project into the pre-scan lookup maps when the
+// container's inspect data was unavailable during the pre-scan (inspect was nil at that point).
+// Without this, the main loop's lookupComposeProjectIDInternal call would miss the project and
+// fall through to the destructive standalone stop/rm/run path.
+func (s *UpdaterService) lazyRegisterComposeProjectInternal(
+ ctx context.Context,
+ p *restartPlan,
+ projectNameToID map[string]string,
+ projectIDToObj map[string]*models.Project,
+ projectToServices map[string][]string,
+ projectToSeenServices map[string]map[string]struct{},
+) {
+ if p.newRef == "" || p.inspect == nil || p.inspect.Config == nil {
+ return
+ }
+ projectName := p.inspect.Config.Labels["com.docker.compose.project"]
+ serviceName := p.inspect.Config.Labels["com.docker.compose.service"]
+ if projectName == "" || serviceName == "" {
+ return
+ }
+
+ projectID, registered := lookupComposeProjectIDInternal(projectName, projectNameToID)
+ if !registered {
+ proj, err := s.projectService.GetProjectByComposeName(ctx, projectName)
+ if err != nil {
+ return
+ }
+ projectID = proj.ID
+ projectIDToObj[proj.ID] = proj
+ projectNameToID[proj.Name] = proj.ID
+ projectNameToID[loader.NormalizeProjectName(proj.Name)] = proj.ID
+ }
+ if _, ok := projectToSeenServices[projectID]; !ok {
+ projectToSeenServices[projectID] = make(map[string]struct{})
+ }
+ if _, seen := projectToSeenServices[projectID][serviceName]; !seen {
+ projectToServices[projectID] = append(projectToServices[projectID], serviceName)
+ projectToSeenServices[projectID][serviceName] = struct{}{}
+ }
+}
+
func (s *UpdaterService) beginContainerUpdateInternal(containerID string) func() {
containerID = strings.TrimSpace(containerID)
if containerID == "" {
@@ -1470,6 +1670,17 @@ func composeProjectNameFromLabelsInternal(labels map[string]string) string {
return strings.TrimSpace(labels["com.docker.compose.project"])
}
+func lookupComposeProjectIDInternal(projectName string, projectNameToID map[string]string) (string, bool) {
+ if projectName == "" || len(projectNameToID) == 0 {
+ return "", false
+ }
+ if projectID, ok := projectNameToID[projectName]; ok {
+ return projectID, true
+ }
+ projectID, ok := projectNameToID[loader.NormalizeProjectName(projectName)]
+ return projectID, ok
+}
+
func (s *UpdaterService) statusSnapshotInternal() updater.Status {
s.statusMu.RLock()
defer s.statusMu.RUnlock()
diff --git a/backend/internal/services/updater_service_test.go b/backend/internal/services/updater_service_test.go
index c14840594..5d973197b 100644
--- a/backend/internal/services/updater_service_test.go
+++ b/backend/internal/services/updater_service_test.go
@@ -8,6 +8,7 @@ import (
"testing"
"time"
+ "github.com/compose-spec/compose-go/v2/loader"
"github.com/getarcaneapp/arcane/backend/internal/config"
"github.com/getarcaneapp/arcane/backend/internal/database"
glsqlite "github.com/glebarez/sqlite"
@@ -284,6 +285,96 @@ func TestUpdaterService_UpgradeServiceNotNilCheck(t *testing.T) {
assert.True(t, mockUpgrade.triggerCalled, "Should call CLI upgrade when service is not nil")
}
+func TestLookupComposeProjectIDInternal(t *testing.T) {
+ t.Run("exact match", func(t *testing.T) {
+ projectID, ok := lookupComposeProjectIDInternal("myproject", map[string]string{
+ "myproject": "p1",
+ })
+ require.True(t, ok)
+ assert.Equal(t, "p1", projectID)
+ })
+
+ t.Run("normalized fallback", func(t *testing.T) {
+ projectID, ok := lookupComposeProjectIDInternal("My Project", map[string]string{
+ loader.NormalizeProjectName("myproject"): "p1",
+ })
+ require.True(t, ok)
+ assert.Equal(t, "p1", projectID)
+ })
+
+ t.Run("missing project", func(t *testing.T) {
+ projectID, ok := lookupComposeProjectIDInternal("missing", map[string]string{
+ "other": "p1",
+ })
+ require.False(t, ok)
+ assert.Empty(t, projectID)
+ })
+}
+
+func TestUpdaterService_LazyRegisterComposeProjectInternal_AddsServicesForRegisteredProject(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "p1"},
+ Name: "My Project!",
+ Path: "/tmp/my-project",
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ projectService := NewProjectService(db, nil, nil, nil, nil, nil)
+ svc := &UpdaterService{projectService: projectService}
+
+ projectNameToID := map[string]string{}
+ projectIDToObj := map[string]*models.Project{}
+ projectToServices := map[string][]string{}
+ projectToSeenServices := map[string]map[string]struct{}{}
+
+ firstPlan := &restartPlan{
+ newRef: "nginx:latest",
+ inspect: &container.InspectResponse{
+ Config: &container.Config{
+ Labels: map[string]string{
+ "com.docker.compose.project": "myproject",
+ "com.docker.compose.service": "web",
+ },
+ },
+ },
+ }
+ secondPlan := &restartPlan{
+ newRef: "nginx:latest",
+ inspect: &container.InspectResponse{
+ Config: &container.Config{
+ Labels: map[string]string{
+ "com.docker.compose.project": "myproject",
+ "com.docker.compose.service": "worker",
+ },
+ },
+ },
+ }
+
+ svc.lazyRegisterComposeProjectInternal(ctx, firstPlan, projectNameToID, projectIDToObj, projectToServices, projectToSeenServices)
+ svc.lazyRegisterComposeProjectInternal(ctx, secondPlan, projectNameToID, projectIDToObj, projectToServices, projectToSeenServices)
+
+ require.Contains(t, projectToServices, project.ID)
+ assert.Equal(t, []string{"web", "worker"}, projectToServices[project.ID])
+ assert.Equal(t, project.ID, projectNameToID[project.Name])
+ assert.Equal(t, project.ID, projectNameToID[loader.NormalizeProjectName(project.Name)])
+}
+
+func TestPendingComposeProjectServicesInternal(t *testing.T) {
+ processedProjectServices := map[string]map[string]struct{}{}
+
+ assert.Equal(t, []string{"A"}, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A"}))
+
+ markComposeProjectServicesProcessedInternal(processedProjectServices, "project-1", []string{"A"})
+ assert.Empty(t, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A"}))
+ assert.Equal(t, []string{"B"}, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A", "B"}))
+
+ markComposeProjectServicesProcessedInternal(processedProjectServices, "project-1", []string{"B"})
+ assert.Empty(t, pendingComposeProjectServicesInternal(processedProjectServices, "project-1", []string{"A", "B"}))
+}
+
func TestAnyImageIDsInUseSet(t *testing.T) {
inUseSet := map[string]struct{}{
"sha256:one": {},
diff --git a/backend/pkg/projects/cmds.go b/backend/pkg/projects/cmds.go
index dc453d247..31dd79cb3 100644
--- a/backend/pkg/projects/cmds.go
+++ b/backend/pkg/projects/cmds.go
@@ -42,6 +42,40 @@ func ComposeRestart(ctx context.Context, proj *types.Project, services []string)
return c.svc.Restart(ctx, proj.Name, api.RestartOptions{Services: services})
}
+func ComposePull(ctx context.Context, proj *types.Project, services []string) error {
+ c, err := NewClient(ctx)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = c.Close() }()
+
+ filteredProject, err := filterProjectServicesForPullInternal(proj, services)
+ if err != nil {
+ return err
+ }
+ return c.svc.Pull(ctx, filteredProject, api.PullOptions{})
+}
+
+func filterProjectServicesForPullInternal(proj *types.Project, services []string) (*types.Project, error) {
+ if proj == nil || len(services) == 0 {
+ return proj, nil
+ }
+
+ return proj.WithSelectedServices(services, types.IgnoreDependencies)
+}
+
+func ComposeStop(ctx context.Context, proj *types.Project, services []string) error {
+ if len(services) == 0 {
+ return nil
+ }
+ c, err := NewClient(ctx)
+ if err != nil {
+ return err
+ }
+ defer func() { _ = c.Close() }()
+ return c.svc.Stop(ctx, proj.Name, api.StopOptions{Services: services})
+}
+
func ComposeUp(ctx context.Context, proj *types.Project, services []string, removeOrphans bool, forceRecreate bool) error {
c, err := NewClient(ctx)
if err != nil {
diff --git a/backend/pkg/projects/cmds_test.go b/backend/pkg/projects/cmds_test.go
new file mode 100644
index 000000000..3b051c30f
--- /dev/null
+++ b/backend/pkg/projects/cmds_test.go
@@ -0,0 +1,56 @@
+package projects
+
+import (
+ "context"
+ "testing"
+
+ composetypes "github.com/compose-spec/compose-go/v2/types"
+ "github.com/stretchr/testify/require"
+)
+
+func TestComposeStopSkipsWhenNoServicesSpecified(t *testing.T) {
+ t.Setenv("DOCKER_HOST", "tcp://127.0.0.1:9")
+
+ err := ComposeStop(context.Background(), &composetypes.Project{Name: "test"}, nil)
+ require.NoError(t, err)
+
+ err = ComposeStop(context.Background(), &composetypes.Project{Name: "test"}, []string{})
+ require.NoError(t, err)
+}
+
+func TestFilterProjectServicesForPullInternalReturnsDeepCopiedProject(t *testing.T) {
+ project := &composetypes.Project{
+ Name: "demo",
+ Services: composetypes.Services{
+ "web": {
+ Name: "web",
+ DependsOn: composetypes.DependsOnConfig{
+ "db": {Condition: "service_started"},
+ },
+ },
+ "db": {
+ Name: "db",
+ },
+ },
+ Networks: composetypes.Networks{
+ "default": composetypes.NetworkConfig{
+ Name: "demo_default",
+ },
+ },
+ }
+
+ filtered, err := filterProjectServicesForPullInternal(project, []string{"web"})
+ require.NoError(t, err)
+ require.NotNil(t, filtered)
+
+ require.Contains(t, filtered.Services, "web")
+ require.NotContains(t, filtered.Services, "db")
+
+ web := filtered.Services["web"]
+ delete(web.DependsOn, "db")
+ filtered.Services["web"] = web
+ delete(filtered.Networks, "default")
+
+ require.Contains(t, project.Services["web"].DependsOn, "db")
+ require.Contains(t, project.Networks, "default")
+}
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 7ebac6742..6b8fad51f 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -418,7 +418,7 @@
"containers_update_column": "Updates",
"containers_update_container": "Update Container",
"containers_update_confirm_title": "Update Container",
- "containers_update_confirm_message": "This will pull the latest image and restart the container \"{name}\". Do you want to continue?",
+ "containers_update_confirm_message": "This will pull the latest image and apply the appropriate update for \"{name}\". Do you want to continue?",
"containers_update_pulling_image": "Pulling latest image...",
"containers_update_success": "Container \"{name}\" updated successfully",
"containers_update_failed": "Failed to update container \"{name}\"",
diff --git a/frontend/src/lib/components/arcane-button/arcane-button.svelte b/frontend/src/lib/components/arcane-button/arcane-button.svelte
index 41efa6ed2..2faf1adb5 100644
--- a/frontend/src/lib/components/arcane-button/arcane-button.svelte
+++ b/frontend/src/lib/components/arcane-button/arcane-button.svelte
@@ -81,6 +81,7 @@
this={href ? 'a' : 'button'}
{...rest}
data-slot="arcane-button"
+ data-action={action}
type={href ? undefined : type}
href={href && !disabled ? href : undefined}
disabled={href ? undefined : disabled || loading}
diff --git a/frontend/src/routes/(app)/environments/[id]/+page.svelte b/frontend/src/routes/(app)/environments/[id]/+page.svelte
index 67015fe6f..604b45018 100644
--- a/frontend/src/routes/(app)/environments/[id]/+page.svelte
+++ b/frontend/src/routes/(app)/environments/[id]/+page.svelte
@@ -173,7 +173,7 @@
trivyCpuLimit: z.coerce.number().int(m.security_session_timeout_integer()).nonnegative(),
trivyMemoryLimitMb: z.coerce.number().int().nonnegative(),
trivyConcurrentScanContainers: z.coerce.number().int().min(1, m.security_trivy_concurrent_scan_containers_min()),
- autoUpdateExcludedContainers: z.string(),
+ autoUpdateExcludedContainers: z.string().optional(),
autoHealEnabled: z.boolean(),
autoHealExcludedContainers: z.string(),
autoHealMaxRestarts: z.coerce.number().int().min(1),
diff --git a/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte b/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte
index bead252be..1ccdf7881 100644
--- a/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte
+++ b/frontend/src/routes/(app)/environments/[id]/components/JobsTab.svelte
@@ -52,23 +52,17 @@
return result.data.data;
});
- const excludedContainers = new SvelteSet<string>();
let searchTerm = $state('');
+ let autoHealSearchTerm = $state('');
- $effect(() => {
+ const excludedContainers = $derived.by(() => {
const savedValue = $formInputs.autoUpdateExcludedContainers?.value || '';
- const names = savedValue
- .split(',')
- .map((s: string) => normalizeContainerName(s.trim()))
- .filter(Boolean);
-
- // Synchronize the SvelteSet with the form input value
- // Only update if there are actual changes to avoid unnecessary reactivity
- const currentNames = Array.from(excludedContainers);
- if (names.length !== currentNames.length || names.some((n: string) => !excludedContainers.has(n))) {
- excludedContainers.clear();
- names.forEach((n: string) => excludedContainers.add(n));
- }
+ return new SvelteSet(
+ savedValue
+ .split(',')
+ .map((s: string) => normalizeContainerName(s.trim()))
+ .filter(Boolean)
+ );
});
function resolveSettingsUrl(job: JobStatus, prereq: JobPrerequisite): string | undefined {
@@ -99,46 +93,39 @@
function toggleContainerExclusion(containerName: string) {
const normalizedName = normalizeContainerName(containerName);
- if (excludedContainers.has(normalizedName)) {
- excludedContainers.delete(normalizedName);
+ const newSet = new SvelteSet(excludedContainers);
+ if (newSet.has(normalizedName)) {
+ newSet.delete(normalizedName);
} else {
- excludedContainers.add(normalizedName);
+ newSet.add(normalizedName);
}
- const newValue = Array.from(excludedContainers).join(',');
if ($formInputs.autoUpdateExcludedContainers) {
- $formInputs.autoUpdateExcludedContainers.value = newValue;
+ $formInputs.autoUpdateExcludedContainers.value = Array.from(newSet).join(',');
}
}
- const autoHealExcludedContainers = new SvelteSet<string>();
- let autoHealSearchTerm = $state('');
-
- $effect(() => {
+ const autoHealExcludedContainers = $derived.by(() => {
const savedValue = $formInputs.autoHealExcludedContainers?.value || '';
- const names = savedValue
- .split(',')
- .map((s: string) => normalizeContainerName(s.trim()))
- .filter(Boolean);
-
- const currentNames = Array.from(autoHealExcludedContainers);
- if (names.length !== currentNames.length || names.some((n: string) => !autoHealExcludedContainers.has(n))) {
- autoHealExcludedContainers.clear();
- names.forEach((n: string) => autoHealExcludedContainers.add(n));
- }
+ return new SvelteSet(
+ savedValue
+ .split(',')
+ .map((s: string) => normalizeContainerName(s.trim()))
+ .filter(Boolean)
+ );
});
function toggleAutoHealContainerExclusion(containerName: string) {
const normalizedName = normalizeContainerName(containerName);
- if (autoHealExcludedContainers.has(normalizedName)) {
- autoHealExcludedContainers.delete(normalizedName);
+ const newSet = new SvelteSet(autoHealExcludedContainers);
+ if (newSet.has(normalizedName)) {
+ newSet.delete(normalizedName);
} else {
- autoHealExcludedContainers.add(normalizedName);
+ newSet.add(normalizedName);
}
- const newValue = Array.from(autoHealExcludedContainers).join(',');
if ($formInputs.autoHealExcludedContainers) {
- $formInputs.autoHealExcludedContainers.value = newValue;
+ $formInputs.autoHealExcludedContainers.value = Array.from(newSet).join(',');
}
}
diff --git a/tests/setup/global-teardown.ts b/tests/setup/global-teardown.ts
index ded867275..4aaa68b77 100644
--- a/tests/setup/global-teardown.ts
+++ b/tests/setup/global-teardown.ts
@@ -1,4 +1,4 @@
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
import path from 'node:path';
import fs from 'node:fs';
import { fileURLToPath } from 'node:url';
@@ -36,7 +36,31 @@ async function globalTeardown() {
if (item === '.env.global' || item === 'test-project-static') continue;
if (fs.lstatSync(itemPath).isDirectory()) {
- fs.rmSync(itemPath, { recursive: true, force: true });
+ try {
+ fs.rmSync(itemPath, { recursive: true, force: true });
+ } catch (err: any) {
+ if (err.code === 'EACCES' || err.code === 'EPERM') {
+ // Arcane container creates files as root, fallback to docker to remove them
+ execFileSync(
+ 'docker',
+ [
+ 'run',
+ '--rm',
+ '-v',
+ `${projectsDir}:/projects`,
+ 'alpine',
+ 'sh',
+ '-c',
+ 'rm -rf "/projects/$1"',
+ '--',
+ item
+ ],
+ { stdio: 'inherit' }
+ );
+ } else {
+ throw err;
+ }
+ }
console.log(` - Removed directory: ${item}`);
} else if (item.startsWith('test-project-')) {
fs.unlinkSync(itemPath);
diff --git a/tests/spec/environment-settings.spec.ts b/tests/spec/environment-settings.spec.ts
index 2209bdb20..ca4621627 100644
--- a/tests/spec/environment-settings.spec.ts
+++ b/tests/spec/environment-settings.spec.ts
@@ -79,6 +79,7 @@ test.describe('Environment Settings UI', () => {
test.describe.configure({ mode: 'serial' });
test('should update and save environment details', async ({ page }) => {
+ test.setTimeout(120_000); // 120 seconds timeout for this lengthy UI workflow
const envName = `settings-ui-${Date.now().toString().slice(-5)}`;
const updatedName = `${envName}-updated`;
diff --git a/tests/spec/images.spec.ts b/tests/spec/images.spec.ts
index 087e333c9..f5c3c24b1 100644
--- a/tests/spec/images.spec.ts
+++ b/tests/spec/images.spec.ts
@@ -197,6 +197,8 @@ test.describe('Images Page', () => {
});
test('should pull image via form', async ({ page }) => {
+ test.setTimeout(180_000); // Pulling images can take a long time on CI
+
await navigateToImages(page);
await page.getByRole('button', { name: 'Pull Image' }).click();
diff --git a/tests/spec/volumes.spec.ts b/tests/spec/volumes.spec.ts
index bab9d82f0..2ff8ce39f 100644
--- a/tests/spec/volumes.spec.ts
+++ b/tests/spec/volumes.spec.ts
@@ -65,7 +65,7 @@ async function removeVolumeViaUI(page: Page, volumeName: string) {
await row.locator('a[href*="/volumes/"]').first().click();
await expect(page).toHaveURL(/\/volumes\/.+/);
- await page.getByRole('button', { name: 'Remove', exact: true }).click();
+ await page.locator('button[data-slot="arcane-button"][data-action="remove"]').click();
await page.getByRole('button', { name: 'Remove', exact: true }).last().click();
await expect(
page.locator('li[data-sonner-toast][data-type="success"] div[data-title]')
@@ -150,7 +150,7 @@ test.describe('Volumes Page', () => {
await expect(row).toBeVisible();
await row.locator('a[href*="/volumes/"]').first().click();
await expect(page).toHaveURL(new RegExp(`/volumes/.+`));
- await page.getByRole('button', { name: 'Remove', exact: true }).click();
+ await page.locator('button[data-slot="arcane-button"][data-action="remove"]').click();
await page.getByRole('button', { name: 'Remove', exact: true }).last().click();
await expect(