Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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, syreturn 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, syncfunc (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 changedoldCompose, 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, redeployif contentChanged {details, err := s.projectService.GetProjectDetails(ctx, project.ID)@@ -676,3 +677,13 @@ func (s *GitOpsSyncService) updateProjectForSyncInternal(ctx context.Context, syreturn 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.gonew file mode 100644index 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.goindex 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 stringreturn 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.Detailsif 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 = effectiveEnvContentresp.HasBuildDirective = falseresp.DirName = utils.DerefString(proj.DirName)resp.GitOpsManagedBy = proj.GitOpsManagedBy@@ -1849,6 +1858,48 @@ func (s *ProjectService) UpdateProject(ctx context.Context, projectID string, nareturn &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.Projectif err := s.db.WithContext(ctx).First(&proj, "id = ?", projectID).Error; err != nil {@@ -1892,14 +1943,25 @@ func (s *ProjectService) withProjectRenameRollback(ctx context.Context, proj *mofunc (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 *mreturn 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, prfullEnvMap["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, prEnvironment: 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, prreturn 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, runreturn fmt.Errorf("prepare env file for compose validation: %w", readErr)}- shouldWrite := envContent != nil || !originalExists+ shouldWrite := effectiveEnvContent != nil || !originalExistsif 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, runswitch {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, runreturn 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 nildiff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.goindex 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_ReturnsEnvParseErrorDuringComposeValidatioassert.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.goindex 30d72edfd..b4710d957 100644--- a/backend/internal/utils/fs/fs_writer.go+++ b/backend/internal/utils/fs/fs_writer.go@@ -1,9 +1,11 @@package fsimport (+ "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 traversalabsPath, 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, envContentreturn 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.goindex 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 stringworkdir string@@ -49,7 +73,7 @@ func (l *EnvLoader) LoadEnvironment(ctx context.Context) (envMap EnvMap, injectienvMap = 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, injectislog.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.goindex 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.svelteindex 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}/><CodePanelbind: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.tsindex 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 }) => {