Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
fix: allow use of the local templates directory (#462)
Kyle Mendellcae0df4fd3a2
diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.goindex 8f3b3d1dc..c888a938d 100644--- a/backend/internal/bootstrap/jobs_bootstrap.go+++ b/backend/internal/bootstrap/jobs_bootstrap.go@@ -25,7 +25,7 @@ func registerJobs(appCtx context.Context, scheduler *job.Scheduler, appServicesslog.ErrorContext(appCtx, "Failed to register event cleanup job", slog.Any("error", err))}- if err := job.RegisterFilesystemWatcherJob(appCtx, scheduler, appServices.Stack, appServices.Settings); err != nil {+ if err := job.RegisterFilesystemWatcherJob(appCtx, scheduler, appServices.Stack, appServices.Template, appServices.Settings); err != nil {slog.ErrorContext(appCtx, "Failed to register filesystem watcher job", slog.Any("error", err))}diff --git a/backend/internal/job/filesystem_watcher_job.go b/backend/internal/job/filesystem_watcher_job.goindex a362109fa..9168df5be 100644--- a/backend/internal/job/filesystem_watcher_job.go+++ b/backend/internal/job/filesystem_watcher_job.go@@ -3,33 +3,36 @@ package jobimport ("context""log/slog"- "os""time""github.com/ofkm/arcane-backend/internal/services""github.com/ofkm/arcane-backend/internal/utils"+ "github.com/ofkm/arcane-backend/internal/utils/fs")type FilesystemWatcherJob struct {- stackService *services.StackService- settingsService *services.SettingsService- watcher *utils.FilesystemWatcher+ stackService *services.StackService+ templateService *services.TemplateService+ settingsService *services.SettingsService+ projectsWatcher *utils.FilesystemWatcher+ templatesWatcher *utils.FilesystemWatcher}func NewFilesystemWatcherJob(stackService *services.StackService,+ templateService *services.TemplateService,settingsService *services.SettingsService,) *FilesystemWatcherJob {return &FilesystemWatcherJob{stackService: stackService,+ templateService: templateService,settingsService: settingsService,}}-func RegisterFilesystemWatcherJob(ctx context.Context, scheduler *Scheduler, stackService *services.StackService, settingsService *services.SettingsService) error {- job := NewFilesystemWatcherJob(stackService, settingsService)+func RegisterFilesystemWatcherJob(ctx context.Context, scheduler *Scheduler, stackService *services.StackService, templateService *services.TemplateService, settingsService *services.SettingsService) error {+ job := NewFilesystemWatcherJob(stackService, templateService, settingsService)- // Start the filesystem watcher as a background taskgo func() {if err := job.Start(ctx); err != nil {slog.ErrorContext(ctx, "Filesystem watcher failed", "error", err)@@ -41,22 +44,17 @@ func RegisterFilesystemWatcherJob(ctx context.Context, scheduler *Scheduler, sta}func (j *FilesystemWatcherJob) Start(ctx context.Context) error {- // Get stacks directory from settings- stacksDir, err := j.getStacksDirectory(ctx)++ settings, err := j.settingsService.GetSettings(ctx)if err != nil {return err}-- // Ensure directory exists- if _, err := os.Stat(stacksDir); os.IsNotExist(err) {- if err := os.MkdirAll(stacksDir, 0755); err != nil {- return err- }- slog.InfoContext(ctx, "Created stacks directory", "path", stacksDir)+ projectsDirectory, err := fs.GetProjectsDirectory(ctx, settings.StacksDirectory.Value)+ if err != nil {+ return err}- // Create filesystem watcher- watcher, err := utils.NewFilesystemWatcher(stacksDir, utils.WatcherOptions{+ sw, err := utils.NewFilesystemWatcher(projectsDirectory, utils.WatcherOptions{Debounce: 3 * time.Second, // Wait 3 seconds after last change before syncingOnChange: j.handleFilesystemChange,})@@ -64,27 +62,71 @@ func (j *FilesystemWatcherJob) Start(ctx context.Context) error {return err}- j.watcher = watcher+ j.projectsWatcher = sw++ templatesDir, err := fs.GetTemplatesDirectory(ctx)+ if err != nil {+ return err+ }++ if j.templateService != nil {+ tw, err := utils.NewFilesystemWatcher(templatesDir, utils.WatcherOptions{+ Debounce: 3 * time.Second,+ OnChange: j.handleTemplatesChange,+ })+ if err != nil {+ return err+ }+ j.templatesWatcher = tw+ }- // Start watching- if err := j.watcher.Start(ctx); err != nil {+ if err := j.projectsWatcher.Start(ctx); err != nil {return err}+ if j.templatesWatcher != nil {+ if err := j.templatesWatcher.Start(ctx); err != nil {+ if stopErr := j.projectsWatcher.Stop(); stopErr != nil {+ slog.ErrorContext(ctx, "Failed to stop projects watcher after templates watcher start error", "error", stopErr)+ }+ return err+ }+ }++ slog.InfoContext(ctx, "Filesystem watcher started for projects directory",+ "path", projectsDirectory)+ if j.templatesWatcher != nil {+ slog.InfoContext(ctx, "Filesystem watcher started for templates directory",+ "path", templatesDir)+ }- slog.InfoContext(ctx, "Filesystem watcher started for stacks directory",- "path", stacksDir)+ // Initial sync to surface pre-existing resources+ if err := j.stackService.SyncAllStacksFromFilesystem(ctx); err != nil {+ slog.ErrorContext(ctx, "Initial stack sync failed", "error", err)+ }+ if j.templateService != nil {+ if err := j.templateService.SyncLocalTemplatesFromFilesystem(ctx); err != nil {+ slog.ErrorContext(ctx, "Initial template sync failed", "error", err)+ }+ }- // Keep the watcher running until context is cancelled<-ctx.Done()return j.Stop()}func (j *FilesystemWatcherJob) Stop() error {- if j.watcher != nil {- return j.watcher.Stop()+ var firstErr error+ if j.projectsWatcher != nil {+ if err := j.projectsWatcher.Stop(); err != nil {+ firstErr = err+ }}- return nil+ if j.templatesWatcher != nil {+ if err := j.templatesWatcher.Stop(); err != nil && firstErr == nil {+ firstErr = err+ }+ }+ return firstErr}func (j *FilesystemWatcherJob) handleFilesystemChange(ctx context.Context) {@@ -98,10 +140,14 @@ func (j *FilesystemWatcherJob) handleFilesystemChange(ctx context.Context) {}}-func (j *FilesystemWatcherJob) getStacksDirectory(ctx context.Context) (string, error) {- settings, err := j.settingsService.GetSettings(ctx)- if err != nil {- return "data/projects", err+func (j *FilesystemWatcherJob) handleTemplatesChange(ctx context.Context) {+ slog.InfoContext(ctx, "Template directory change detected, syncing templates")+ if j.templateService == nil {+ return+ }+ if err := j.templateService.SyncLocalTemplatesFromFilesystem(ctx); err != nil {+ slog.ErrorContext(ctx, "Failed to sync templates after filesystem change", "error", err)+ } else {+ slog.InfoContext(ctx, "Template sync completed after filesystem change")}- return settings.StacksDirectory.Value, nil}diff --git a/backend/internal/models/template.go b/backend/internal/models/template.goindex cbb52b83d..39c0f6a56 100644--- a/backend/internal/models/template.go+++ b/backend/internal/models/template.go@@ -22,19 +22,14 @@ type ComposeTemplate struct {}type ComposeTemplateMetadata struct {- Version *string `json:"version,omitempty" gorm:"column:meta_version"`- Author *string `json:"author,omitempty" gorm:"column:meta_author"`- Tags *string `json:"tags,omitempty" gorm:"column:meta_tags"`- RemoteURL *string `json:"remoteUrl,omitempty" gorm:"column:meta_remote_url"`- EnvURL *string `json:"envUrl,omitempty" gorm:"column:meta_env_url"`- DocumentationURL *string `json:"documentationUrl,omitempty" gorm:"column:meta_documentation_url"`- IconURL *string `json:"iconUrl,omitempty" gorm:"column:meta_icon_url"`+ Version *string `json:"version,omitempty"`+ Author *string `json:"author,omitempty"`+ Tags *string `json:"tags,omitempty"`+ RemoteURL *string `json:"remoteUrl,omitempty"`+ EnvURL *string `json:"envUrl,omitempty"`+ DocumentationURL *string `json:"documentationUrl,omitempty"`+ IconURL *string `json:"iconUrl,omitempty"`}-func (TemplateRegistry) TableName() string {- return "template_registries"-}--func (ComposeTemplate) TableName() string {- return "compose_templates"-}+func (TemplateRegistry) TableName() string { return "template_registries" }+func (ComposeTemplate) TableName() string { return "compose_templates" }diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.goindex 754ebd0f8..a944ffa77 100644--- a/backend/internal/services/template_service.go+++ b/backend/internal/services/template_service.go@@ -14,9 +14,11 @@ import ("sync/atomic""time"+ "github.com/google/uuid""github.com/ofkm/arcane-backend/internal/database""github.com/ofkm/arcane-backend/internal/dto""github.com/ofkm/arcane-backend/internal/models"+ appfs "github.com/ofkm/arcane-backend/internal/utils/fs""gorm.io/gorm")@@ -113,15 +115,22 @@ func (s *TemplateService) ensureRemoteTemplatesLoaded(ctx context.Context) error}func (s *TemplateService) GetAllTemplates(ctx context.Context) ([]models.ComposeTemplate, error) {- var templates []models.ComposeTemplate+ if err := s.syncFilesystemTemplatesInternal(ctx); err != nil {+ fmt.Printf("Warning: failed to sync filesystem templates: %v\n", err)+ }- err := s.db.WithContext(ctx).Preload("Registry").Find(&templates).Error- if err != nil {+ var templates []models.ComposeTemplate+ if err := s.db.WithContext(ctx).Preload("Registry").Find(&templates).Error; err != nil {return nil, fmt.Errorf("failed to get local templates: %w", err)}- err = s.ensureRemoteTemplatesLoaded(ctx)- if err != nil {+ // Trim heavy fields in list responses+ for i := range templates {+ templates[i].Content = ""+ templates[i].EnvContent = nil+ }++ if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {fmt.Printf("Warning: failed to load remote templates for GetAllTemplates: %v\n", err)} else {rc := s.getRemoteCache()@@ -134,27 +143,25 @@ func (s *TemplateService) GetAllTemplates(ctx context.Context) ([]models.Compose}func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.ComposeTemplate, error) {- var template models.ComposeTemplate+ if err := s.syncFilesystemTemplatesInternal(ctx); err != nil {+ fmt.Printf("Warning: failed to sync filesystem templates: %v\n", err)+ }- // Local DB by ID (keeps DB concerns in models)- err := s.db.WithContext(ctx).Preload("Registry").Where("id = ?", id).First(&template).Error- if err == nil {+ var template models.ComposeTemplate+ if err := s.db.WithContext(ctx).Preload("Registry").Where("id = ?", id).First(&template).Error; err == nil {return &template, nil- }- if !errors.Is(err, gorm.ErrRecordNotFound) {+ } else if !errors.Is(err, gorm.ErrRecordNotFound) {return nil, fmt.Errorf("failed to query local template: %w", err)}- // Remote cache by public IDif err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {return nil, fmt.Errorf("template not found (failed to load remote templates): %w", err)}rc := s.getRemoteCache()for _, remoteTemplate := range rc.templates {- // Compare against public ID (supports both new composite IDs and legacy slug IDs if present)if remoteTemplate.ID == id {- foundTemplate := remoteTemplate- return &foundTemplate, nil+ t := remoteTemplate+ return &t, nil}}@@ -162,19 +169,14 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.C}func (s *TemplateService) CreateTemplate(ctx context.Context, template *models.ComposeTemplate) error {- // Ensure ID is set if not provided (for custom templates)if template.ID == "" {- template.ID = s.generateTemplateID(template.Name)+ template.ID = uuid.NewString()}-template.IsCustom = truetemplate.IsRemote = false-- err := s.db.WithContext(ctx).Create(template).Error- if err != nil {+ if err := s.db.WithContext(ctx).Create(template).Error; err != nil {return fmt.Errorf("failed to create template: %w", err)}-return nil}@@ -226,7 +228,6 @@ func (s *TemplateService) DeleteTemplate(ctx context.Context, id string) error {return fmt.Errorf("failed to delete template: %w", result.Error)}if result.RowsAffected == 0 {- // This case should ideally not be reached if First() succeeded, but as a safeguardreturn fmt.Errorf("template not found after finding it")}return nil@@ -265,6 +266,7 @@ func (s *TemplateService) GetRegistries(ctx context.Context) ([]models.TemplateR}func (s *TemplateService) CreateRegistry(ctx context.Context, registry *models.TemplateRegistry) error {+ // Hydrate metadata if neededif registry.Name == "" || registry.Description == "" {if registry.URL == "" {return fmt.Errorf("registry URL is required")@@ -281,6 +283,10 @@ func (s *TemplateService) CreateRegistry(ctx context.Context, registry *models.T}}+ if registry.ID == "" {+ registry.ID = uuid.NewString()+ }+if err := s.db.WithContext(ctx).Create(registry).Error; err != nil {return fmt.Errorf("failed to create registry: %w", err)}@@ -454,21 +460,6 @@ func (s *TemplateService) convertRemoteToLocal(remote dto.RemoteTemplate, regist}}-func (s *TemplateService) generateTemplateID(name string) string {- id := strings.ToLower(name)- id = regexp.MustCompile(`[^a-z0-9]+`).ReplaceAllString(id, "-")- id = strings.Trim(id, "-")-- if id == "" {- id = "template"- }-- // Ensure uniqueness for local templates if needed, e.g., append a short hash or timestamp- // For now, relying on DB primary key constraint for uniqueness on save.-- return id-}-func (s *TemplateService) getDefaultEnvTemplate() string {return `# Environment Variables# These variables will be available to your stack services@@ -526,11 +517,73 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *return nil, fmt.Errorf("template is not remote")}- // Check if a local version with the same remote ID already exists- // This prevents duplicate downloads of the same remote template- existingLocalTemplate, err := s.GetTemplate(ctx, s.generateTemplateID(remoteTemplate.Name))- if err == nil && !existingLocalTemplate.IsRemote {- return existingLocalTemplate, fmt.Errorf("template '%s' is already downloaded", remoteTemplate.Name)+ // Determine safe folder name from template name or public ID+ base := s.slugify(remoteTemplate.Name)+ if base == "" {+ parts := strings.Split(remoteTemplate.ID, ":")+ if len(parts) > 0 {+ base = s.slugify(parts[len(parts)-1])+ }+ if base == "" {+ base = "template-" + uuid.NewString()+ }+ }++ // Ensure directory: data/templates/<base>+ tplDir := filepath.Join("data", "templates", base)+ if err := os.MkdirAll(tplDir, 0755); err != nil {+ return nil, fmt.Errorf("failed to create template directory: %w", err)+ }+ composePath := filepath.Join(tplDir, "compose.yaml")+ envPath := filepath.Join(tplDir, ".env.example")+ srcDesc := fmt.Sprintf("Imported from data/templates/%s/compose.yaml", base)++ var existing models.ComposeTemplate+ if err := s.db.WithContext(ctx).+ Where("is_remote = ? AND registry_id IS NULL AND (description = ? OR name = ?)", false, srcDesc, base).+ First(&existing).Error; err == nil {+ composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)+ if err != nil {+ return nil, fmt.Errorf("failed to fetch template content for existing local template: %w", err)+ }++ // Write compose file and handle errors+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {+ return nil, fmt.Errorf("failed to write compose file: %w", err)+ }++ // Write env file if present and handle errors+ hasEnv := strings.TrimSpace(envContent) != ""+ if hasEnv {+ if err := os.WriteFile(envPath, []byte(envContent), 0600); err != nil {+ return nil, fmt.Errorf("failed to write env file: %w", err)+ }+ }++ // Only set fields after successful writes+ existing.Content = composeContent+ if hasEnv {+ existing.EnvContent = &envContent+ }++ if remoteTemplate.Metadata != nil {+ existing.Metadata = &models.ComposeTemplateMetadata{+ Version: remoteTemplate.Metadata.Version,+ Author: remoteTemplate.Metadata.Author,+ Tags: remoteTemplate.Metadata.Tags,+ RemoteURL: remoteTemplate.Metadata.RemoteURL,+ EnvURL: remoteTemplate.Metadata.EnvURL,+ DocumentationURL: remoteTemplate.Metadata.DocumentationURL,+ IconURL: remoteTemplate.Metadata.IconURL,+ }+ }++ if err := s.db.WithContext(ctx).Save(&existing).Error; err != nil {+ return nil, fmt.Errorf("failed to update existing local template: %w", err)+ }+ return &existing, nil+ } else if !errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, fmt.Errorf("failed to check existing template: %w", err)}composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)@@ -538,42 +591,153 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *return nil, fmt.Errorf("failed to fetch template content for download: %w", err)}+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {+ return nil, fmt.Errorf("failed to write compose file: %w", err)+ }+ var envPtr *string+ if strings.TrimSpace(envContent) != "" {+ if err := os.WriteFile(envPath, []byte(envContent), 0600); err != nil {+ return nil, fmt.Errorf("failed to write env file: %w", err)+ }+ envPtr = &envContent+ }+localTemplate := &models.ComposeTemplate{- Name: remoteTemplate.Name,- Description: fmt.Sprintf("%s (Downloaded from %s)", remoteTemplate.Description, remoteTemplate.Registry.Name),+ BaseModel: models.BaseModel{ID: uuid.NewString()},+ Name: base,+ Description: srcDesc,Content: composeContent,+ EnvContent: envPtr,IsCustom: true,IsRemote: false,RegistryID: nil,Registry: nil,}- if envContent != "" {- localTemplate.EnvContent = &envContent- }-if remoteTemplate.Metadata != nil {localTemplate.Metadata = &models.ComposeTemplateMetadata{Version: remoteTemplate.Metadata.Version,Author: remoteTemplate.Metadata.Author,Tags: remoteTemplate.Metadata.Tags,+ RemoteURL: remoteTemplate.Metadata.RemoteURL,+ EnvURL: remoteTemplate.Metadata.EnvURL,DocumentationURL: remoteTemplate.Metadata.DocumentationURL,IconURL: remoteTemplate.Metadata.IconURL,}}- err = s.db.WithContext(ctx).Create(localTemplate).Error- if err != nil {+ if err := s.db.WithContext(ctx).Create(localTemplate).Error; err != nil {return nil, fmt.Errorf("failed to save local template: %w", err)}- // After successful download and save, remove the remote template from the cache- // This is optional but can help keep the list clean if you only want to see local after download- // s.removeRemoteTemplateFromCache(remoteTemplate.ID) // Need to implement this helper if desired-return localTemplate, nil}+// slugify produces a filesystem-safe name.+func (s *TemplateService) slugify(in string) string {+ in = strings.TrimSpace(strings.ToLower(in))+ if in == "" {+ return ""+ }+ in = strings.ReplaceAll(in, " ", "-")+ re := regexp.MustCompile(`[^a-z0-9\-_]+`)+ in = re.ReplaceAllString(in, "-")+ in = regexp.MustCompile(`-+`).ReplaceAllString(in, "-")+ return strings.Trim(in, "-")+}+func (s *TemplateService) invalidateRemoteCache() {s.setRemoteCache(remoteCache{})}++func (s *TemplateService) SyncLocalTemplatesFromFilesystem(ctx context.Context) error {+ return s.syncFilesystemTemplatesInternal(ctx)+}++// upsertFilesystemTemplate centralizes insert/update logic for filesystem templates.+func (s *TemplateService) upsertFilesystemTemplate(ctx context.Context, name, desc, compose string, envPtr *string) error {+ var existing models.ComposeTemplate+ q := s.db.WithContext(ctx).+ Where("is_remote = ? AND registry_id IS NULL AND description = ?", false, desc).+ First(&existing)++ if q.Error == nil {+ existing.Name = name+ existing.Content = compose+ existing.EnvContent = envPtr+ existing.IsCustom = true+ existing.IsRemote = false+ if err := s.db.WithContext(ctx).Save(&existing).Error; err != nil {+ return fmt.Errorf("update template %s: %w", existing.ID, err)+ }+ return nil+ }+ if !errors.Is(q.Error, gorm.ErrRecordNotFound) {+ return fmt.Errorf("query existing template: %w", q.Error)+ }++ tpl := &models.ComposeTemplate{+ BaseModel: models.BaseModel{ID: uuid.NewString()},+ Name: name,+ Description: desc,+ Content: compose,+ EnvContent: envPtr,+ IsCustom: true,+ IsRemote: false,+ RegistryID: nil,+ Registry: nil,+ Metadata: nil,+ }+ if err := s.db.WithContext(ctx).Create(tpl).Error; err != nil {+ return fmt.Errorf("insert template %s: %w", name, err)+ }+ return nil+}++func (s *TemplateService) processFolderEntry(ctx context.Context, baseDir, folder string) error {+ compose, envPtr, desc, found, err := appfs.ReadFolderComposeTemplate(baseDir, folder)+ if err != nil || !found {+ return err+ }+ return s.upsertFilesystemTemplate(ctx, folder, desc, compose, envPtr)+}++func (s *TemplateService) processRootFile(ctx context.Context, baseDir, file string) error {+ base, compose, envPtr, desc, err := appfs.ReadRootComposeTemplate(baseDir, file)+ if err != nil {+ return err+ }+ return s.upsertFilesystemTemplate(ctx, base, desc, compose, envPtr)+}++func (s *TemplateService) syncFilesystemTemplatesInternal(ctx context.Context) error {+ dir, err := appfs.GetTemplatesDirectory(ctx)+ if err != nil {+ return fmt.Errorf("ensure templates dir: %w", err)+ }++ entries, err := os.ReadDir(dir)+ if err != nil {+ if os.IsNotExist(err) {+ return nil+ }+ return fmt.Errorf("read dir %s: %w", dir, err)+ }++ for _, ent := range entries {+ if ent.IsDir() {+ if err := s.processFolderEntry(ctx, dir, ent.Name()); err != nil {+ fmt.Printf("Warning: failed to read folder template %s: %v\n", ent.Name(), err)+ }+ continue+ }+ ext := strings.ToLower(filepath.Ext(ent.Name()))+ if ext != ".yml" && ext != ".yaml" {+ continue+ }+ if err := s.processRootFile(ctx, dir, ent.Name()); err != nil {+ fmt.Printf("Warning: failed to read file template %s: %v\n", ent.Name(), err)+ }+ }+ return nil+}diff --git a/backend/internal/utils/fs/fs_templates.go b/backend/internal/utils/fs/fs_templates.gonew file mode 100644index 000000000..43dab88dd--- /dev/null+++ b/backend/internal/utils/fs/fs_templates.go@@ -0,0 +1,60 @@+package fs++import (+ "fmt"+ "os"+ "path/filepath"+ "strings"+)++func ReadFolderComposeTemplate(baseDir, folder string) (string, *string, string, bool, error) {+ composePath := filepath.Join(baseDir, folder, "compose.yaml")+ if _, err := os.Stat(composePath); err != nil {+ if os.IsNotExist(err) {+ return "", nil, "", false, nil+ }+ return "", nil, "", false, fmt.Errorf("stat compose: %w", err)+ }++ b, err := os.ReadFile(composePath)+ if err != nil {+ return "", nil, "", false, fmt.Errorf("read compose %s: %w", composePath, err)+ }++ var envPtr *string+ for _, envName := range []string{".env.example", ".env"} {+ envPath := filepath.Join(baseDir, folder, envName)+ if eb, err := os.ReadFile(envPath); err == nil {+ env := string(eb)+ envPtr = &env+ break+ }+ }++ desc := fmt.Sprintf("Imported from %s/%s/compose.yaml", baseDir, folder)+ return string(b), envPtr, desc, true, nil+}++func ReadRootComposeTemplate(baseDir, fileName string) (string, string, *string, string, error) {+ ext := strings.ToLower(filepath.Ext(fileName))+ base := strings.TrimSuffix(fileName, ext)+ composePath := filepath.Join(baseDir, fileName)++ b, err := os.ReadFile(composePath)+ if err != nil {+ return "", "", nil, "", fmt.Errorf("read compose %s: %w", composePath, err)+ }++ var envPtr *string+ for _, envExt := range []string{".env.example", ".env"} {+ envPath := filepath.Join(baseDir, base+envExt)+ if eb, err := os.ReadFile(envPath); err == nil {+ env := string(eb)+ envPtr = &env+ break+ }+ }++ desc := fmt.Sprintf("Imported from %s/%s", baseDir, fileName)+ return base, string(b), envPtr, desc, nil+}diff --git a/backend/internal/utils/fs/fs_util.go b/backend/internal/utils/fs/fs_util.goindex 830952113..3decd4a00 100644--- a/backend/internal/utils/fs/fs_util.go+++ b/backend/internal/utils/fs/fs_util.go@@ -1,8 +1,11 @@package fsimport (+ "context""fmt"+ "log/slog""os"+ "path/filepath")func CountSubdirectories(path string) (int, error) {@@ -19,3 +22,30 @@ func CountSubdirectories(path string) (int, error) {}return count, nil}++func GetProjectsDirectory(ctx context.Context, stacksDir string) (string, error) {+ projectsDirectory := stacksDir+ if projectsDirectory == "" {+ projectsDirectory = "data/projects"+ }++ if _, err := os.Stat(projectsDirectory); os.IsNotExist(err) {+ if err := os.MkdirAll(projectsDirectory, 0755); err != nil {+ return "", err+ }+ slog.InfoContext(ctx, "Created projects directory", "path", projectsDirectory)+ }++ return projectsDirectory, nil+}++func GetTemplatesDirectory(ctx context.Context) (string, error) {+ templatesDir := filepath.Join("data", "templates")+ if _, err := os.Stat(templatesDir); os.IsNotExist(err) {+ if err := os.MkdirAll(templatesDir, 0755); err != nil {+ return "", err+ }+ slog.InfoContext(ctx, "Created templates directory", "path", templatesDir)+ }+ return templatesDir, nil+}