Skip to content

Modern Docker Management, Designed for Everyone

fix: unable to edit env when synced from git (#2069)

Kyle Mendell4a8d2845daff
diff --git a/backend/internal/services/gitops_sync_service.go b/backend/internal/services/gitops_sync_service.go
index 64e75366f..f7d91b7bd 100644
--- a/backend/internal/services/gitops_sync_service.go
+++ b/backend/internal/services/gitops_sync_service.go
@@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"log/slog"
+ "maps"
"path/filepath"
"strings"
"time"
@@ -14,6 +15,7 @@ import (
bootstraputils "github.com/getarcaneapp/arcane/backend/internal/utils"
"github.com/getarcaneapp/arcane/backend/internal/utils/mapper"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
+ "github.com/getarcaneapp/arcane/backend/pkg/projects"
"github.com/getarcaneapp/arcane/types/gitops"
"gorm.io/gorm"
)
@@ -611,6 +613,10 @@ func (s *GitOpsSyncService) createProjectForSyncInternal(ctx context.Context, sy
return nil, s.failSync(ctx, id, result, sync, actor, "Failed to mark project as GitOps-managed", err.Error())
}
+ if _, err := s.projectService.ApplyGitSyncProjectFiles(ctx, project.ID, composeContent, envContent, actor); err != nil {
+ return nil, s.failSync(ctx, id, result, sync, actor, "Failed to sync project env files", err.Error())
+ }
+
slog.InfoContext(ctx, "Created project for GitOps sync", "projectName", sync.ProjectName, "projectId", project.ID)
// Deploy the project immediately after creation
@@ -647,22 +653,17 @@ func (s *GitOpsSyncService) getOrCreateProjectInternal(ctx context.Context, sync
func (s *GitOpsSyncService) updateProjectForSyncInternal(ctx context.Context, sync *models.GitOpsSync, id string, project *models.Project, composeContent string, envContent *string, result *gitops.SyncResult, actor models.User) error {
// Get current content to see if it changed
oldCompose, oldEnv, _ := s.projectService.GetProjectContent(ctx, project.ID)
- contentChanged := oldCompose != composeContent
- if envContent != nil {
- if oldEnv != *envContent {
- contentChanged = true
- }
- } else if oldEnv != "" {
- contentChanged = true
- }
// Update existing project's compose and env files
- _, err := s.projectService.UpdateProject(ctx, project.ID, nil, &composeContent, envContent, actor)
+ _, err := s.projectService.ApplyGitSyncProjectFiles(ctx, project.ID, composeContent, envContent, actor)
if err != nil {
return s.failSync(ctx, id, result, sync, actor, "Failed to update project files", err.Error())
}
slog.InfoContext(ctx, "Updated project files", "projectName", project.Name, "projectId", project.ID)
+ newCompose, newEnv, _ := s.projectService.GetProjectContent(ctx, project.ID)
+ contentChanged := oldCompose != newCompose || envContentChangedInternal(oldEnv, newEnv)
+
// If content changed and project is running, redeploy
if contentChanged {
details, err := s.projectService.GetProjectDetails(ctx, project.ID)
@@ -676,3 +677,13 @@ func (s *GitOpsSyncService) updateProjectForSyncInternal(ctx context.Context, sy
return nil
}
+
+func envContentChangedInternal(oldEnv, newEnv string) bool {
+ oldEnvMap, oldErr := projects.ParseProjectEnvContent(oldEnv, nil)
+ newEnvMap, newErr := projects.ParseProjectEnvContent(newEnv, nil)
+ if oldErr != nil || newErr != nil {
+ return oldEnv != newEnv
+ }
+
+ return !maps.Equal(oldEnvMap, newEnvMap)
+}
diff --git a/backend/internal/services/gitops_sync_service_test.go b/backend/internal/services/gitops_sync_service_test.go
new file mode 100644
index 000000000..5671b0a15
--- /dev/null
+++ b/backend/internal/services/gitops_sync_service_test.go
@@ -0,0 +1,23 @@
+package services
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestEnvContentChangedInternal(t *testing.T) {
+ t.Run("ignores formatting-only changes", func(t *testing.T) {
+ oldEnv := "B=2\nA=1\n# comment\n"
+ newEnv := "A=1\nB=2\n"
+
+ assert.False(t, envContentChangedInternal(oldEnv, newEnv))
+ })
+
+ t.Run("detects semantic changes", func(t *testing.T) {
+ oldEnv := "A=1\nB=2\n"
+ newEnv := "A=1\nB=3\n"
+
+ assert.True(t, envContentChangedInternal(oldEnv, newEnv))
+ })
+}
diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.go
index 4c7a7a4be..89954aaf9 100644
--- a/backend/internal/services/project_service.go
+++ b/backend/internal/services/project_service.go
@@ -82,7 +82,7 @@ func (s *ProjectService) getPathMapper(ctx context.Context) (*pathmapper.PathMap
}
// If hostDir not obtained from mapping, attempt auto-discovery from Docker mounts
- if hostDir == "" {
+ if hostDir == "" && s.dockerService != nil {
if dockerCli, derr := s.dockerService.GetClient(ctx); derr == nil {
absContainerDir, _ := filepath.Abs(containerDirResolved)
if discovery, aerr := docker.GetHostPathForContainerPath(ctx, dockerCli, absContainerDir); aerr == nil && discovery != "" {
@@ -371,17 +371,26 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string
return project.Details{}, err
}
- composeContent, envContent, _ := s.GetProjectContent(ctx, projectID)
+ composeContent, _, _ := s.GetProjectContent(ctx, projectID)
+ envState, err := projects.ReadProjectEnvState(proj.Path)
+ if err != nil {
+ return project.Details{}, fmt.Errorf("failed to read project env state: %w", err)
+ }
var resp project.Details
if err := mapper.MapStruct(proj, &resp); err != nil {
return project.Details{}, fmt.Errorf("failed to map project: %w", err)
}
+ effectiveEnvContent, err := s.resolveStoredEffectiveEnvContentInternal(envState)
+ if err != nil {
+ return project.Details{}, err
+ }
+
resp.CreatedAt = proj.CreatedAt.Format(time.RFC3339)
resp.UpdatedAt = proj.UpdatedAt.Format(time.RFC3339)
resp.ComposeContent = composeContent
- resp.EnvContent = envContent
+ resp.EnvContent = effectiveEnvContent
resp.HasBuildDirective = false
resp.DirName = utils.DerefString(proj.DirName)
resp.GitOpsManagedBy = proj.GitOpsManagedBy
@@ -1849,6 +1858,48 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, na
return &proj, nil
}
+func (s *ProjectService) ApplyGitSyncProjectFiles(ctx context.Context, projectID string, composeContent string, gitEnvContent *string, user models.User) (*models.Project, error) {
+ proj, projectsDirectory, err := s.getProjectForUpdate(ctx, projectID)
+ if err != nil {
+ return nil, err
+ }
+
+ envUpdate, err := s.prepareGitSyncEnvUpdateInternal(proj.Path, gitEnvContent)
+ if err != nil {
+ return nil, fmt.Errorf("failed to resolve git env state: %w", err)
+ }
+
+ if err := s.validateComposeContentForUpdate(ctx, proj.Path, proj.Name, composeContent, envUpdate.effectiveContent); err != nil {
+ return nil, fmt.Errorf("invalid compose file: %w", err)
+ }
+
+ if err := fs.WriteComposeFile(projectsDirectory, proj.Path, composeContent); err != nil {
+ return nil, fmt.Errorf("failed to save compose file: %w", err)
+ }
+ if err := s.persistGitSyncEnvFilesInternal(proj.Path, projectsDirectory, envUpdate); err != nil {
+ return nil, fmt.Errorf("failed to sync git env files: %w", err)
+ }
+ if err := s.db.WithContext(ctx).Save(&proj).Error; err != nil {
+ return nil, fmt.Errorf("failed to update project: %w", err)
+ }
+
+ metadata := models.JSON{
+ "action": "git_sync_update",
+ "projectID": proj.ID,
+ "projectName": proj.Name,
+ "composeUpdated": true,
+ "envUpdated": gitEnvContent != nil,
+ }
+ if gitEnvContent == nil {
+ metadata["envSourceRemoved"] = true
+ }
+ if logErr := s.eventService.LogProjectEvent(ctx, models.EventTypeProjectUpdate, proj.ID, proj.Name, user.ID, user.Username, "0", metadata); logErr != nil {
+ slog.ErrorContext(ctx, "could not log git sync project update action", "error", logErr)
+ }
+
+ return &proj, nil
+}
+
func (s *ProjectService) getProjectForUpdate(ctx context.Context, projectID string) (models.Project, string, error) {
var proj models.Project
if err := s.db.WithContext(ctx).First(&proj, "id = ?", projectID).Error; err != nil {
@@ -1892,14 +1943,25 @@ func (s *ProjectService) withProjectRenameRollback(ctx context.Context, proj *mo
func (s *ProjectService) persistUpdatedProjectFiles(ctx context.Context, proj *models.Project, projectsDirectory string, composeContent, envContent *string) error {
switch {
case composeContent != nil:
- if err := s.validateComposeContentForUpdate(ctx, proj.Path, proj.Name, *composeContent, envContent); err != nil {
+ effectiveEnvContent, err := s.resolveEffectiveEnvContentForUpdateInternal(proj.Path, envContent)
+ if err != nil {
return fmt.Errorf("invalid compose file: %w", err)
}
- if err := fs.SaveOrUpdateProjectFiles(projectsDirectory, proj.Path, *composeContent, envContent); err != nil {
+ if err := s.validateComposeContentForUpdate(ctx, proj.Path, proj.Name, *composeContent, effectiveEnvContent); err != nil {
+ return fmt.Errorf("invalid compose file: %w", err)
+ }
+ if err := fs.WriteComposeFile(projectsDirectory, proj.Path, *composeContent); err != nil {
+ return fmt.Errorf("failed to save project files: %w", err)
+ }
+ if envContent != nil {
+ if err := s.persistEffectiveEnvContentInternal(proj.Path, projectsDirectory, *envContent); err != nil {
+ return fmt.Errorf("failed to save project files: %w", err)
+ }
+ } else if err := s.ensureEffectiveEnvFileInternal(proj.Path, projectsDirectory); err != nil {
return fmt.Errorf("failed to save project files: %w", err)
}
case envContent != nil:
- if err := fs.WriteEnvFile(projectsDirectory, proj.Path, *envContent); err != nil {
+ if err := s.persistEffectiveEnvContentInternal(proj.Path, projectsDirectory, *envContent); err != nil {
return err
}
}
@@ -1907,7 +1969,7 @@ func (s *ProjectService) persistUpdatedProjectFiles(ctx context.Context, proj *m
return nil
}
-func (s *ProjectService) validateComposeContentForUpdate(ctx context.Context, projectPath, projectName, composeContent string, envContent *string) (err error) {
+func (s *ProjectService) validateComposeContentForUpdate(ctx context.Context, projectPath, projectName, composeContent string, effectiveEnvContent *string) (err error) {
defer func() {
if recovered := recover(); recovered != nil {
err = fmt.Errorf("compose file contains invalid syntax: %v", recovered)
@@ -1922,9 +1984,9 @@ func (s *ProjectService) validateComposeContentForUpdate(ctx context.Context, pr
fullEnvMap["PWD"] = absWorkdir
}
- // Prefer the provided new environment content if available, otherwise read from disk.
- if envContent != nil {
- if fileEnv, envErr := projects.ParseProjectEnvContent(*envContent, fullEnvMap); envErr != nil {
+ // Prefer the provided effective environment content if available, otherwise read from disk.
+ if effectiveEnvContent != nil {
+ if fileEnv, envErr := projects.ParseProjectEnvContent(*effectiveEnvContent, fullEnvMap); envErr != nil {
return fmt.Errorf("parse provided env content: %w", envErr)
} else {
maps.Copy(fullEnvMap, fileEnv)
@@ -1948,7 +2010,7 @@ func (s *ProjectService) validateComposeContentForUpdate(ctx context.Context, pr
Environment: composetypes.Mapping(fullEnvMap),
}
- err = withTransientValidationEnvFile(projectPath, envContent, func() error {
+ err = withTransientValidationEnvFile(projectPath, effectiveEnvContent, func() error {
_, loadErr := loader.LoadWithContext(ctx, cfg, func(opts *loader.Options) {
if validationProjectName != "" {
opts.SetProjectName(validationProjectName, true)
@@ -1960,7 +2022,7 @@ func (s *ProjectService) validateComposeContentForUpdate(ctx context.Context, pr
return err
}
-func withTransientValidationEnvFile(projectPath string, envContent *string, run func() error) (err error) {
+func withTransientValidationEnvFile(projectPath string, effectiveEnvContent *string, run func() error) (err error) {
envPath := filepath.Join(projectPath, ".env")
originalContent, readErr := os.ReadFile(envPath)
originalExists := readErr == nil
@@ -1968,11 +2030,11 @@ func withTransientValidationEnvFile(projectPath string, envContent *string, run
return fmt.Errorf("prepare env file for compose validation: %w", readErr)
}
- shouldWrite := envContent != nil || !originalExists
+ shouldWrite := effectiveEnvContent != nil || !originalExists
if shouldWrite {
content := ""
- if envContent != nil {
- content = *envContent
+ if effectiveEnvContent != nil {
+ content = *effectiveEnvContent
}
if writeErr := fs.WriteEnvFile(projectPath, projectPath, content); writeErr != nil {
return fmt.Errorf("prepare env file for compose validation: %w", writeErr)
@@ -1983,7 +2045,7 @@ func withTransientValidationEnvFile(projectPath string, envContent *string, run
switch {
case originalExists:
restoreErr = fs.WriteEnvFile(projectPath, projectPath, string(originalContent))
- case envContent != nil:
+ case effectiveEnvContent != nil:
restoreErr = os.Remove(envPath)
default:
restoreErr = os.Remove(envPath)
@@ -2004,6 +2066,226 @@ func withTransientValidationEnvFile(projectPath string, envContent *string, run
return run()
}
+func (s *ProjectService) resolveEffectiveEnvContentForUpdateInternal(projectPath string, envContent *string) (*string, error) {
+ if envContent != nil {
+ return envContent, nil
+ }
+
+ state, err := projects.ReadProjectEnvState(projectPath)
+ if err != nil {
+ return nil, fmt.Errorf("read project env state: %w", err)
+ }
+
+ effectiveContent, err := s.resolveStoredEffectiveEnvContentInternal(state)
+ if err != nil {
+ return nil, err
+ }
+ if effectiveContent == "" && !state.HasEffective && !state.HasGitSource && !state.HasOverride {
+ return nil, nil
+ }
+
+ return &effectiveContent, nil
+}
+
+func (s *ProjectService) resolveStoredEffectiveEnvContentInternal(state projects.ProjectEnvState) (string, error) {
+ if state.HasEffective {
+ return state.EffectiveContent, nil
+ }
+ if state.HasGitSource || state.HasOverride {
+ effectiveContent, err := projects.BuildEffectiveEnvContent(state.GitContent, state.OverrideContent)
+ if err != nil {
+ return "", fmt.Errorf("build effective env content: %w", err)
+ }
+ return effectiveContent, nil
+ }
+ return state.DirectContent, nil
+}
+
+func (s *ProjectService) persistEffectiveEnvContentInternal(projectPath, projectsDirectory, envContent string) error {
+ state, err := projects.ReadProjectEnvState(projectPath)
+ if err != nil {
+ return fmt.Errorf("read project env state: %w", err)
+ }
+
+ if !state.HasGitSource {
+ if state.HasOverride {
+ if err := fs.RemoveProjectFile(projectsDirectory, projectPath, projects.OverrideEnvFileName); err != nil {
+ return err
+ }
+ }
+ return fs.WriteEnvFile(projectsDirectory, projectPath, envContent)
+ }
+
+ overrideContent, err := projects.BuildOverrideEnvContent(state.GitContent, envContent)
+ if err != nil {
+ return fmt.Errorf("build override env content: %w", err)
+ }
+
+ effectiveContent, err := projects.BuildEffectiveEnvContent(state.GitContent, overrideContent)
+ if err != nil {
+ return fmt.Errorf("build effective env content: %w", err)
+ }
+
+ if err := fs.WriteEnvFile(projectsDirectory, projectPath, effectiveContent); err != nil {
+ return err
+ }
+
+ if strings.TrimSpace(overrideContent) == "" {
+ if err := fs.RemoveProjectFile(projectsDirectory, projectPath, projects.OverrideEnvFileName); err != nil {
+ return err
+ }
+ } else if err := fs.WriteProjectFile(projectsDirectory, projectPath, projects.OverrideEnvFileName, overrideContent); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (s *ProjectService) ensureEffectiveEnvFileInternal(projectPath, projectsDirectory string) error {
+ state, err := projects.ReadProjectEnvState(projectPath)
+ if err != nil {
+ return fmt.Errorf("read project env state: %w", err)
+ }
+
+ if !state.HasGitSource {
+ if state.HasOverride {
+ if err := fs.RemoveProjectFile(projectsDirectory, projectPath, projects.OverrideEnvFileName); err != nil {
+ return err
+ }
+ effectiveContent, err := s.resolveStoredEffectiveEnvContentInternal(state)
+ if err != nil {
+ return err
+ }
+ return fs.WriteEnvFile(projectsDirectory, projectPath, effectiveContent)
+ }
+ return fs.EnsureEnvFile(projectsDirectory, projectPath)
+ }
+
+ effectiveContent, err := projects.BuildEffectiveEnvContent(state.GitContent, state.OverrideContent)
+ if err != nil {
+ return fmt.Errorf("build effective env content: %w", err)
+ }
+
+ return fs.WriteEnvFile(projectsDirectory, projectPath, effectiveContent)
+}
+
+type gitSyncEnvUpdateInternal struct {
+ state projects.ProjectEnvState
+ gitEnvContent *string
+ overrideContent string
+ effectiveContent *string
+}
+
+func (s *ProjectService) prepareGitSyncEnvUpdateInternal(projectPath string, gitEnvContent *string) (gitSyncEnvUpdateInternal, error) {
+ state, err := projects.ReadProjectEnvState(projectPath)
+ if err != nil {
+ return gitSyncEnvUpdateInternal{}, fmt.Errorf("read project env state: %w", err)
+ }
+
+ update := gitSyncEnvUpdateInternal{
+ state: state,
+ gitEnvContent: gitEnvContent,
+ }
+
+ if gitEnvContent == nil {
+ effectiveContent, err := s.resolveStoredEffectiveEnvContentInternal(state)
+ if err != nil {
+ return gitSyncEnvUpdateInternal{}, err
+ }
+ if effectiveContent == "" && !state.HasEffective && !state.HasGitSource && !state.HasOverride {
+ return update, nil
+ }
+ update.effectiveContent = &effectiveContent
+ return update, nil
+ }
+
+ overrideContent, err := s.resolveOverrideContentForGitSyncInternal(state, *gitEnvContent)
+ if err != nil {
+ return gitSyncEnvUpdateInternal{}, err
+ }
+ update.overrideContent = overrideContent
+
+ effectiveContent, err := projects.BuildEffectiveEnvContent(*gitEnvContent, overrideContent)
+ if err != nil {
+ return gitSyncEnvUpdateInternal{}, fmt.Errorf("build effective env content: %w", err)
+ }
+ update.effectiveContent = &effectiveContent
+
+ return update, nil
+}
+
+func (s *ProjectService) resolveOverrideContentForGitSyncInternal(state projects.ProjectEnvState, gitEnvContent string) (string, error) {
+ switch {
+ case state.HasGitSource:
+ overrideContent, err := projects.BuildOverrideEnvContent(state.GitContent, state.OverrideContent)
+ if err != nil {
+ return "", fmt.Errorf("build override env content: %w", err)
+ }
+ return overrideContent, nil
+ case state.HasOverride:
+ effectiveContent, err := s.resolveStoredEffectiveEnvContentInternal(state)
+ if err != nil {
+ return "", err
+ }
+ overrideContent, err := projects.BuildOverrideEnvContent(gitEnvContent, effectiveContent)
+ if err != nil {
+ return "", fmt.Errorf("build override env content: %w", err)
+ }
+ return overrideContent, nil
+ case strings.TrimSpace(state.DirectContent) != "":
+ overrideContent, err := projects.BuildAdditiveOverrideEnvContent(gitEnvContent, state.DirectContent)
+ if err != nil {
+ return "", fmt.Errorf("build override env content: %w", err)
+ }
+ return overrideContent, nil
+ default:
+ return "", nil
+ }
+}
+
+func (s *ProjectService) persistGitSyncEnvFilesInternal(projectPath, projectsDirectory string, update gitSyncEnvUpdateInternal) error {
+ if update.gitEnvContent == nil {
+ if update.state.HasGitSource {
+ if err := fs.RemoveProjectFile(projectsDirectory, projectPath, projects.GitSourceEnvFileName); err != nil {
+ return err
+ }
+ }
+ if update.state.HasOverride {
+ if err := fs.RemoveProjectFile(projectsDirectory, projectPath, projects.OverrideEnvFileName); err != nil {
+ return err
+ }
+ }
+ if update.effectiveContent != nil || update.state.HasEffective || update.state.HasGitSource || update.state.HasOverride {
+ effectiveContent := ""
+ if update.effectiveContent != nil {
+ effectiveContent = *update.effectiveContent
+ }
+ return fs.WriteEnvFile(projectsDirectory, projectPath, effectiveContent)
+ }
+ return fs.EnsureEnvFile(projectsDirectory, projectPath)
+ }
+
+ if update.effectiveContent == nil {
+ return fmt.Errorf("missing effective env content for git sync update")
+ }
+
+ if err := fs.WriteEnvFile(projectsDirectory, projectPath, *update.effectiveContent); err != nil {
+ return err
+ }
+ if err := fs.WriteProjectFile(projectsDirectory, projectPath, projects.GitSourceEnvFileName, *update.gitEnvContent); err != nil {
+ return err
+ }
+ if strings.TrimSpace(update.overrideContent) == "" {
+ if err := fs.RemoveProjectFile(projectsDirectory, projectPath, projects.OverrideEnvFileName); err != nil {
+ return err
+ }
+ } else if err := fs.WriteProjectFile(projectsDirectory, projectPath, projects.OverrideEnvFileName, update.overrideContent); err != nil {
+ return err
+ }
+
+ return nil
+}
+
func (s *ProjectService) applyProjectRenameIfNeeded(proj *models.Project, name *string, projectsDirectory string) error {
if name == nil {
return nil
diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.go
index 6cbc7c820..a0a0b9ddf 100644
--- a/backend/internal/services/project_service_test.go
+++ b/backend/internal/services/project_service_test.go
@@ -716,6 +716,371 @@ func TestProjectService_UpdateProject_ReturnsEnvParseErrorDuringComposeValidatio
assert.Contains(t, err.Error(), "parse env")
}
+func TestProjectService_UpdateProject_DerivesProjectOverrideEnvWhenGitSourceExists(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "override-edit"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-override-edit"},
+ Name: "override-edit",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ env := "BASE=git\nTOKEN=secret\n"
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, &env, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "TOKEN=secret\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "BASE=git\n")
+ assert.Contains(t, string(effectiveBytes), "TOKEN=secret\n")
+}
+
+func TestProjectService_UpdateProject_DeletingGitBackedKeyFallsBackToGit(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "override-delete"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=local\nLOCAL_ONLY=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nTOKEN=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=local\nLOCAL_ONLY=1\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-override-delete"},
+ Name: "override-delete",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ env := "BASE=git\nLOCAL_ONLY=1\n"
+ updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, &env, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "BASE=git\n")
+ assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
+ assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
+ assert.NotContains(t, string(overrideBytes), "TOKEN=")
+}
+
+func TestProjectService_ApplyGitSyncProjectFiles_MigratesDirectEnvIntoProjectOverride(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "git-sync-migrate"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TOKEN=stale-local\nLOCAL_ONLY=1\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-migrate"},
+ Name: "git-sync-migrate",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ gitEnv := "TOKEN=git\nREMOTE_ONLY=1\n"
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", &gitEnv, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
+
+ gitSourceBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env.git"))
+ require.NoError(t, readErr)
+ assert.Equal(t, gitEnv, string(gitSourceBytes))
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
+ assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
+ assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
+}
+
+func TestProjectService_ApplyGitSyncProjectFiles_NormalizesStaleCopiedGitOverrides(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "git-sync-normalize"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nSHARED=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-normalize"},
+ Name: "git-sync-normalize",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ gitEnv := "BASE=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", &gitEnv, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "TOKEN=local\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "BASE=git-updated\n")
+ assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
+ assert.Contains(t, string(effectiveBytes), "TOKEN=local\n")
+}
+
+func TestProjectService_ApplyGitSyncProjectFiles_RemovesLegacyDeletedGitMasks(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "git-sync-delete-mask"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("TOKEN=git\nSHARED=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=\nLOCAL_ONLY=1\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("LOCAL_ONLY=1\nSHARED=1\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-delete-mask"},
+ Name: "git-sync-delete-mask",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ gitEnv := "TOKEN=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", &gitEnv, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Contains(t, string(effectiveBytes), "TOKEN=git-updated\n")
+ assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
+ assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
+ assert.NotContains(t, string(overrideBytes), "TOKEN=")
+}
+
+func TestProjectService_ApplyGitSyncProjectFiles_RemovesGitEnvSource(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "git-sync-remove"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-git-sync-remove"},
+ Name: "git-sync-remove",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ updated, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n app:\n image: nginx:alpine\n", nil, models.User{
+ BaseModel: models.BaseModel{ID: "u1"},
+ Username: "tester",
+ })
+ require.NoError(t, err)
+ require.NotNil(t, updated)
+
+ _, statErr := os.Stat(filepath.Join(projectPath, ".env.git"))
+ assert.True(t, os.IsNotExist(statErr))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "BASE=git\n", string(effectiveBytes))
+}
+
+func TestProjectService_PersistGitSyncEnvFiles_UsesPreparedState(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "git-sync-prepared-state"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=local\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nTOKEN=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=local\n"), 0o600))
+
+ gitEnv := "BASE=git-updated\nTOKEN=git\nREMOTE=1\n"
+ update, err := svc.prepareGitSyncEnvUpdateInternal(projectPath, &gitEnv)
+ require.NoError(t, err)
+ require.NotNil(t, update.effectiveContent)
+
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=unexpected\n"), 0o600))
+
+ require.NoError(t, svc.persistGitSyncEnvFilesInternal(projectPath, projectsDir, update))
+
+ overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "TOKEN=local\n", string(overrideBytes))
+
+ effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
+ require.NoError(t, readErr)
+ assert.Equal(t, "BASE=git-updated\nREMOTE=1\nTOKEN=local\n", string(effectiveBytes))
+}
+
+func TestProjectService_GetProjectDetails_ReturnsEffectiveEnvContent(t *testing.T) {
+ db := setupProjectTestDB(t)
+ ctx := context.Background()
+
+ projectsDir := t.TempDir()
+ t.Setenv("PROJECTS_DIRECTORY", projectsDir)
+
+ settingsService, err := NewSettingsService(ctx, db)
+ require.NoError(t, err)
+
+ eventService := NewEventService(db, nil, nil)
+ svc := NewProjectService(db, settingsService, eventService, nil, nil, nil)
+
+ dirName := "details-override"
+ projectPath := filepath.Join(projectsDir, dirName)
+ require.NoError(t, os.MkdirAll(projectPath, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=secret\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=secret\n"), 0o600))
+
+ project := &models.Project{
+ BaseModel: models.BaseModel{ID: "proj-details-override"},
+ Name: "details-override",
+ DirName: &dirName,
+ Path: projectPath,
+ Status: models.ProjectStatusStopped,
+ }
+ require.NoError(t, db.Create(project).Error)
+
+ details, err := svc.GetProjectDetails(ctx, project.ID)
+ require.NoError(t, err)
+ assert.Equal(t, "BASE=git\nTOKEN=secret\n", details.EnvContent)
+}
+
func TestProjectService_MergeBuildTags(t *testing.T) {
tags := mergeBuildTags("example/app:latest", []string{"example/app:sha", "example/app:latest", " "})
assert.Equal(t, []string{"example/app:latest", "example/app:sha"}, tags)
diff --git a/backend/internal/utils/fs/fs_writer.go b/backend/internal/utils/fs/fs_writer.go
index 30d72edfd..b4710d957 100644
--- a/backend/internal/utils/fs/fs_writer.go
+++ b/backend/internal/utils/fs/fs_writer.go
@@ -1,9 +1,11 @@
package fs
import (
+ "errors"
"fmt"
"os"
"path/filepath"
+ "strings"
"github.com/getarcaneapp/arcane/backend/internal/common"
)
@@ -69,9 +71,7 @@ func WriteComposeFile(projectsRoot, dirPath, content string) error {
return nil
}
-// WriteEnvFile writes a .env file to the specified directory
-// projectsRoot is the allowed root directory to prevent path traversal attacks
-func WriteEnvFile(projectsRoot, dirPath, content string) error {
+func WriteProjectFile(projectsRoot, dirPath, fileName, content string) error {
// Security: Validate dirPath is absolute and clean to prevent path traversal
absPath, err := filepath.Abs(dirPath)
if err != nil {
@@ -87,21 +87,71 @@ func WriteEnvFile(projectsRoot, dirPath, content string) error {
rootAbs = filepath.Clean(rootAbs)
if !IsSafeSubdirectory(rootAbs, dirPath) {
- return fmt.Errorf("refusing to write env file: path outside projects root")
+ return fmt.Errorf("refusing to write project file: path outside projects root")
}
if err := os.MkdirAll(dirPath, common.DirPerm); err != nil {
return fmt.Errorf("failed to create directory: %w", err)
}
- envPath := filepath.Join(dirPath, ".env")
- if err := os.WriteFile(envPath, []byte(content), common.FilePerm); err != nil {
- return fmt.Errorf("failed to write env file: %w", err)
+ if fileName == "" || filepath.Base(fileName) != fileName || strings.Contains(fileName, string(filepath.Separator)) {
+ return fmt.Errorf("invalid project file name %q", fileName)
+ }
+
+ targetPath := filepath.Join(dirPath, fileName)
+ if err := os.WriteFile(targetPath, []byte(content), common.FilePerm); err != nil {
+ return fmt.Errorf("failed to write project file %s: %w", fileName, err)
}
return nil
}
+func RemoveProjectFile(projectsRoot, dirPath, fileName string) error {
+ absPath, err := filepath.Abs(dirPath)
+ if err != nil {
+ return fmt.Errorf("failed to resolve directory path: %w", err)
+ }
+ dirPath = filepath.Clean(absPath)
+
+ rootAbs, err := filepath.Abs(projectsRoot)
+ if err != nil {
+ return fmt.Errorf("failed to resolve projects root: %w", err)
+ }
+ rootAbs = filepath.Clean(rootAbs)
+
+ if !IsSafeSubdirectory(rootAbs, dirPath) {
+ return fmt.Errorf("refusing to remove project file: path outside projects root")
+ }
+
+ if fileName == "" || filepath.Base(fileName) != fileName || strings.Contains(fileName, string(filepath.Separator)) {
+ return fmt.Errorf("invalid project file name %q", fileName)
+ }
+
+ targetPath := filepath.Join(dirPath, fileName)
+ if err := os.Remove(targetPath); err != nil && !errors.Is(err, os.ErrNotExist) {
+ return fmt.Errorf("failed to remove project file %s: %w", fileName, err)
+ }
+
+ return nil
+}
+
+// WriteEnvFile writes a .env file to the specified directory
+// projectsRoot is the allowed root directory to prevent path traversal attacks
+func WriteEnvFile(projectsRoot, dirPath, content string) error {
+ return WriteProjectFile(projectsRoot, dirPath, ".env", content)
+}
+
+func EnsureEnvFile(projectsRoot, dirPath string) error {
+ envPath := filepath.Join(dirPath, ".env")
+ if _, err := os.Stat(envPath); err == nil {
+ return nil
+ } else if !errors.Is(err, os.ErrNotExist) {
+ return fmt.Errorf("failed to stat env file: %w", err)
+ }
+
+ return WriteEnvFile(projectsRoot, dirPath, "")
+}
+
// WriteProjectFiles writes both compose and env files to a project directory.
// An empty .env file is always created to prevent compose-go from failing when
// the compose file references env_file: .env
@@ -119,11 +169,8 @@ func WriteProjectFiles(projectsRoot, dirPath, composeContent string, envContent
return err
}
} else {
- envPath := filepath.Join(dirPath, ".env")
- if _, err := os.Stat(envPath); os.IsNotExist(err) {
- if err := WriteEnvFile(projectsRoot, dirPath, ""); err != nil {
- return err
- }
+ if err := EnsureEnvFile(projectsRoot, dirPath); err != nil {
+ return err
}
}
diff --git a/backend/pkg/projects/env.go b/backend/pkg/projects/env.go
index 3bf370420..cd0eee82d 100644
--- a/backend/pkg/projects/env.go
+++ b/backend/pkg/projects/env.go
@@ -6,8 +6,10 @@ import (
"fmt"
"io"
"log/slog"
+ "maps"
"os"
"path/filepath"
+ "sort"
"strings"
"time"
@@ -16,9 +18,11 @@ import (
)
const (
- globalEnvFileName = ".env.global"
- projectEnvFileName = ".env"
- globalEnvHeader = `# Global Environment Variables
+ GlobalEnvFileName = ".env.global"
+ EffectiveEnvFileName = ".env"
+ GitSourceEnvFileName = ".env.git"
+ OverrideEnvFileName = "project.env"
+ globalEnvHeader = `# Global Environment Variables
# These variables are available to all projects
# Created: %s
@@ -27,6 +31,26 @@ const (
type EnvMap = map[string]string
+type ProjectEnvMode string
+
+const (
+ ProjectEnvModeDirect ProjectEnvMode = "direct"
+ ProjectEnvModeOverride ProjectEnvMode = "override"
+)
+
+type ProjectEnvState struct {
+ Mode ProjectEnvMode
+ EditableFileName string
+ EditableContent string
+ EffectiveContent string
+ DirectContent string
+ HasEffective bool
+ GitContent string
+ HasGitSource bool
+ OverrideContent string
+ HasOverride bool
+}
+
type EnvLoader struct {
projectsDir string
workdir string
@@ -49,7 +73,7 @@ func (l *EnvLoader) LoadEnvironment(ctx context.Context) (envMap EnvMap, injecti
envMap = l.loadProcessEnv()
injectionVars = make(EnvMap)
- globalEnvPath := filepath.Join(l.projectsDir, globalEnvFileName)
+ globalEnvPath := filepath.Join(l.projectsDir, GlobalEnvFileName)
if err := l.ensureGlobalEnvFile(ctx, globalEnvPath); err != nil {
slog.WarnContext(ctx, "Failed to ensure global env file", "path", globalEnvPath, "error", err)
}
@@ -58,7 +82,7 @@ func (l *EnvLoader) LoadEnvironment(ctx context.Context) (envMap EnvMap, injecti
slog.WarnContext(ctx, "Failed to load global env", "path", globalEnvPath, "error", err)
}
- projectEnvPath := filepath.Join(l.workdir, projectEnvFileName)
+ projectEnvPath := filepath.Join(l.workdir, EffectiveEnvFileName)
if err := l.loadAndMergeProjectEnv(ctx, projectEnvPath, envMap, injectionVars); err != nil {
slog.WarnContext(ctx, "Failed to load project env", "path", projectEnvPath, "error", err)
}
@@ -179,6 +203,145 @@ func ParseProjectEnvContent(content string, contextEnv EnvMap) (EnvMap, error) {
return parseEnvWithContext(strings.NewReader(content), contextEnv)
}
+// BuildEffectiveEnvContent merges git and override env sources into the effective
+// .env content written to disk. The output is normalized: comments are dropped,
+// keys are sorted, and values are rewritten with Arcane's formatter.
+func BuildEffectiveEnvContent(gitContent, overrideContent string) (string, error) {
+ contextEnv := make(EnvMap)
+
+ gitEnv, err := ParseProjectEnvContent(gitContent, contextEnv)
+ if err != nil {
+ return "", fmt.Errorf("parse git env content: %w", err)
+ }
+ maps.Copy(contextEnv, gitEnv)
+
+ overrideEnv, err := ParseProjectEnvContent(overrideContent, contextEnv)
+ if err != nil {
+ return "", fmt.Errorf("parse override env content: %w", err)
+ }
+
+ merged := make(EnvMap, len(gitEnv)+len(overrideEnv))
+ maps.Copy(merged, gitEnv)
+ maps.Copy(merged, overrideEnv)
+
+ return formatEnvMapInternal(merged), nil
+}
+
+// BuildOverrideEnvContent derives the editable override file from git-backed and
+// effective env content. The generated output is normalized and does not retain
+// comments or original key ordering.
+func BuildOverrideEnvContent(gitContent, effectiveContent string) (string, error) {
+ return buildOverrideEnvContentInternal(gitContent, effectiveContent)
+}
+
+// BuildAdditiveOverrideEnvContent derives override content from a pre-git local
+// .env file. Like other generated env helpers, the result is normalized and does
+// not preserve comments or original key ordering.
+func BuildAdditiveOverrideEnvContent(gitContent, localContent string) (string, error) {
+ contextEnv := make(EnvMap)
+
+ gitEnv, err := ParseProjectEnvContent(gitContent, contextEnv)
+ if err != nil {
+ return "", fmt.Errorf("parse git env content: %w", err)
+ }
+ maps.Copy(contextEnv, gitEnv)
+
+ localEnv, err := ParseProjectEnvContent(localContent, contextEnv)
+ if err != nil {
+ return "", fmt.Errorf("parse local env content: %w", err)
+ }
+
+ override := make(EnvMap)
+ for key, value := range localEnv {
+ if _, exists := gitEnv[key]; !exists {
+ override[key] = value
+ }
+ }
+
+ return formatEnvMapInternal(override), nil
+}
+
+func buildOverrideEnvContentInternal(gitContent, effectiveContent string) (string, error) {
+ contextEnv := make(EnvMap)
+
+ gitEnv, err := ParseProjectEnvContent(gitContent, contextEnv)
+ if err != nil {
+ return "", fmt.Errorf("parse git env content: %w", err)
+ }
+ maps.Copy(contextEnv, gitEnv)
+
+ effectiveEnv, err := ParseProjectEnvContent(effectiveContent, contextEnv)
+ if err != nil {
+ return "", fmt.Errorf("parse effective env content: %w", err)
+ }
+
+ override := make(EnvMap)
+ for key, value := range effectiveEnv {
+ gitValue, exists := gitEnv[key]
+ switch {
+ case !exists:
+ override[key] = value
+ case value == "":
+ // Empty values for Git-backed keys are treated as deleting the local override,
+ // so the Git value is restored on the next effective merge.
+ continue
+ case gitValue != value:
+ override[key] = value
+ }
+ }
+
+ return formatEnvMapInternal(override), nil
+}
+
+func ReadProjectEnvState(projectPath string) (ProjectEnvState, error) {
+ effectiveContent, hasEffective, err := readOptionalProjectFileInternal(projectPath, EffectiveEnvFileName)
+ if err != nil {
+ return ProjectEnvState{}, err
+ }
+
+ gitContent, hasGitSource, err := readOptionalProjectFileInternal(projectPath, GitSourceEnvFileName)
+ if err != nil {
+ return ProjectEnvState{}, err
+ }
+
+ overrideContent, hasOverride, err := readOptionalProjectFileInternal(projectPath, OverrideEnvFileName)
+ if err != nil {
+ return ProjectEnvState{}, err
+ }
+
+ state := ProjectEnvState{
+ DirectContent: effectiveContent,
+ EffectiveContent: effectiveContent,
+ HasEffective: hasEffective,
+ GitContent: gitContent,
+ HasGitSource: hasGitSource,
+ OverrideContent: overrideContent,
+ HasOverride: hasOverride,
+ }
+
+ if hasGitSource || hasOverride {
+ state.Mode = ProjectEnvModeOverride
+ state.EditableFileName = OverrideEnvFileName
+ state.EditableContent = overrideContent
+
+ if !hasEffective {
+ mergedContent, mergeErr := BuildEffectiveEnvContent(gitContent, overrideContent)
+ if mergeErr != nil {
+ return ProjectEnvState{}, mergeErr
+ }
+ state.EffectiveContent = mergedContent
+ }
+
+ return state, nil
+ }
+
+ state.Mode = ProjectEnvModeDirect
+ state.EditableFileName = EffectiveEnvFileName
+ state.EditableContent = effectiveContent
+
+ return state, nil
+}
+
// parseEnvWithContext parses environment variables from an io.Reader using compose-go's
// dotenv parser with variable expansion using the provided context lookup map.
func parseEnvWithContext(r io.Reader, contextEnv EnvMap) (EnvMap, error) {
@@ -199,3 +362,60 @@ func parseEnvWithContext(r io.Reader, contextEnv EnvMap) (EnvMap, error) {
return EnvMap(envMap), nil
}
+
+func readOptionalProjectFileInternal(projectPath, fileName string) (string, bool, error) {
+ content, err := os.ReadFile(filepath.Join(projectPath, fileName))
+ if err == nil {
+ return string(content), true, nil
+ }
+ if errors.Is(err, os.ErrNotExist) {
+ return "", false, nil
+ }
+ return "", false, fmt.Errorf("read %s: %w", fileName, err)
+}
+
+// formatEnvMapInternal serializes env maps into Arcane's canonical generated
+// format. This is intentionally lossy: comments are omitted and keys are sorted
+// alphabetically to keep persisted merge output stable.
+func formatEnvMapInternal(envMap EnvMap) string {
+ if len(envMap) == 0 {
+ return ""
+ }
+
+ keys := make([]string, 0, len(envMap))
+ for key := range envMap {
+ keys = append(keys, key)
+ }
+ sort.Strings(keys)
+
+ var builder strings.Builder
+ for _, key := range keys {
+ builder.WriteString(key)
+ builder.WriteByte('=')
+ builder.WriteString(formatEnvValueInternal(envMap[key]))
+ builder.WriteByte('\n')
+ }
+
+ return builder.String()
+}
+
+func formatEnvValueInternal(value string) string {
+ if value == "" {
+ return value
+ }
+
+ needsQuotes := strings.ContainsAny(value, " \t\r\n#\"'") || strings.TrimSpace(value) != value
+ if !needsQuotes {
+ return value
+ }
+
+ escaped := strings.NewReplacer(
+ "\\", "\\\\",
+ `"`, `\"`,
+ "\t", `\t`,
+ "\n", `\n`,
+ "\r", `\r`,
+ ).Replace(value)
+
+ return `"` + escaped + `"`
+}
diff --git a/backend/pkg/projects/env_test.go b/backend/pkg/projects/env_test.go
index 9d831fc3e..c45a3bfe1 100644
--- a/backend/pkg/projects/env_test.go
+++ b/backend/pkg/projects/env_test.go
@@ -68,3 +68,103 @@ func TestLoadEnvironment(t *testing.T) {
assert.Equal(t, "project_shared", injectionVars["SHARED_VAR"])
})
}
+
+func TestBuildEffectiveEnvContent(t *testing.T) {
+ gitContent := "BASE_URL=https://example.com\nSHARED=git\n"
+ overrideContent := "API_TOKEN=secret\nSHARED=override\n"
+
+ effective, err := BuildEffectiveEnvContent(gitContent, overrideContent)
+ require.NoError(t, err)
+ assert.Contains(t, effective, "BASE_URL=https://example.com\n")
+ assert.Contains(t, effective, "API_TOKEN=secret\n")
+ assert.Contains(t, effective, "SHARED=override\n")
+ assert.NotContains(t, effective, "SHARED=git\n")
+}
+
+func TestBuildOverrideEnvContent(t *testing.T) {
+ t.Run("includes only values that differ from git", func(t *testing.T) {
+ gitContent := "BASE_URL=https://example.com\nSHARED=git\n"
+ effectiveContent := "BASE_URL=https://example.com\nSHARED=git\nAPI_TOKEN=secret\n"
+
+ override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
+ require.NoError(t, err)
+ assert.Equal(t, "API_TOKEN=secret\n", override)
+ })
+
+ t.Run("falls back to git for removed git variables", func(t *testing.T) {
+ gitContent := "BASE_URL=https://example.com\nREMOVE_ME=1\n"
+ effectiveContent := "BASE_URL=https://example.com\n"
+
+ override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
+ require.NoError(t, err)
+ assert.Equal(t, "", override)
+ })
+
+ t.Run("drops empty overrides for git-backed keys during normalization", func(t *testing.T) {
+ gitContent := "BASE_URL=https://example.com\nREMOVE_ME=1\n"
+ effectiveContent := "BASE_URL=https://example.com\nREMOVE_ME=\nTOKEN=local\n"
+
+ override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
+ require.NoError(t, err)
+ assert.Equal(t, "TOKEN=local\n", override)
+ })
+
+ t.Run("keeps explicit empty local-only values", func(t *testing.T) {
+ gitContent := "BASE_URL=https://example.com\n"
+ effectiveContent := "BASE_URL=https://example.com\nLOCAL_EMPTY=\n"
+
+ override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
+ require.NoError(t, err)
+ assert.Equal(t, "LOCAL_EMPTY=\n", override)
+ })
+
+ t.Run("override derivation keeps local-only keys during migration", func(t *testing.T) {
+ gitContent := "BASE_URL=https://example.com\nREMOTE_ONLY=1\n"
+ effectiveContent := "BASE_URL=https://example.com\nTOKEN=local\n"
+
+ override, err := BuildOverrideEnvContent(gitContent, effectiveContent)
+ require.NoError(t, err)
+ assert.Equal(t, "TOKEN=local\n", override)
+ })
+
+ t.Run("additive migration keeps only local-only keys when a direct env becomes git-managed", func(t *testing.T) {
+ gitContent := "TOKEN=git\nREMOTE_ONLY=1\n"
+ localContent := "TOKEN=stale-local\nLOCAL_ONLY=1\n"
+
+ override, err := BuildAdditiveOverrideEnvContent(gitContent, localContent)
+ require.NoError(t, err)
+ assert.Equal(t, "LOCAL_ONLY=1\n", override)
+ })
+}
+
+func TestReadProjectEnvState(t *testing.T) {
+ t.Run("direct mode uses .env as editable source", func(t *testing.T) {
+ projectDir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, EffectiveEnvFileName), []byte("FOO=bar\n"), common.FilePerm))
+
+ state, err := ReadProjectEnvState(projectDir)
+ require.NoError(t, err)
+ assert.Equal(t, ProjectEnvModeDirect, state.Mode)
+ assert.Equal(t, EffectiveEnvFileName, state.EditableFileName)
+ assert.Equal(t, "FOO=bar\n", state.EditableContent)
+ assert.False(t, state.HasGitSource)
+ assert.False(t, state.HasOverride)
+ })
+
+ t.Run("override mode exposes project.env and git source separately", func(t *testing.T) {
+ projectDir := t.TempDir()
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, EffectiveEnvFileName), []byte("A=1\nB=2\n"), common.FilePerm))
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, GitSourceEnvFileName), []byte("A=1\n"), common.FilePerm))
+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, OverrideEnvFileName), []byte("B=2\n"), common.FilePerm))
+
+ state, err := ReadProjectEnvState(projectDir)
+ require.NoError(t, err)
+ assert.Equal(t, ProjectEnvModeOverride, state.Mode)
+ assert.Equal(t, OverrideEnvFileName, state.EditableFileName)
+ assert.Equal(t, "B=2\n", state.EditableContent)
+ assert.True(t, state.HasGitSource)
+ assert.Equal(t, "A=1\n", state.GitContent)
+ assert.True(t, state.HasOverride)
+ assert.Equal(t, "A=1\nB=2\n", state.EffectiveContent)
+ })
+}
diff --git a/frontend/src/routes/(app)/projects/[projectId]/+page.svelte b/frontend/src/routes/(app)/projects/[projectId]/+page.svelte
index 50ee56f34..27a735f2c 100644
--- a/frontend/src/routes/(app)/projects/[projectId]/+page.svelte
+++ b/frontend/src/routes/(app)/projects/[projectId]/+page.svelte
@@ -94,7 +94,7 @@
!isGitOpsManaged && !isLoading.saving && project?.status !== 'running' && project?.status !== 'partially running'
);
let canEditCompose = $derived(!isGitOpsManaged);
- let canEditEnv = $derived(!isGitOpsManaged);
+ let canEditEnv = true;
let autoScrollStackLogs = $state(true);
@@ -288,6 +288,11 @@
const allComposeContents = $derived.by(() => {
return [$inputs.composeContent.value, ...Object.values(includeFilesState)].filter((value) => value.length > 0);
});
+ const codeEditorContext = $derived({
+ envContent: $inputs.envContent.value,
+ composeContents: allComposeContents,
+ globalVariables: globalVariableMap
+ });
async function refreshProjectDetails() {
if (!projectId) return;
@@ -589,11 +594,7 @@
fileId={`project:${projectId}:compose`}
originalValue={originalComposeContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
{:else if selectedFile === 'env'}
<CodePanel
@@ -608,11 +609,7 @@
fileId={`project:${projectId}:env`}
originalValue={originalEnvContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
{:else}
{@const includeFile = project?.includeFiles?.find((f) => f.relativePath === selectedFile)}
@@ -627,11 +624,7 @@
fileId={`project:${projectId}:include:${includeFile.relativePath}`}
originalValue={originalIncludeFiles[includeFile.relativePath]}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
{/if}
{/if}
@@ -714,11 +707,7 @@
fileId={`project:${projectId}:compose`}
originalValue={originalComposeContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
{:else if selectedFile === 'env'}
<CodePanel
@@ -733,11 +722,7 @@
fileId={`project:${projectId}:env`}
originalValue={originalEnvContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
{:else}
{@const includeFile = project?.includeFiles?.find((f) => f.relativePath === selectedFile)}
@@ -752,11 +737,7 @@
fileId={`project:${projectId}:include:${includeFile.relativePath}`}
originalValue={originalIncludeFiles[includeFile.relativePath]}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
{/if}
{/if}
@@ -799,11 +780,7 @@
fileId={`project:${projectId}:include:${includeFile.relativePath}`}
originalValue={originalIncludeFiles[includeFile.relativePath]}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
{/if}
{:else}
@@ -820,11 +797,7 @@
fileId={`project:${projectId}:compose`}
originalValue={originalComposeContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
<CodePanel
bind:open={envOpen}
@@ -838,11 +811,7 @@
fileId={`project:${projectId}:env`}
originalValue={originalEnvContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
</div>
@@ -872,11 +841,7 @@
fileId={`project:${projectId}:compose`}
originalValue={originalComposeContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
</div>
{/snippet}
@@ -895,11 +860,7 @@
fileId={`project:${projectId}:env`}
originalValue={originalEnvContent}
enableDiff={true}
- editorContext={{
- envContent: $inputs.envContent.value,
- composeContents: allComposeContents,
- globalVariables: globalVariableMap
- }}
+ editorContext={codeEditorContext}
/>
</div>
{/snippet}
diff --git a/tests/spec/project.spec.ts b/tests/spec/project.spec.ts
index a6407ea2e..eda7a7e87 100644
--- a/tests/spec/project.spec.ts
+++ b/tests/spec/project.spec.ts
@@ -36,8 +36,9 @@ async function createProjectViaUI(page: Page, projectName: string) {
await page.getByRole('textbox', { name: 'My New Project' }).fill(projectName);
await page.getByRole('textbox', { name: 'My New Project' }).press('Enter');
- const composeEditor = page.locator('.cm-editor').first();
- const envEditor = page.locator('.cm-editor').nth(1);
+ const visibleEditors = page.locator('.cm-editor:visible');
+ const composeEditor = visibleEditors.first();
+ const envEditor = visibleEditors.nth(1);
await expect(composeEditor).toBeVisible();
await expect(envEditor).toBeVisible();
@@ -284,7 +285,7 @@ test.describe('New Compose Project Page', () => {
await page.getByRole('textbox', { name: 'My New Project' }).fill('syntax-check-project');
await page.getByRole('textbox', { name: 'My New Project' }).press('Enter');
- const composeEditor = page.locator('.cm-editor').first();
+ const composeEditor = page.locator('.cm-editor:visible').first();
await expect(composeEditor).toBeVisible();
await setCodeMirrorValue(page, composeEditor, 'services:\n\tredis:\n\t\timage: redis:latest\n');
@@ -307,8 +308,9 @@ test.describe('New Compose Project Page', () => {
await page.getByRole('textbox', { name: 'My New Project' }).fill('env-check-project');
await page.getByRole('textbox', { name: 'My New Project' }).press('Enter');
- const composeEditor = page.locator('.cm-editor').first();
- const envEditor = page.locator('.cm-editor').nth(1);
+ const visibleEditors = page.locator('.cm-editor:visible');
+ const composeEditor = visibleEditors.first();
+ const envEditor = visibleEditors.nth(1);
await expect(composeEditor).toBeVisible();
await expect(envEditor).toBeVisible();
@@ -337,12 +339,12 @@ test.describe('New Compose Project Page', () => {
await page.getByRole('textbox', { name: 'My New Project' }).fill(projectName);
await page.getByRole('textbox', { name: 'My New Project' }).press('Enter');
- const composeEditor = page.locator('.cm-editor').first();
+ const composeEditor = page.locator('.cm-editor:visible').first();
await expect(composeEditor).toBeVisible();
await setCodeMirrorValue(page, composeEditor, TEST_COMPOSE_YAML);
await expect(composeEditor).toContainText(/redis/i);
- const envEditor = page.locator('.cm-editor').nth(1);
+ const envEditor = page.locator('.cm-editor:visible').nth(1);
await expect(envEditor).toBeVisible();
await setCodeMirrorValue(page, envEditor, envFile);
await expect(envEditor).toContainText(/redis/i);
@@ -509,7 +511,7 @@ test.describe('New Compose Project Page', () => {
await page.getByRole('textbox', { name: 'My New Project' }).fill(projectName);
await page.getByRole('textbox', { name: 'My New Project' }).press('Enter');
- const composeEditor = page.locator('.cm-editor').first();
+ const composeEditor = page.locator('.cm-editor:visible').first();
await expect(composeEditor).toBeVisible();
await setCodeMirrorValue(page, composeEditor, TEST_COMPOSE_YAML);
@@ -619,11 +621,13 @@ test.describe('GitOps Managed Project', () => {
await page.waitForLoadState('networkidle');
await page.waitForTimeout(800);
- const composeContent = page.locator('.cm-editor').first().locator('.cm-content');
+ const composeContent = page.locator('.cm-editor:visible').first().locator('.cm-content');
await expect(composeContent).toHaveAttribute('aria-readonly', 'true');
});
- test('should have env editor in read-only mode when GitOps managed', async ({ page }) => {
+ test('should allow editing env editor when GitOps managed in classic and tree view', async ({
+ page
+ }) => {
const gitOpsProject = realProjects.find((p) => p.gitOpsManagedBy);
test.skip(!gitOpsProject, 'No GitOps-managed projects found');
@@ -635,8 +639,33 @@ test.describe('GitOps Managed Project', () => {
await page.waitForLoadState('networkidle');
await page.waitForTimeout(800);
- const envContent = page.locator('.cm-editor').nth(1).locator('.cm-content');
- await expect(envContent).toHaveAttribute('aria-readonly', 'true');
+ const envEditor = page.locator('.cm-editor:visible').nth(1);
+ const envContent = envEditor.locator('.cm-content');
+ const marker = `ARCANE_E2E_${Date.now()}`;
+ const originalEnv = await envContent.evaluate((node) => (node as HTMLElement).innerText ?? '');
+ const updatedEnv = `${originalEnv.trimEnd()}\n${marker}=1\n`;
+
+ await expect(envContent).not.toHaveAttribute('aria-readonly', 'true');
+ await setCodeMirrorValue(page, envEditor, updatedEnv);
+ await expect(envEditor).toContainText(marker);
+ await expect(page.getByRole('button', { name: 'Save', exact: true }).first()).toBeVisible();
+
+ const layoutSwitch = page.getByRole('switch', {
+ name: /Classic|Tree View/i
+ });
+ if (await layoutSwitch.count()) {
+ await layoutSwitch.click();
+ await page.waitForLoadState('networkidle');
+
+ const envFileButton = page.getByRole('button', { name: '.env' }).first();
+ await expect(envFileButton).toBeVisible();
+ await envFileButton.click();
+
+ const treeEnvEditor = page.locator('.cm-editor:visible').first();
+ const treeEnvContent = treeEnvEditor.locator('.cm-content');
+ await expect(treeEnvContent).not.toHaveAttribute('aria-readonly', 'true');
+ await expect(treeEnvEditor).toContainText(marker);
+ }
});
test('should allow editing for non-GitOps managed projects', async ({ page }) => {