Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: support custom canonical compose filenames (#2285)
Kyle Mendell8bd1650aeb21
diff --git a/backend/internal/bootstrap/bootstrap.go b/backend/internal/bootstrap/bootstrap.goindex 45959d9c5..0f31af339 100644--- a/backend/internal/bootstrap/bootstrap.go+++ b/backend/internal/bootstrap/bootstrap.go@@ -137,6 +137,9 @@ func initializeStartupState(appCtx context.Context, cfg *config.Config, appServiappServices.GitOpsSync.ListSyncIntervalsRaw,appServices.GitOpsSync.UpdateSyncIntervalMinutes,)+ if err := appServices.GitOpsSync.ReconcileDirectorySyncProjectsOnStartup(appCtx); err != nil {+ slog.WarnContext(appCtx, "Failed to reconcile directory GitOps projects on startup", "error", err)+ }}if err := appServices.Settings.NormalizeProjectsDirectory(appCtx, cfg.ProjectsDirectory); err != nil {diff --git a/backend/internal/common/errors.go b/backend/internal/common/errors.goindex 9b8873db5..1e8fca548 100644--- a/backend/internal/common/errors.go+++ b/backend/internal/common/errors.go@@ -744,6 +744,14 @@ func (e *ProjectFileNotFoundError) Error() string {return "Project file not found"}+type ProjectComposeFileNotFoundError struct {+ Err error+}++func (e *ProjectComposeFileNotFoundError) Error() string {+ return fmt.Sprintf("Project compose file not found: %v", e.Err)+}+type ProjectRedeploymentError struct {Err error}diff --git a/backend/internal/services/gitops_sync_service.go b/backend/internal/services/gitops_sync_service.goindex 8980febf7..892036e1f 100644--- a/backend/internal/services/gitops_sync_service.go+++ b/backend/internal/services/gitops_sync_service.go@@ -1,7 +1,6 @@package servicesimport (- "bytes""context""encoding/json""errors"@@ -13,6 +12,7 @@ import ("strings""time"+ "github.com/getarcaneapp/arcane/backend/internal/common""github.com/getarcaneapp/arcane/backend/internal/database""github.com/getarcaneapp/arcane/backend/internal/models""github.com/getarcaneapp/arcane/backend/pkg/libarcane/startup"@@ -713,6 +713,37 @@ func (s *GitOpsSyncService) SyncAllEnabled(ctx context.Context) error {return nil}+func (s *GitOpsSyncService) ReconcileDirectorySyncProjectsOnStartup(ctx context.Context) error {+ var syncs []models.GitOpsSync+ if err := s.db.WithContext(ctx).+ Where("sync_directory = ?", true).+ Find(&syncs).Error; err != nil {+ return fmt.Errorf("failed to list directory syncs for startup reconciliation: %w", err)+ }++ for i := range syncs {+ originalProjectID := ""+ if syncs[i].ProjectID != nil {+ originalProjectID = *syncs[i].ProjectID+ }++ project, err := s.getDirectorySyncProjectInternal(ctx, &syncs[i])+ if err != nil {+ slog.WarnContext(ctx, "Failed to reconcile directory GitOps sync on startup", "syncId", syncs[i].ID, "error", err)+ continue+ }+ if project == nil {+ continue+ }++ if originalProjectID != project.ID {+ slog.InfoContext(ctx, "Reconciled directory GitOps sync on startup", "syncId", syncs[i].ID, "projectId", project.ID)+ }+ }++ return nil+}+func (s *GitOpsSyncService) BrowseFiles(ctx context.Context, environmentID, id string, path string) (*gitops.BrowseResponse, error) {browseCtx, cancel := context.WithTimeout(ctx, defaultGitSyncTimeout)defer cancel()@@ -849,12 +880,16 @@ func (s *GitOpsSyncService) createProjectForSyncInternal(ctx context.Context, syfunc (s *GitOpsSyncService) getOrCreateProjectInternal(ctx context.Context, sync *models.GitOpsSync, id string, composeContent string, envContent *string, result *gitops.SyncResult, actor models.User) (*models.Project, error) {var project *models.Project- var err errorif sync.ProjectID != nil && *sync.ProjectID != "" {- project, err = s.projectService.GetProjectFromDatabaseByID(ctx, *sync.ProjectID)- if err != nil {- slog.WarnContext(ctx, "Existing project not found, will create new one", "projectId", *sync.ProjectID, "error", err)+ var found bool+ var lookupErr error+ project, found, lookupErr = s.lookupProjectByIDInternal(ctx, *sync.ProjectID)+ if lookupErr != nil {+ return nil, s.failSync(ctx, id, result, sync, actor, "Failed to load existing project", lookupErr.Error())+ }+ if !found {+ slog.WarnContext(ctx, "Existing project not found, will create new one", "projectId", *sync.ProjectID)project = nil}}@@ -1022,7 +1057,7 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync}if project != nil {- if err := copyDirectoryContentsInternal(project.Path, stagePath); err != nil {+ if err := projects.CopyDirectoryContents(project.Path, stagePath); err != nil {_ = os.RemoveAll(stagePath)return nil, fmt.Errorf("failed to stage current project files: %w", err)}@@ -1042,15 +1077,18 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync}composeFileName := filepath.Base(sync.ComposePath)- if err := removeStaleComposeFilesInternal(stagePath, composeFileName, syncedFiles); err != nil {+ if err := projects.RemoveStaleComposeFiles(stagePath, composeFileName, syncedFiles); err != nil {_ = os.RemoveAll(stagePath)return nil, fmt.Errorf("failed to remove stale compose files: %w", err)}- contentsChanged, err := directorySyncContentsChangedInternal(project, syncFiles, oldSyncedFiles, composeFileName)- if err != nil {- _ = os.RemoveAll(stagePath)- return nil, fmt.Errorf("failed to compare staged directory changes: %w", err)+ contentsChanged := true+ if project != nil {+ contentsChanged, err = projects.DirectorySyncContentsChanged(project.Path, syncFiles, oldSyncedFiles, composeFileName)+ if err != nil {+ _ = os.RemoveAll(stagePath)+ return nil, fmt.Errorf("failed to compare staged directory changes: %w", err)+ }}// Write the repo files after cleanup so validation sees the final on-disk@@ -1076,24 +1114,269 @@ func (s *GitOpsSyncService) stageDirectorySyncInternal(ctx context.Context, sync}, nil}+func (s *GitOpsSyncService) lookupProjectByIDInternal(ctx context.Context, projectID string) (*models.Project, bool, error) {+ var project models.Project+ if err := s.db.WithContext(ctx).Where("id = ?", projectID).First(&project).Error; err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, false, nil+ }+ return nil, false, fmt.Errorf("failed to get project %s: %w", projectID, err)+ }++ return &project, true, nil+}++func (s *GitOpsSyncService) lookupProjectByPathInternal(ctx context.Context, projectPath string) (*models.Project, bool, error) {+ var project models.Project+ if err := s.db.WithContext(ctx).Where("path = ?", projectPath).First(&project).Error; err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, false, nil+ }+ return nil, false, fmt.Errorf("failed to get project by path %s: %w", projectPath, err)+ }++ return &project, true, nil+}++func (s *GitOpsSyncService) ensureDirectorySyncProjectLinkedInternal(ctx context.Context, sync *models.GitOpsSync, project *models.Project) error {+ if sync == nil || project == nil {+ return nil+ }++ if project.GitOpsManagedBy != nil && *project.GitOpsManagedBy != "" && *project.GitOpsManagedBy != sync.ID {+ return fmt.Errorf("project %s is already managed by a different GitOps sync", project.ID)+ }++ if sync.ProjectID != nil && *sync.ProjectID == project.ID && project.GitOpsManagedBy != nil && *project.GitOpsManagedBy == sync.ID {+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)+ return nil+ }++ updatesSync := map[string]any{}+ updatesProject := map[string]any{}+ if sync.ProjectID == nil || *sync.ProjectID != project.ID {+ updatesSync["project_id"] = project.ID+ }+ if project.GitOpsManagedBy == nil || *project.GitOpsManagedBy != sync.ID {+ updatesProject["gitops_managed_by"] = sync.ID+ }++ if len(updatesSync) == 0 && len(updatesProject) == 0 {+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)+ return nil+ }++ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ if len(updatesSync) > 0 {+ if err := tx.Model(&models.GitOpsSync{}).Where("id = ?", sync.ID).Updates(updatesSync).Error; err != nil {+ return fmt.Errorf("failed to relink GitOps sync %s: %w", sync.ID, err)+ }+ }+ if len(updatesProject) > 0 {+ if err := tx.Model(&models.Project{}).Where("id = ?", project.ID).Updates(updatesProject).Error; err != nil {+ return fmt.Errorf("failed to relink project %s to GitOps sync %s: %w", project.ID, sync.ID, err)+ }+ }+ return nil+ }); err != nil {+ return err+ }++ sync.ProjectID = &project.ID+ project.GitOpsManagedBy = &sync.ID+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)++ return nil+}++func (s *GitOpsSyncService) findRecoverableManagedProjectInternal(ctx context.Context, sync *models.GitOpsSync) (*models.Project, error) {+ var managedProjects []models.Project+ if err := s.db.WithContext(ctx).+ Where("gitops_managed_by = ?", sync.ID).+ Find(&managedProjects).Error; err != nil {+ return nil, fmt.Errorf("failed to list GitOps-managed projects for sync %s: %w", sync.ID, err)+ }++ matches := make([]models.Project, 0, len(managedProjects))+ for i := range managedProjects {+ project := managedProjects[i]+ if err := s.projectService.ensureProjectPathUnderRoot(ctx, &project, true); err != nil {+ return nil, err+ }+ if _, err := s.projectService.resolveProjectComposeFileInternal(ctx, &project); err != nil {+ if _, ok := errors.AsType[*common.ProjectComposeFileNotFoundError](err); ok {+ continue+ }+ return nil, err+ }+ matches = append(matches, project)+ }++ switch len(matches) {+ case 0:+ return nil, nil+ case 1:+ return &matches[0], nil+ default:+ return nil, fmt.Errorf("multiple GitOps-managed projects match sync %s; refusing automatic relink", sync.ID)+ }+}++func (s *GitOpsSyncService) findUniqueProjectDirectoryCandidateInternal(ctx context.Context, sync *models.GitOpsSync) (string, error) {+ projectsDir, err := s.projectService.getProjectsDirectoryInternal(ctx)+ if err != nil {+ return "", err+ }++ entries, err := os.ReadDir(projectsDir)+ if err != nil {+ return "", fmt.Errorf("failed to list projects directory %s: %w", projectsDir, err)+ }++ composeFileName := strings.TrimSpace(filepath.Base(sync.ComposePath))+ if composeFileName == "" || composeFileName == "." {+ return "", nil+ }++ prefix := projects.SanitizeProjectName(sync.ProjectName)+ matches := make([]string, 0, 1)+ for _, entry := range entries {+ candidatePath := filepath.Join(projectsDir, entry.Name())+ if !projects.IsProjectDirectoryEntry(entry, candidatePath, false) {+ continue+ }+ if prefix != "" && entry.Name() != prefix && !strings.HasPrefix(entry.Name(), prefix+"-") {+ continue+ }++ composePath := filepath.Join(candidatePath, composeFileName)+ if info, statErr := os.Stat(composePath); statErr == nil {+ if !info.IsDir() {+ matches = append(matches, candidatePath)+ }+ } else if !os.IsNotExist(statErr) {+ return "", fmt.Errorf("failed to inspect recovery candidate %s: %w", composePath, statErr)+ }+ }++ switch len(matches) {+ case 0:+ return "", nil+ case 1:+ return matches[0], nil+ default:+ return "", fmt.Errorf("multiple project directories match sync %s; refusing automatic relink", sync.ID)+ }+}++func (s *GitOpsSyncService) createRecoveredProjectFromDirectoryInternal(ctx context.Context, sync *models.GitOpsSync, projectPath string) (*models.Project, error) {+ dirName := filepath.Base(projectPath)+ reason := "Project recovered from existing GitOps-managed directory"+ project := &models.Project{+ Name: sync.ProjectName,+ DirName: &dirName,+ Path: projectPath,+ Status: models.ProjectStatusUnknown,+ StatusReason: &reason,+ ServiceCount: 0,+ RunningCount: 0,+ GitOpsManagedBy: &sync.ID,+ }++ if serviceCount, err := s.projectService.countServicesFromCompose(ctx, *project); err == nil {+ project.ServiceCount = serviceCount+ } else {+ slog.WarnContext(ctx, "Failed to count services while recovering GitOps project", "syncId", sync.ID, "path", projectPath, "error", err)+ }++ if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {+ if err := tx.Create(project).Error; err != nil {+ return fmt.Errorf("failed to create recovered project for sync %s: %w", sync.ID, err)+ }++ if err := tx.Model(&models.GitOpsSync{}).Where("id = ?", sync.ID).Update("project_id", project.ID).Error; err != nil {+ return fmt.Errorf("failed to relink sync %s to recovered project %s: %w", sync.ID, project.ID, err)+ }++ return nil+ }); err != nil {+ return nil, err+ }++ sync.ProjectID = &project.ID+ s.projectService.cacheComposeProjectIDInternal(normalizeComposeProjectName(project.Name), project.ID)++ return project, nil+}++func (s *GitOpsSyncService) recoverProjectFromDirectoryCandidateInternal(ctx context.Context, sync *models.GitOpsSync) (*models.Project, error) {+ projectPath, err := s.findUniqueProjectDirectoryCandidateInternal(ctx, sync)+ if err != nil || projectPath == "" {+ return nil, err+ }++ project, found, err := s.lookupProjectByPathInternal(ctx, projectPath)+ if err != nil {+ return nil, err+ }+ if found {+ if err := s.projectService.ensureProjectPathUnderRoot(ctx, project, true); err != nil {+ return nil, err+ }+ if err := s.ensureDirectorySyncProjectLinkedInternal(ctx, sync, project); err != nil {+ return nil, err+ }+ return project, nil+ }++ return s.createRecoveredProjectFromDirectoryInternal(ctx, sync, projectPath)+}+// getDirectorySyncProjectInternal resolves the linked project for a sync when one// exists, while tolerating deleted/stale project references.func (s *GitOpsSyncService) getDirectorySyncProjectInternal(ctx context.Context, sync *models.GitOpsSync) (*models.Project, error) {- if sync.ProjectID == nil || *sync.ProjectID == "" {+ if sync == nil {return nil, nil}- project, err := s.projectService.GetProjectFromDatabaseByID(ctx, *sync.ProjectID)+ if sync.ProjectID != nil && *sync.ProjectID != "" {+ project, found, err := s.lookupProjectByIDInternal(ctx, *sync.ProjectID)+ if err != nil {+ return nil, err+ }+ if found {+ if err := s.projectService.ensureProjectPathUnderRoot(ctx, project, true); err != nil {+ return nil, err+ }+ if err := s.ensureDirectorySyncProjectLinkedInternal(ctx, sync, project); err != nil {+ return nil, err+ }+ return project, nil+ }++ slog.WarnContext(ctx, "Existing project not found, attempting recovery", "projectId", *sync.ProjectID, "syncId", sync.ID)+ }++ project, err := s.findRecoverableManagedProjectInternal(ctx, sync)if err != nil {- slog.WarnContext(ctx, "Existing project not found, will create new one", "projectId", *sync.ProjectID, "error", err)- return nil, nil+ return nil, err+ }+ if project != nil {+ if err := s.ensureDirectorySyncProjectLinkedInternal(ctx, sync, project); err != nil {+ return nil, err+ }+ return project, nil}- if err := s.projectService.ensureProjectPathUnderRoot(ctx, project, false); err != nil {+ project, err = s.recoverProjectFromDirectoryCandidateInternal(ctx, sync)+ if err != nil {return nil, err}+ if project != nil {+ return project, nil+ }- return project, nil+ return nil, nil}// validateDirectorySyncStageInternal loads the staged compose project using the real@@ -1236,141 +1519,6 @@ func (s *GitOpsSyncService) updateDirectorySyncProjectInternal(ctx context.Contereturn project, nil}-// directorySyncContentsChangedInternal compares the currently managed synced files with-// the newly fetched repo files to decide whether a redeploy is needed.-func directorySyncContentsChangedInternal(project *models.Project, syncFiles []projects.SyncFile, oldSyncedFiles []string, composeFileName string) (bool, error) {- if project == nil {- return true, nil- }-- if info, err := os.Stat(project.Path); err != nil {- if errors.Is(err, os.ErrNotExist) {- return true, nil- }- return false, err- } else if !info.IsDir() {- return false, fmt.Errorf("project path is not a directory: %s", project.Path)- }-- newFileSet := make(map[string]struct{}, len(syncFiles))- for _, file := range syncFiles {- newFileSet[file.RelativePath] = struct{}{}- existingContent, err := os.ReadFile(filepath.Join(project.Path, file.RelativePath))- if err != nil {- if errors.Is(err, os.ErrNotExist) {- return true, nil- }- return false, err- }- if !bytes.Equal(existingContent, file.Content) {- return true, nil- }- }-- for _, oldFile := range oldSyncedFiles {- if _, exists := newFileSet[oldFile]; exists {- continue- }- if _, err := os.Stat(filepath.Join(project.Path, oldFile)); err == nil {- return true, nil- } else if !errors.Is(err, os.ErrNotExist) {- return false, err- }- }-- for _, candidate := range projects.ComposeFileCandidates() {- if candidate == composeFileName {- continue- }- if _, exists := newFileSet[candidate]; exists {- continue- }- if _, err := os.Stat(filepath.Join(project.Path, candidate)); err == nil {- return true, nil- } else if !errors.Is(err, os.ErrNotExist) {- return false, err- }- }-- return false, nil-}--// removeStaleComposeFilesInternal drops old canonical compose filenames from the staged-// project when the repo now uses a different compose filename.-func removeStaleComposeFilesInternal(projectPath, composeFileName string, syncedFiles []string) error {- syncedFileSet := make(map[string]struct{}, len(syncedFiles))- for _, file := range syncedFiles {- syncedFileSet[file] = struct{}{}- }-- for _, candidate := range projects.ComposeFileCandidates() {- if candidate == composeFileName {- continue- }- if _, exists := syncedFileSet[candidate]; exists {- continue- }- if err := os.Remove(filepath.Join(projectPath, candidate)); err != nil && !errors.Is(err, os.ErrNotExist) {- return err- }- }-- return nil-}--// copyDirectoryContentsInternal clones the current project tree into the staging-// directory so directory sync updates can preserve non-synced local files.-func copyDirectoryContentsInternal(srcDir, destDir string) error {- srcRoot, err := os.OpenRoot(srcDir)- if err != nil {- return err- }- defer func() { _ = srcRoot.Close() }()-- destRoot, err := os.OpenRoot(destDir)- if err != nil {- return err- }- defer func() { _ = destRoot.Close() }()-- return filepath.WalkDir(srcDir, func(path string, d os.DirEntry, walkErr error) error {- if walkErr != nil {- return walkErr- }- if path == srcDir {- return nil- }-- relPath, err := filepath.Rel(srcDir, path)- if err != nil {- return err- }-- if d.IsDir() {- return destRoot.MkdirAll(relPath, 0o755)- }- if d.Type()&os.ModeSymlink != 0 {- return nil- }-- info, err := d.Info()- if err != nil {- return err- }-- content, err := srcRoot.ReadFile(relPath)- if err != nil {- return err- }-- if err := destRoot.MkdirAll(filepath.Dir(relPath), 0o755); err != nil {- return err- }-- return destRoot.WriteFile(relPath, content, info.Mode())- })-}-// updateSyncStatusWithFiles updates sync status including the list of synced filesfunc (s *GitOpsSyncService) updateSyncStatusWithFiles(ctx context.Context, id, status, errorMsg, commitHash string, syncedFiles []string) {now := time.Now()diff --git a/backend/internal/services/gitops_sync_service_test.go b/backend/internal/services/gitops_sync_service_test.goindex 5d1f53f55..dadc27c16 100644--- a/backend/internal/services/gitops_sync_service_test.go+++ b/backend/internal/services/gitops_sync_service_test.go@@ -243,6 +243,140 @@ func TestGitOpsSyncService_CreateDirectorySyncProjectInternal_RollsBackProjectOnassert.ErrorIs(t, statErr, os.ErrNotExist)}+func TestProjectsRemoveStaleComposeFiles_RemovesStaleCustomComposeFiles(t *testing.T) {+ t.Parallel()++ projectPath := t.TempDir()+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "sonarr.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "values.yaml"), []byte("replicaCount: 2\nimage:\n tag: latest\n"), 0o644))++ err := projects.RemoveStaleComposeFiles(projectPath, "sonarr.yaml", []string{"sonarr.yaml"})+ require.NoError(t, err)++ _, statErr := os.Stat(filepath.Join(projectPath, "radarr.yaml"))+ assert.ErrorIs(t, statErr, os.ErrNotExist)++ _, statErr = os.Stat(filepath.Join(projectPath, "sonarr.yaml"))+ require.NoError(t, statErr)++ _, statErr = os.Stat(filepath.Join(projectPath, "values.yaml"))+ require.NoError(t, statErr)+}++func TestGitOpsSyncService_GetDirectorySyncProjectInternal_RelinksManagedProjectWhenProjectIDStale(t *testing.T) {+ ctx := context.Background()+ svc, db, projectsDir := setupGitOpsSyncDirectoryTestService(t)++ projectPath := filepath.Join(projectsDir, "Radarr-3")+ require.NoError(t, os.MkdirAll(projectPath, 0o755))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))++ sync := &models.GitOpsSync{+ BaseModel: models.BaseModel{ID: "sync-directory-relink"},+ Name: "radarr-sync",+ EnvironmentID: "0",+ RepositoryID: "repo-1",+ ComposePath: "apps/media/radarr.yaml",+ ProjectName: "Radarr",+ ProjectID: ptr("missing-project"),+ SyncDirectory: true,+ }+ require.NoError(t, db.Create(sync).Error)++ project := &models.Project{+ BaseModel: models.BaseModel{ID: "proj-directory-relink"},+ Name: "Radarr",+ DirName: ptr("Radarr-3"),+ Path: projectPath,+ Status: models.ProjectStatusStopped,+ GitOpsManagedBy: &sync.ID,+ }+ require.NoError(t, db.Create(project).Error)++ recovered, err := svc.getDirectorySyncProjectInternal(ctx, sync)+ require.NoError(t, err)+ require.NotNil(t, recovered)+ assert.Equal(t, project.ID, recovered.ID)++ var storedSync models.GitOpsSync+ require.NoError(t, db.First(&storedSync, "id = ?", sync.ID).Error)+ require.NotNil(t, storedSync.ProjectID)+ assert.Equal(t, project.ID, *storedSync.ProjectID)+}++func TestGitOpsSyncService_GetDirectorySyncProjectInternal_RecoversUniqueDirectoryCandidate(t *testing.T) {+ ctx := context.Background()+ svc, db, projectsDir := setupGitOpsSyncDirectoryTestService(t)++ projectPath := filepath.Join(projectsDir, "Radarr-3")+ require.NoError(t, os.MkdirAll(projectPath, 0o755))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))++ sync := &models.GitOpsSync{+ BaseModel: models.BaseModel{ID: "sync-directory-disk-recovery"},+ Name: "radarr-sync",+ EnvironmentID: "0",+ RepositoryID: "repo-1",+ ComposePath: "apps/media/radarr.yaml",+ ProjectName: "Radarr",+ ProjectID: ptr("missing-project"),+ SyncDirectory: true,+ }+ require.NoError(t, db.Create(sync).Error)++ recovered, err := svc.getDirectorySyncProjectInternal(ctx, sync)+ require.NoError(t, err)+ require.NotNil(t, recovered)+ assert.Equal(t, projectPath, recovered.Path)+ require.NotNil(t, recovered.GitOpsManagedBy)+ assert.Equal(t, sync.ID, *recovered.GitOpsManagedBy)++ var storedSync models.GitOpsSync+ require.NoError(t, db.First(&storedSync, "id = ?", sync.ID).Error)+ require.NotNil(t, storedSync.ProjectID)+ assert.Equal(t, recovered.ID, *storedSync.ProjectID)++ var storedProject models.Project+ require.NoError(t, db.First(&storedProject, "id = ?", recovered.ID).Error)+ assert.Equal(t, projectPath, storedProject.Path)+ assert.Equal(t, 1, storedProject.ServiceCount)+}++func TestGitOpsSyncService_ReconcileDirectorySyncProjectsOnStartup_SkipsAmbiguousDuplicates(t *testing.T) {+ ctx := context.Background()+ svc, db, projectsDir := setupGitOpsSyncDirectoryTestService(t)++ for _, dirName := range []string{"Radarr-3", "Radarr-30"} {+ projectPath := filepath.Join(projectsDir, dirName)+ require.NoError(t, os.MkdirAll(projectPath, 0o755))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))+ }++ sync := &models.GitOpsSync{+ BaseModel: models.BaseModel{ID: "sync-directory-ambiguous"},+ Name: "radarr-sync",+ EnvironmentID: "0",+ RepositoryID: "repo-1",+ ComposePath: "apps/media/radarr.yaml",+ ProjectName: "Radarr",+ ProjectID: ptr("missing-project"),+ SyncDirectory: true,+ }+ require.NoError(t, db.Create(sync).Error)++ require.NoError(t, svc.ReconcileDirectorySyncProjectsOnStartup(ctx))++ var projectsCount int64+ require.NoError(t, db.Model(&models.Project{}).Count(&projectsCount).Error)+ assert.Zero(t, projectsCount)++ var storedSync models.GitOpsSync+ require.NoError(t, db.First(&storedSync, "id = ?", sync.ID).Error)+ require.NotNil(t, storedSync.ProjectID)+ assert.Equal(t, "missing-project", *storedSync.ProjectID)+}+func TestEnvContentChangedInternal(t *testing.T) {t.Run("ignores formatting-only changes", func(t *testing.T) {oldEnv := "B=2\nA=1\n# comment\n"diff --git a/backend/internal/services/project_service.go b/backend/internal/services/project_service.goindex c76f7473c..f419d78a0 100644--- a/backend/internal/services/project_service.go+++ b/backend/internal/services/project_service.go@@ -389,22 +389,76 @@ func (s *ProjectService) GetProjectByComposeName(ctx context.Context, name strinreturn nil, fmt.Errorf("project not found: %s", name)}-func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user models.User) error {- projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)+func (s *ProjectService) resolveProjectComposeFileInternal(ctx context.Context, proj *models.Project) (string, error) {+ if proj == nil {+ return "", fmt.Errorf("project is nil")+ }++ if proj.GitOpsManagedBy != nil && strings.TrimSpace(*proj.GitOpsManagedBy) != "" {+ var sync models.GitOpsSync+ if err := s.db.WithContext(ctx).+ Select("compose_path").+ Where("id = ?", *proj.GitOpsManagedBy).+ First(&sync).Error; err == nil {+ composeFileName := strings.TrimSpace(filepath.Base(sync.ComposePath))+ if composeFileName != "" && composeFileName != "." {+ candidate := filepath.Join(proj.Path, composeFileName)+ if info, statErr := os.Stat(candidate); statErr == nil {+ if !info.IsDir() {+ return candidate, nil+ }+ } else if !os.IsNotExist(statErr) {+ return "", fmt.Errorf("failed to inspect GitOps compose file %s: %w", candidate, statErr)+ }+ }+ } else if !errors.Is(err, gorm.ErrRecordNotFound) {+ return "", fmt.Errorf("failed to resolve GitOps compose path for project %s: %w", proj.ID, err)+ }+ }++ composeFile, err := projects.DetectComposeFile(proj.Path)if err != nil {- return err+ return "", &common.ProjectComposeFileNotFoundError{Err: err}}- // 1. Load project- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))+ return composeFile, nil+}++func (s *ProjectService) loadComposeProjectForProjectInternal(ctx context.Context, proj *models.Project) (*composetypes.Project, string, error) {+ composeFileFullPath, err := s.resolveProjectComposeFileInternal(ctx, proj)if err != nil {+ return nil, "", err+ }++ projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")+ projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))+ if pdErr != nil {+ slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)projectsDirectory = "/app/data/projects"}- pathMapper, _ := s.getPathMapper(ctx)+ pathMapper, pmErr := s.getPathMapper(ctx)+ if pmErr != nil {+ slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)+ }+autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- compProj, _, err := projects.LoadComposeProjectFromDir(ctx, projectFromDb.Path, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)+ composeProject, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper)+ if loadErr != nil {+ return nil, "", loadErr+ }++ return composeProject, composeFileFullPath, nil+}++func (s *ProjectService) UpdateProjectServices(ctx context.Context, projectID string, servicesToUpdate []string, user models.User) error {+ projectFromDb, err := s.GetProjectFromDatabaseByID(ctx, projectID)+ if err != nil {+ return err+ }++ // 1. Load project+ compProj, _, err := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)if err != nil {return fmt.Errorf("failed to load compose project: %w", err)}@@ -502,38 +556,19 @@ func (s *ProjectService) GetProjectServices(ctx context.Context, projectID strinreturn nil, err}- composeFileFullPath, derr := projects.DetectComposeFile(projectFromDb.Path)+ composeProject, composeFileFullPath, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)if derr != nil {return []ProjectServiceInfo{}, fmt.Errorf("no compose file found in project directory: %s", projectFromDb.Path)}- // Get configured projects directory from settings- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if pdErr != nil {- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)- projectsDirectory = "/app/data/projects"- }-- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- project, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)- if loadErr != nil {- return []ProjectServiceInfo{}, fmt.Errorf("failed to load compose project from %s: %w", projectFromDb.Path, loadErr)- }-meta, metaErr := projects.ParseArcaneComposeMetadata(ctx, composeFileFullPath)if metaErr != nil {slog.WarnContext(ctx, "failed to parse Arcane compose metadata", "path", composeFileFullPath, "error", metaErr)}- containers, err := projects.ComposePs(ctx, project, nil, true)+ containers, err := projects.ComposePs(ctx, composeProject, nil, true)if err != nil {- slog.Error("compose ps error", "projectName", project.Name, "error", err)+ slog.Error("compose ps error", "projectName", composeProject.Name, "error", err)return nil, fmt.Errorf("failed to get compose services status: %w", err)}@@ -542,7 +577,7 @@ func (s *ProjectService) GetProjectServices(ctx context.Context, projectID strin// Create a map for quick lookup of service configserviceConfigs := make(map[string]composetypes.ServiceConfig)- for _, svc := range project.Services {+ for _, svc := range composeProject.Services {serviceConfigs[svc.Name] = svc}@@ -571,7 +606,7 @@ func (s *ProjectService) GetProjectServices(ctx context.Context, projectID strinhave[c.Service] = true}- for _, svc := range project.Services {+ for _, svc := range composeProject.Services {if !have[svc.Name] {services = append(services, ProjectServiceInfo{Name: svc.Name,@@ -592,7 +627,13 @@ func (s *ProjectService) GetProjectContent(ctx context.Context, projectID stringif err != nil {return "", "", err}- return projects.ReadProjectFiles(proj.Path)++ composePath, composeErr := s.resolveProjectComposeFileInternal(ctx, proj)+ if composeErr != nil {+ composePath = ""+ }++ return projects.ReadProjectFiles(proj.Path, composePath)}func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID string) (project.Details, error) {@@ -626,7 +667,7 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID stringresp.DirName = utils.DerefString(proj.DirName)resp.RelativePath = s.getProjectRelativePathInternal(projectsDir, proj.Path)resp.GitOpsManagedBy = proj.GitOpsManagedBy- meta := s.getProjectMetadataFromPath(ctx, proj.Path)+ meta := s.getProjectMetadataForProject(ctx, *proj)resp.IconURL = meta.ProjectIconURLresp.URLs = meta.ProjectURLS@@ -636,16 +677,14 @@ func (s *ProjectService) GetProjectDetails(ctx context.Context, projectID stringresp.Status = string(proj.Status)// Enrich with details- s.enrichWithIncludeFiles(ctx, proj.Path, &resp)- s.enrichWithDirectoryFiles(ctx, proj.Path, &resp)- s.enrichWithGitOpsInfo(ctx, proj, &resp)-- // Load compose project for service definitions- composeFile, _ := projects.DetectComposeFile(proj.Path)- if composeFile != "" {+ composeFile, composeFileErr := s.resolveProjectComposeFileInternal(ctx, proj)+ if composeFileErr == nil {resp.ComposeFileName = filepath.Base(composeFile)+ s.enrichWithIncludeFiles(ctx, composeFile, &resp)s.enrichWithComposeServiceConfigs(ctx, proj, composeFile, &resp)}+ s.enrichWithDirectoryFiles(ctx, proj.Path, &resp)+ s.enrichWithGitOpsInfo(ctx, proj, &resp)// Get runtime services and update status/countsservices, serr := s.GetProjectServices(ctx, projectID)@@ -684,7 +723,7 @@ func (s *ProjectService) GetProjectFileContent(ctx context.Context, projectID, rreturn project.IncludeFile{}, &common.ProjectFileBadRequestError{Err: fmt.Errorf("relative path is required")}}- composeFile, detectErr := projects.DetectComposeFile(proj.Path)+ composeFile, detectErr := s.resolveProjectComposeFileInternal(ctx, proj)if detectErr == nil {projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")projectsDirectory, _ := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))@@ -751,29 +790,30 @@ func (s *ProjectService) GetProjectFileContent(ctx context.Context, projectID, r}, nil}-func (s *ProjectService) enrichWithIncludeFiles(ctx context.Context, projectPath string, resp *project.Details) {- composeFile, detectErr := projects.DetectComposeFile(projectPath)- if detectErr == nil {- // Load environment variables so that include paths with ${VAR} references are expanded- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, _ := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- envLoader := projects.NewEnvLoader(projectsDirectory, filepath.Dir(composeFile), autoInjectEnv)- envMap, _, _ := envLoader.LoadEnvironment(ctx)+func (s *ProjectService) enrichWithIncludeFiles(ctx context.Context, composeFile string, resp *project.Details) {+ if strings.TrimSpace(composeFile) == "" {+ return+ }- includes, parseErr := projects.ParseIncludes(composeFile, envMap, false)- if parseErr == nil {- var includeFiles []project.IncludeFile- for _, inc := range includes {- includeFiles = append(includeFiles, project.IncludeFile{- Path: inc.Path,- RelativePath: inc.RelativePath,- })- }- resp.IncludeFiles = includeFiles- } else {- slog.WarnContext(ctx, "Failed to parse includes", "error", parseErr, "path", projectPath)+ // Load environment variables so that include paths with ${VAR} references are expanded+ projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")+ projectsDirectory, _ := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))+ autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)+ envLoader := projects.NewEnvLoader(projectsDirectory, filepath.Dir(composeFile), autoInjectEnv)+ envMap, _, _ := envLoader.LoadEnvironment(ctx)++ includes, parseErr := projects.ParseIncludes(composeFile, envMap, false)+ if parseErr == nil {+ var includeFiles []project.IncludeFile+ for _, inc := range includes {+ includeFiles = append(includeFiles, project.IncludeFile{+ Path: inc.Path,+ RelativePath: inc.RelativePath,+ })}+ resp.IncludeFiles = includeFiles+ } else {+ slog.WarnContext(ctx, "Failed to parse includes", "error", parseErr, "path", composeFile)}}@@ -789,6 +829,8 @@ func (s *ProjectService) enrichWithDirectoryFiles(ctx context.Context, projectPa"compose.yml": true,"docker-compose.yaml": true,"docker-compose.yml": true,+ "podman-compose.yaml": true,+ "podman-compose.yml": true,}for _, inc := range resp.IncludeFiles {shownFiles[inc.RelativePath] = true@@ -976,7 +1018,11 @@ func (s *ProjectService) cleanupDBProjects(ctx context.Context, seen map[string]continue}- if _, err := projects.DetectComposeFile(p.Path); err != nil {+ if _, err := s.resolveProjectComposeFileInternal(ctx, &p); err != nil {+ if _, ok := errors.AsType[*common.ProjectComposeFileNotFoundError](err); !ok {+ slog.WarnContext(ctx, "failed to validate project compose file during cleanup", "projectID", p.ID, "path", p.Path, "error", err)+ continue+ }if derr := s.db.WithContext(ctx).Delete(&models.Project{}, "id = ?", p.ID).Error; derr != nil {slog.WarnContext(ctx, "failed to delete project without compose", "projectID", p.ID, "error", derr)}@@ -1136,30 +1182,11 @@ func (s *ProjectService) DeployProject(ctx context.Context, projectID string, usresolvedPullPolicy = "missing"}- composeFileFullPath, derr := projects.DetectComposeFile(projectFromDb.Path)+ project, _, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)if derr != nil {return fmt.Errorf("no compose file found in project directory: %s", projectFromDb.Path)}- // Get configured projects directory from settings- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if pdErr != nil {- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)- projectsDirectory = "/app/data/projects"- }-- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- project, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)- if loadErr != nil {- return fmt.Errorf("failed to load compose project from %s: %w", projectFromDb.Path, loadErr)- }-if err := s.updateProjectStatusInternal(ctx, projectID, models.ProjectStatusDeploying); err != nil {return fmt.Errorf("failed to update project status to deploying: %w", err)}@@ -1208,21 +1235,7 @@ func (s *ProjectService) DownProject(ctx context.Context, projectID string, userreturn err}- // Get configured projects directory from settings- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if pdErr != nil {- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)- projectsDirectory = "/app/data/projects"- }-- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- proj, _, lerr := projects.LoadComposeProjectFromDir(ctx, projectFromDb.Path, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)+ proj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)if lerr != nil {_ = s.updateProjectStatusInternal(ctx, projectID, models.ProjectStatusRunning)return fmt.Errorf("failed to load compose project: %w", lerr)@@ -1312,21 +1325,7 @@ func (s *ProjectService) DestroyProject(ctx context.Context, projectID string, r}if removeVolumes {- // Get configured projects directory from settings- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if pdErr != nil {- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)- projectsDirectory = "/app/data/projects"- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- if compProj, _, lerr := projects.LoadComposeProjectFromDir(ctx, proj.Path, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper); lerr == nil {+ if compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj); lerr == nil {if derr := projects.ComposeDown(ctx, compProj, true); derr != nil {slog.WarnContext(ctx, "failed to remove volumes", "error", derr)}@@ -1382,21 +1381,7 @@ func (s *ProjectService) PullProjectImages(ctx context.Context, projectID stringreturn err}- // Get configured projects directory from settings- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if pdErr != nil {- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)- projectsDirectory = "/app/data/projects"- }-- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- compProj, _, lerr := projects.LoadComposeProjectFromDir(ctx, proj.Path, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper)+ compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj)if lerr != nil {return fmt.Errorf("failed to load compose project: %w", lerr)}@@ -1437,29 +1422,11 @@ func (s *ProjectService) BuildProjectServices(ctx context.Context, projectID strreturn err}- composeFileFullPath, derr := projects.DetectComposeFile(projectFromDb.Path)+ project, _, derr := s.loadComposeProjectForProjectInternal(ctx, projectFromDb)if derr != nil {return fmt.Errorf("no compose file found in project directory: %s", projectFromDb.Path)}- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if pdErr != nil {- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)- projectsDirectory = "/app/data/projects"- }-- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- project, loadErr := projects.LoadComposeProject(ctx, composeFileFullPath, normalizeComposeProjectName(projectFromDb.Name), projectsDirectory, autoInjectEnv, pathMapper)- if loadErr != nil {- return fmt.Errorf("failed to load compose project from %s: %w", projectFromDb.Path, loadErr)- }-return s.buildProjectServicesInternal(ctx, projectID, project, options, progressWriter, user)}@@ -1474,21 +1441,7 @@ func (s *ProjectService) EnsureProjectImagesPresent(ctx context.Context, projectreturn err}- // Get configured projects directory from settings- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, pdErr := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if pdErr != nil {- slog.WarnContext(ctx, "unable to determine projects directory; using default", "error", pdErr)- projectsDirectory = "/app/data/projects"- }-- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- compProj, _, lerr := projects.LoadComposeProjectFromDir(ctx, proj.Path, normalizeComposeProjectName(proj.Name), projectsDirectory, autoInjectEnv, pathMapper)+ compProj, _, lerr := s.loadComposeProjectForProjectInternal(ctx, proj)if lerr != nil {return fmt.Errorf("failed to load compose project: %w", lerr)}@@ -2999,7 +2952,7 @@ func (s *ProjectService) fetchProjectStatusConcurrently(ctx context.Context, proresults[i].DirName = utils.DerefString(p.DirName)results[i].RelativePath = s.getProjectRelativePathInternal(projectsDir, p.Path)results[i].GitOpsManagedBy = p.GitOpsManagedBy- meta := s.getProjectMetadataFromPath(ctx, p.Path)+ meta := s.getProjectMetadataForProject(ctx, p)results[i].IconURL = meta.ProjectIconURLresults[i].URLs = meta.ProjectURLSresults[i].Status = string(models.ProjectStatusUnknown)@@ -3034,7 +2987,7 @@ func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir stringresp.DirName = utils.DerefString(p.DirName)resp.RelativePath = s.getProjectRelativePathInternal(projectsDir, p.Path)resp.GitOpsManagedBy = p.GitOpsManagedBy- meta := s.getProjectMetadataFromPath(ctx, p.Path)+ meta := s.getProjectMetadataForProject(ctx, p)resp.IconURL = meta.ProjectIconURLresp.URLs = meta.ProjectURLS@@ -3137,8 +3090,8 @@ func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir stringreturn resp}-func (s *ProjectService) getProjectMetadataFromPath(ctx context.Context, projectPath string) projects.ArcaneComposeMetadata {- composeFile, err := projects.DetectComposeFile(projectPath)+func (s *ProjectService) getProjectMetadataForProject(ctx context.Context, p models.Project) projects.ArcaneComposeMetadata {+ composeFile, err := s.resolveProjectComposeFileInternal(ctx, &p)if err != nil {return projects.ArcaneComposeMetadata{ServiceIcons: map[string]string{}}}@@ -3155,19 +3108,7 @@ func (s *ProjectService) getProjectMetadataFromPath(ctx context.Context, project// End Table Functionsfunc (s *ProjectService) countServicesFromCompose(ctx context.Context, p models.Project) (int, error) {- projectsDirSetting := s.settingsService.GetStringSetting(ctx, "projectsDirectory", "/app/data/projects")- projectsDirectory, err := projects.GetProjectsDirectory(ctx, strings.TrimSpace(projectsDirSetting))- if err != nil {- return 0, err- }-- pathMapper, pmErr := s.getPathMapper(ctx)- if pmErr != nil {- slog.WarnContext(ctx, "failed to create path mapper, continuing without translation", "error", pmErr)- }-- autoInjectEnv := s.settingsService.GetBoolSetting(ctx, "autoInjectEnv", false)- proj, _, err := projects.LoadComposeProjectFromDir(ctx, p.Path, normalizeComposeProjectName(p.Name), projectsDirectory, autoInjectEnv, pathMapper)+ proj, _, err := s.loadComposeProjectForProjectInternal(ctx, &p)if err != nil {return 0, err}diff --git a/backend/internal/services/project_service_test.go b/backend/internal/services/project_service_test.goindex 9306dcfc2..17ea224d2 100644--- a/backend/internal/services/project_service_test.go+++ b/backend/internal/services/project_service_test.go@@ -1954,6 +1954,110 @@ func TestProjectService_SyncProjectsFromFileSystem_RefreshesServiceCountOnComposassert.Equal(t, 2, project.ServiceCount)}+func TestProjectService_SyncProjectsFromFileSystem_PreservesGitOpsProjectWithCustomComposeFilename(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()+ require.NoError(t, db.AutoMigrate(&models.GitOpsSync{}))++ settingsService, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ projectsRoot := t.TempDir()+ projectDir := filepath.Join(projectsRoot, "Radarr-3")+ require.NoError(t, os.MkdirAll(projectDir, 0o755))+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))++ syncProjectID := "proj-custom-compose"+ syncID := "sync-custom-compose"+ sync := &models.GitOpsSync{+ BaseModel: models.BaseModel{ID: syncID},+ Name: "Radarr Sync",+ EnvironmentID: "0",+ RepositoryID: "repo-1",+ ComposePath: "apps/media/radarr.yaml",+ ProjectName: "Radarr",+ ProjectID: &syncProjectID,+ SyncDirectory: true,+ }+ require.NoError(t, db.Create(sync).Error)++ project := &models.Project{+ BaseModel: models.BaseModel{ID: syncProjectID},+ Name: "Radarr",+ DirName: ptr("Radarr-3"),+ Path: projectDir,+ Status: models.ProjectStatusStopped,+ GitOpsManagedBy: &syncID,+ }+ require.NoError(t, db.Create(project).Error)++ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))++ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())+ require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))++ items, err := svc.ListAllProjects(ctx)+ require.NoError(t, err)+ require.Len(t, items, 1)+ assert.Equal(t, syncProjectID, items[0].ID)+ assert.Equal(t, projectDir, items[0].Path)+ assert.Equal(t, syncID, *items[0].GitOpsManagedBy)+}++func TestProjectService_GetProjectDetails_UsesGitOpsCustomComposeFilename(t *testing.T) {+ db := setupProjectTestDB(t)+ ctx := context.Background()+ require.NoError(t, db.AutoMigrate(&models.GitOpsSync{}))++ settingsService, err := NewSettingsService(ctx, db)+ require.NoError(t, err)++ projectsRoot := t.TempDir()+ projectDir := filepath.Join(projectsRoot, "Radarr-3")+ composeContent := "services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"+ require.NoError(t, os.MkdirAll(projectDir, 0o755))+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte(composeContent), 0o644))+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, ".env"), []byte("TZ=UTC\n"), 0o644))++ syncProjectID := "proj-custom-compose-details"+ syncID := "sync-custom-compose-details"+ require.NoError(t, db.Create(&models.GitOpsSync{+ BaseModel: models.BaseModel{ID: syncID},+ Name: "Radarr Sync",+ EnvironmentID: "0",+ RepositoryID: "repo-1",+ ComposePath: "apps/media/radarr.yaml",+ ProjectName: "Radarr",+ ProjectID: &syncProjectID,+ SyncDirectory: true,+ }).Error)++ require.NoError(t, db.Create(&models.Project{+ BaseModel: models.BaseModel{ID: syncProjectID},+ Name: "Radarr",+ DirName: ptr("Radarr-3"),+ Path: projectDir,+ Status: models.ProjectStatusStopped,+ GitOpsManagedBy: &syncID,+ }).Error)++ require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))++ svc := NewProjectService(db, settingsService, nil, nil, nil, nil, config.Load())++ composeFromContent, envFromContent, err := svc.GetProjectContent(ctx, syncProjectID)+ require.NoError(t, err)+ assert.Equal(t, composeContent, composeFromContent)+ assert.Equal(t, "TZ=UTC\n", envFromContent)++ details, err := svc.GetProjectDetails(ctx, syncProjectID)+ require.NoError(t, err)+ assert.Equal(t, "radarr.yaml", details.ComposeFileName)+ assert.Equal(t, composeContent, details.ComposeContent)+ assert.Equal(t, "TZ=UTC\n", details.EnvContent)+ assert.Equal(t, 1, len(details.Services))+}+func TestProjectService_UpdateProject_WritesThroughSymlinkedProjectPath(t *testing.T) {db := setupProjectTestDB(t)ctx := context.Background()diff --git a/backend/pkg/projects/discovery_test.go b/backend/pkg/projects/discovery_test.goindex 324a2cba7..581fbb1d5 100644--- a/backend/pkg/projects/discovery_test.go+++ b/backend/pkg/projects/discovery_test.go@@ -103,6 +103,19 @@ func TestDiscoverProjectDirectories_NestedStandaloneProject(t *testing.T) {require.Equal(t, []string{"nested"}, names)}+func TestDiscoverProjectDirectories_SupportsCustomComposeFilename(t *testing.T) {+ root := t.TempDir()+ projectDir := filepath.Join(root, "Radarr-3")+ require.NoError(t, os.MkdirAll(projectDir, 0o755))+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte("services: {}\n"), 0o644))++ discovered, err := DiscoverProjectDirectories(root, false)+ require.NoError(t, err)+ require.Len(t, discovered, 1)+ require.Equal(t, "Radarr-3", discovered[0].DirName)+ require.Equal(t, projectDir, discovered[0].Path)+}+// DiscoveredProjectDirectories_call is a tiny helper so tests can share the// err-check boilerplate.func DiscoveredProjectDirectories_call(t *testing.T, root string) []DiscoveredProjectDir {diff --git a/backend/pkg/projects/fs_util.go b/backend/pkg/projects/fs_util.goindex 7c1894530..858be430a 100644--- a/backend/pkg/projects/fs_util.go+++ b/backend/pkg/projects/fs_util.go@@ -1,6 +1,7 @@package projectsimport (+ "bytes""context""fmt""log/slog"@@ -12,6 +13,7 @@ import ("github.com/getarcaneapp/arcane/backend/internal/config"pkgutils "github.com/getarcaneapp/arcane/backend/pkg/utils""github.com/getarcaneapp/arcane/types/project"+ "github.com/goccy/go-yaml")func ResolveConfiguredContainerDirectory(configuredPath, defaultPath string) string {@@ -93,9 +95,13 @@ func isBackendModuleRoot(path string) bool {return true}-func ReadProjectFiles(projectPath string) (composeContent, envContent string, err error) {- if composeFile, derr := DetectComposeFile(projectPath); derr == nil && composeFile != "" {- if content, rerr := os.ReadFile(composeFile); rerr == nil {+func ReadProjectFiles(projectPath, composePath string) (composeContent, envContent string, err error) {+ if strings.TrimSpace(composePath) == "" {+ composePath, _ = DetectComposeFile(projectPath)+ }++ if strings.TrimSpace(composePath) != "" {+ if content, rerr := os.ReadFile(composePath); rerr == nil {composeContent = string(content)}}@@ -108,6 +114,22 @@ func ReadProjectFiles(projectPath string) (composeContent, envContent string, erreturn composeContent, envContent, nil}+func HasComposeRootKeysInFile(path string) (bool, error) {+ content, err := os.ReadFile(path)+ if err != nil {+ return false, err+ }++ composeData := map[string]any{}+ if err := yaml.Unmarshal(content, &composeData); err != nil {+ return false, err+ }++ _, hasServices := composeData["services"]+ _, hasInclude := composeData["include"]+ return hasServices || hasInclude, nil+}+func GetTemplatesDirectory(ctx context.Context) (string, error) {templatesDir := filepath.Join("data", "templates")if _, err := os.Stat(templatesDir); os.IsNotExist(err) {@@ -236,6 +258,163 @@ func IsBinaryProjectFileContent(content []byte) bool {return slices.Contains(content[:checkSize], 0)}+func DirectorySyncContentsChanged(projectPath string, syncFiles []SyncFile, oldSyncedFiles []string, composeFileName string) (bool, error) {+ if info, err := os.Stat(projectPath); err != nil {+ if os.IsNotExist(err) {+ return true, nil+ }+ return false, err+ } else if !info.IsDir() {+ return false, fmt.Errorf("project path is not a directory: %s", projectPath)+ }++ newFileSet := make(map[string]struct{}, len(syncFiles))+ for _, file := range syncFiles {+ newFileSet[file.RelativePath] = struct{}{}+ existingContent, err := os.ReadFile(filepath.Join(projectPath, file.RelativePath))+ if err != nil {+ if os.IsNotExist(err) {+ return true, nil+ }+ return false, err+ }+ if !bytes.Equal(existingContent, file.Content) {+ return true, nil+ }+ }++ for _, oldFile := range oldSyncedFiles {+ if _, exists := newFileSet[oldFile]; exists {+ continue+ }+ if _, err := os.Stat(filepath.Join(projectPath, oldFile)); err == nil {+ return true, nil+ } else if !os.IsNotExist(err) {+ return false, err+ }+ }++ for _, candidate := range ComposeFileCandidates() {+ if candidate == composeFileName {+ continue+ }+ if _, exists := newFileSet[candidate]; exists {+ continue+ }+ if _, err := os.Stat(filepath.Join(projectPath, candidate)); err == nil {+ return true, nil+ } else if !os.IsNotExist(err) {+ return false, err+ }+ }++ return false, nil+}++func RemoveStaleComposeFiles(projectPath, composeFileName string, syncedFiles []string) error {+ syncedFileSet := make(map[string]struct{}, len(syncedFiles))+ for _, file := range syncedFiles {+ syncedFileSet[file] = struct{}{}+ }++ for _, candidate := range ComposeFileCandidates() {+ if candidate == composeFileName {+ continue+ }+ if _, exists := syncedFileSet[candidate]; exists {+ continue+ }+ if err := os.Remove(filepath.Join(projectPath, candidate)); err != nil && !os.IsNotExist(err) {+ return err+ }+ }++ entries, err := os.ReadDir(projectPath)+ if err != nil {+ return err+ }++ for _, entry := range entries {+ if entry.IsDir() {+ continue+ }++ name := entry.Name()+ if name == composeFileName {+ continue+ }+ if _, exists := syncedFileSet[name]; exists {+ continue+ }+ if slices.Contains(ComposeFileCandidates(), name) || !IsProjectFile(name) {+ continue+ }++ path := filepath.Join(projectPath, name)+ hasComposeRootKeys, rootKeysErr := HasComposeRootKeysInFile(path)+ if rootKeysErr != nil || !hasComposeRootKeys {+ continue+ }++ if err := os.Remove(path); err != nil && !os.IsNotExist(err) {+ return err+ }+ }++ return nil+}++func CopyDirectoryContents(srcDir, destDir string) error {+ srcRoot, err := os.OpenRoot(srcDir)+ if err != nil {+ return err+ }+ defer func() { _ = srcRoot.Close() }()++ destRoot, err := os.OpenRoot(destDir)+ if err != nil {+ return err+ }+ defer func() { _ = destRoot.Close() }()++ return filepath.WalkDir(srcDir, func(path string, d os.DirEntry, walkErr error) error {+ if walkErr != nil {+ return walkErr+ }+ if path == srcDir {+ return nil+ }++ relPath, err := filepath.Rel(srcDir, path)+ if err != nil {+ return err+ }++ if d.IsDir() {+ return destRoot.MkdirAll(relPath, 0o755)+ }+ if d.Type()&os.ModeSymlink != 0 {+ return nil+ }++ info, err := d.Info()+ if err != nil {+ return err+ }++ content, err := srcRoot.ReadFile(relPath)+ if err != nil {+ return err+ }++ if err := destRoot.MkdirAll(filepath.Dir(relPath), 0o755); err != nil {+ return err+ }++ return destRoot.WriteFile(relPath, content, info.Mode())+ })+}+// CreateUniqueDir creates a unique directory within the allowed projectsRoot.// It validates that the created directory is always within projectsRoot.func CreateUniqueDir(projectsRoot, basePath, name string, perm os.FileMode) (path, folderName string, err error) {diff --git a/backend/pkg/projects/fs_util_test.go b/backend/pkg/projects/fs_util_test.goindex 52656bafe..715d39963 100644--- a/backend/pkg/projects/fs_util_test.go+++ b/backend/pkg/projects/fs_util_test.go@@ -65,6 +65,30 @@ func TestResolveConfiguredContainerDirectory(t *testing.T) {})}+func TestReadProjectFiles(t *testing.T) {+ t.Run("detects compose path when not provided", func(t *testing.T) {+ projectPath := t.TempDir()+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n app:\n image: nginx:alpine\n"), 0o644))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TZ=UTC\n"), 0o644))++ composeContent, envContent, err := ReadProjectFiles(projectPath, "")+ require.NoError(t, err)+ assert.Contains(t, composeContent, "services:")+ assert.Equal(t, "TZ=UTC\n", envContent)+ })++ t.Run("uses explicit compose path when provided", func(t *testing.T) {+ projectPath := t.TempDir()+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, "radarr.yaml"), []byte("services:\n app:\n image: lscr.io/linuxserver/radarr:latest\n"), 0o644))+ require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TZ=UTC\n"), 0o644))++ composeContent, envContent, err := ReadProjectFiles(projectPath, filepath.Join(projectPath, "radarr.yaml"))+ require.NoError(t, err)+ assert.Contains(t, composeContent, "radarr")+ assert.Equal(t, "TZ=UTC\n", envContent)+ })+}+func TestReadProjectDirectoryFiles_RespectsDepthAndSkipDirectories(t *testing.T) {projectPath := t.TempDir()diff --git a/backend/pkg/projects/fs_writer.go b/backend/pkg/projects/fs_writer.goindex c8e66aa43..1cb0dd87a 100644--- a/backend/pkg/projects/fs_writer.go+++ b/backend/pkg/projects/fs_writer.go@@ -26,13 +26,11 @@ func ComposeFileCandidates() []string {return append([]string(nil), composeFileCandidates...)}-// detectExistingComposeFile finds an existing compose file in the directory-func detectExistingComposeFile(dir string) string {- for _, filename := range composeFileCandidates {- fullPath := filepath.Join(dir, filename)- if info, err := os.Stat(fullPath); err == nil && !info.IsDir() {- return fullPath- }+// detectExistingComposeFileInternal finds an existing compose file in the directory+func detectExistingComposeFileInternal(dir string) string {+ composePath, err := DetectComposeFile(dir)+ if err == nil {+ return composePath}return ""}@@ -65,7 +63,7 @@ func WriteComposeFile(projectsRoot, dirPath, content string) error {}var composePath string- if existingFile := detectExistingComposeFile(dirPath); existingFile != "" {+ if existingFile := detectExistingComposeFileInternal(dirPath); existingFile != "" {composePath = existingFile} else {composePath = filepath.Join(dirPath, "compose.yaml")diff --git a/backend/pkg/projects/fs_writer_test.go b/backend/pkg/projects/fs_writer_test.goindex f7017c116..ac3763d61 100644--- a/backend/pkg/projects/fs_writer_test.go+++ b/backend/pkg/projects/fs_writer_test.go@@ -136,3 +136,27 @@ func TestWriteComposeFile_PreservesExistingPodmanComposeNames(t *testing.T) {})}}++func TestWriteComposeFile_PreservesExistingCustomComposeNames(t *testing.T) {+ t.Parallel()++ tmpDir := t.TempDir()+ projectsRoot := tmpDir+ projectDir := filepath.Join(tmpDir, "Radarr-3")+ require.NoError(t, os.MkdirAll(projectDir, 0o755))++ existingComposePath := filepath.Join(projectDir, "radarr.yaml")+ require.NoError(t, os.WriteFile(existingComposePath, []byte("services: {}"), 0o600))+ require.NoError(t, os.WriteFile(filepath.Join(projectDir, "config.yaml"), []byte("x-config: true\n"), 0o600))++ expectedContent := "services:\n app:\n image: nginx:alpine\n"+ err := WriteComposeFile(projectsRoot, projectDir, expectedContent)+ require.NoError(t, err)++ actualContent, err := os.ReadFile(existingComposePath)+ require.NoError(t, err)+ assert.Equal(t, expectedContent, string(actualContent))++ _, err = os.Stat(filepath.Join(projectDir, "compose.yaml"))+ assert.True(t, os.IsNotExist(err), "compose.yaml should not be created when an existing custom compose file is present")+}diff --git a/backend/pkg/projects/load.go b/backend/pkg/projects/load.goindex 9d9826d4d..6aefce73b 100644--- a/backend/pkg/projects/load.go+++ b/backend/pkg/projects/load.go@@ -25,30 +25,114 @@ var ProjectFileCandidates = []string{".env",}-// IsProjectFile reports whether filename is a Compose file or an environment file.+// IsProjectFile reports whether filename is a known project file or a plausible+// custom YAML filename worth watching for compose discovery.func IsProjectFile(filename string) bool {- return slices.Contains(ProjectFileCandidates, filename)+ if slices.Contains(ProjectFileCandidates, filename) {+ return true+ }++ ext := strings.ToLower(filepath.Ext(filename))+ if ext != ".yaml" && ext != ".yml" {+ return false+ }++ base := filepath.Base(filename)+ return base != "" && !strings.HasPrefix(base, ".")+}++func stripTrailingProjectCounterInternal(name string) string {+ trimmed := strings.TrimSpace(name)+ withoutDigits := strings.TrimRight(trimmed, "0123456789")+ if len(withoutDigits) == len(trimmed) || withoutDigits == "" {+ return trimmed+ }++ if last := withoutDigits[len(withoutDigits)-1]; last != '-' && last != '_' {+ return trimmed+ }++ return withoutDigits[:len(withoutDigits)-1]}-func locateComposeFile(dir string) string {+func DetectComposeFile(dir string) (string, error) {for _, filename := range ProjectFileCandidates {if filename == ".env" {continue}- fullPath := filepath.Join(dir, filename)- if info, err := os.Stat(fullPath); err == nil && !info.IsDir() {- return fullPath++ composePath := filepath.Join(dir, filename)+ if info, err := os.Stat(composePath); err == nil && !info.IsDir() {+ return composePath, nil}}- return ""-}-func DetectComposeFile(dir string) (string, error) {- compose := locateComposeFile(dir)- if compose == "" {+ entries, err := os.ReadDir(dir)+ if err != nil {+ return "", err+ }++ dirBase := filepath.Base(filepath.Clean(dir))+ normalizedDirBase := loader.NormalizeProjectName(dirBase)+ normalizedTrimmedDirBase := loader.NormalizeProjectName(stripTrailingProjectCounterInternal(dirBase))++ customCandidates := make([]string, 0)+ dirMatchedCandidates := make([]string, 0)+ composeNamedCandidates := make([]string, 0)++ for _, entry := range entries {+ if entry.IsDir() {+ continue+ }++ name := entry.Name()+ if slices.Contains(ProjectFileCandidates, name) || !IsProjectFile(name) {+ continue+ }++ candidatePath := filepath.Join(dir, name)++ stem := strings.TrimSuffix(name, filepath.Ext(name))+ normalizedStem := loader.NormalizeProjectName(strings.TrimSpace(stem))+ dirMatched := normalizedStem != "" && (normalizedStem == normalizedDirBase || normalizedStem == normalizedTrimmedDirBase)+ composeNamed := strings.Contains(strings.ToLower(stem), "compose")++ hasComposeRootKeys, rootKeysErr := HasComposeRootKeysInFile(candidatePath)+ if rootKeysErr == nil {+ if !hasComposeRootKeys {+ continue+ }+ } else if !dirMatched && !composeNamed {+ continue+ }++ if dirMatched {+ dirMatchedCandidates = append(dirMatchedCandidates, candidatePath)+ }++ if composeNamed {+ composeNamedCandidates = append(composeNamedCandidates, candidatePath)+ }++ customCandidates = append(customCandidates, candidatePath)+ }++ switch {+ case len(dirMatchedCandidates) == 1:+ return dirMatchedCandidates[0], nil+ case len(dirMatchedCandidates) > 1:+ return "", fmt.Errorf("multiple custom compose files found in %q", dir)+ case len(composeNamedCandidates) == 1:+ return composeNamedCandidates[0], nil+ case len(composeNamedCandidates) > 1:+ return "", fmt.Errorf("multiple custom compose files found in %q", dir)+ case len(customCandidates) == 1:+ return customCandidates[0], nil+ case len(customCandidates) > 1:+ return "", fmt.Errorf("multiple custom compose files found in %q", dir)+ default:return "", fmt.Errorf("no compose file found in %q", dir)}- return compose, nil}func LoadComposeProject(ctx context.Context, composeFile, projectName, projectsDirectory string, autoInjectEnv bool, pathMapper *PathMapper) (*composetypes.Project, error) {diff --git a/backend/pkg/projects/load_test.go b/backend/pkg/projects/load_test.goindex 336e96f52..1cf09c098 100644--- a/backend/pkg/projects/load_test.go+++ b/backend/pkg/projects/load_test.go@@ -40,6 +40,56 @@ func TestDetectComposeFile_SupportsPodmanComposeNames(t *testing.T) {}}+func TestDetectComposeFile_SupportsSingleCustomComposeName(t *testing.T) {+ t.Parallel()++ dir := t.TempDir()+ expectedPath := filepath.Join(dir, "radarr.yaml")+ require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))++ composePath, err := DetectComposeFile(dir)+ require.NoError(t, err)+ assert.Equal(t, expectedPath, composePath)+}++func TestDetectComposeFile_PrefersDirectoryMatchedCustomComposeName(t *testing.T) {+ t.Parallel()++ root := t.TempDir()+ dir := filepath.Join(root, "Radarr-3")+ require.NoError(t, os.MkdirAll(dir, 0o755))+ expectedPath := filepath.Join(dir, "radarr.yaml")+ require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))+ require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("x-extra: true\n"), 0o600))++ composePath, err := DetectComposeFile(dir)+ require.NoError(t, err)+ assert.Equal(t, expectedPath, composePath)+}++func TestDetectComposeFile_ReturnsErrorForAmbiguousCustomComposeNames(t *testing.T) {+ t.Parallel()++ dir := t.TempDir()+ require.NoError(t, os.WriteFile(filepath.Join(dir, "alpha.yaml"), []byte("services:\n a:\n image: nginx:alpine\n"), 0o600))+ require.NoError(t, os.WriteFile(filepath.Join(dir, "beta.yml"), []byte("services:\n b:\n image: busybox:latest\n"), 0o600))++ _, err := DetectComposeFile(dir)+ require.Error(t, err)+ assert.Contains(t, err.Error(), "multiple custom compose files")+}++func TestDetectComposeFile_IgnoresSingleNonComposeYaml(t *testing.T) {+ t.Parallel()++ dir := t.TempDir()+ require.NoError(t, os.WriteFile(filepath.Join(dir, "values.yaml"), []byte("replicaCount: 2\nimage:\n tag: latest\n"), 0o600))++ _, err := DetectComposeFile(dir)+ require.Error(t, err)+ assert.Contains(t, err.Error(), "no compose file found")+}+func TestLoadComposeProjectFromDir_SupportsPodmanComposeNames(t *testing.T) {composeContent := "services:\n app:\n image: nginx:alpine\n"@@ -77,6 +127,27 @@ func TestLoadComposeProjectFromDir_SupportsPodmanComposeNames(t *testing.T) {}}+func TestLoadComposeProjectFromDir_SupportsCustomComposeNames(t *testing.T) {+ t.Parallel()++ dir := t.TempDir()+ expectedPath := filepath.Join(dir, "radarr.yaml")+ require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n app:\n image: nginx:alpine\n"), 0o600))++ project, composePath, err := LoadComposeProjectFromDir(+ context.Background(),+ dir,+ "radarr",+ filepath.Dir(dir),+ false,+ nil,+ )+ require.NoError(t, err)+ require.NotNil(t, project)+ assert.Equal(t, expectedPath, composePath)+ assert.Equal(t, []string{expectedPath}, project.ComposeFiles)+}+func TestLoadComposeProjectFromDir_EmptyProjectsDirectoryDoesNotCreateParentGlobalEnv(t *testing.T) {t.Parallel()diff --git a/go.work.sum b/go.work.sumindex b0b5fab88..70e39a8be 100644--- a/go.work.sum+++ b/go.work.sum@@ -70,6 +70,7 @@ github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp v1.5.3 h1:2afWGsMzkIcN8Qm4mgPgithub.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp v1.5.3/go.mod h1:dppbR7CwXD4pgtV9t3wD1812RaLDcBjtblcDF5f1vI0=github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0 h1:sBEjpZlNHzK1voKq9695PJSX2o5NEXl7/OL3coiIY0c=github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.30.0/go.mod h1:P4WPRUkOhJC13W//jWpyfJNDAIpvRbAUIYLX/4jtlE0=+github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.31.0/go.mod h1:P4WPRUkOhJC13W//jWpyfJNDAIpvRbAUIYLX/4jtlE0=github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0 h1:owcC2UnmsZycprQ5RfRgjydWhuoxg71LUfyiQdijZuM=github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric v0.53.0/go.mod h1:ZPpqegjbE99EPKsu3iUWV22A04wzGPcAY/ziSIQEEgs=github.com/GoogleCloudPlatform/opentelemetry-operations-go/internal/resourcemapping v0.53.0 h1:Ron4zCA/yk6U7WOBXhTJcDpsUBG9npumK6xw2auFltQ=