Skip to content

Modern Docker Management, Designed for Everyone

feat: show template icons based on x-arcane labels (#1933)

Kyle Mendell20433796de75
diff --git a/backend/internal/models/template.go b/backend/internal/models/template.go
index 3b9af524b..512edd187 100644
--- a/backend/internal/models/template.go
+++ b/backend/internal/models/template.go
@@ -28,6 +28,7 @@ type ComposeTemplateMetadata struct {
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" }
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 997fe9da0..1c45b9d5d 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -24,6 +24,7 @@ import (
"github.com/getarcaneapp/arcane/backend/internal/utils/mapper"
"github.com/getarcaneapp/arcane/backend/internal/utils/pagination"
templateutil "github.com/getarcaneapp/arcane/backend/internal/utils/template"
+ "github.com/getarcaneapp/arcane/backend/pkg/utils"
"github.com/getarcaneapp/arcane/types/env"
tmpl "github.com/getarcaneapp/arcane/types/template"
"github.com/google/uuid"
@@ -39,7 +40,7 @@ type remoteCache struct {
type registryFetchMeta struct {
LastModified string
- Templates []tmpl.RemoteTemplate
+ Templates []models.ComposeTemplate
}
type TemplateService struct {
@@ -58,8 +59,12 @@ type TemplateService struct {
}
const (
- remoteCacheDuration = 5 * time.Minute
- fsSyncInterval = 1 * time.Minute
+ remoteCacheDuration = 5 * time.Minute
+ fsSyncInterval = 1 * time.Minute
+ remoteIconResolveLimit = 4
+ templateArcaneBlockKey = "x-arcane"
+ templateArcaneIconKey = "icon"
+ templateArcaneIconsAliasKey = "icons"
)
const remoteIDPrefix = "remote"
@@ -241,8 +246,7 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.C
return nil, fmt.Errorf("template not found (failed to load remote templates): %w", err)
}
s.remoteMu.RLock()
- copied := make([]models.ComposeTemplate, len(s.remoteCache.templates))
- copy(copied, s.remoteCache.templates)
+ copied := cloneRemoteTemplates(s.remoteCache.templates)
s.remoteMu.RUnlock()
for _, remoteTemplate := range copied {
@@ -261,6 +265,7 @@ func (s *TemplateService) CreateTemplate(ctx context.Context, template *models.C
}
template.IsCustom = true
template.IsRemote = false
+ setTemplateIconURL(template, s.resolveTemplateIconURL(ctx, template.Content, derefString(template.EnvContent)))
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
if err := tx.Create(template).Error; err != nil {
return fmt.Errorf("failed to create template: %w", err)
@@ -287,6 +292,7 @@ func (s *TemplateService) UpdateTemplate(ctx context.Context, id string, updates
existing.Description = updates.Description
existing.Content = updates.Content
existing.EnvContent = updates.EnvContent
+ setTemplateIconURL(&existing, s.resolveTemplateIconURL(ctx, existing.Content, derefString(existing.EnvContent)))
if err := tx.Save(&existing).Error; err != nil {
return fmt.Errorf("failed to update template: %w", err)
@@ -509,8 +515,9 @@ func (s *TemplateService) loadRemoteTemplates(ctx context.Context) ([]models.Com
mu.Lock()
defer mu.Unlock()
- for _, rt := range remoteTemplates {
- template := s.convertRemoteToLocal(rt, &reg)
+ for _, template := range remoteTemplates {
+ template.Registry = cloneRegistry(&reg)
+ template.RegistryID = stringPtr(reg.ID)
templates = append(templates, template)
}
return nil
@@ -552,7 +559,7 @@ func (s *TemplateService) doGET(ctx context.Context, url string) ([]byte, error)
// fetchRegistryTemplates performs a conditional GET using If-Modified-Since.
// If the server replies 304 Not Modified, cached templates for the registry are reused.
-func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, reg *models.TemplateRegistry) ([]tmpl.RemoteTemplate, error) {
+func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, reg *models.TemplateRegistry) ([]models.ComposeTemplate, error) {
s.registryMu.RLock()
fetchMeta := s.registryFetchMeta[reg.ID]
s.registryMu.RUnlock()
@@ -573,7 +580,7 @@ func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, reg *model
if resp.StatusCode == http.StatusNotModified {
if fetchMeta != nil {
- return fetchMeta.Templates, nil
+ return cloneRemoteTemplates(fetchMeta.Templates), nil
}
return nil, fmt.Errorf("received 304 without cached data")
}
@@ -591,16 +598,22 @@ func (s *TemplateService) fetchRegistryTemplates(ctx context.Context, reg *model
return nil, fmt.Errorf("parse registry JSON: %w", err)
}
+ templates := make([]models.ComposeTemplate, 0, len(regDTO.Templates))
+ for _, remoteTemplate := range regDTO.Templates {
+ templates = append(templates, s.convertRemoteToLocal(remoteTemplate, reg))
+ }
+ s.enrichRemoteTemplateIcons(ctx, templates)
+
lm := resp.Header.Get("Last-Modified")
newMeta := &registryFetchMeta{
LastModified: lm,
- Templates: regDTO.Templates,
+ Templates: cloneRemoteTemplates(templates),
}
s.registryMu.Lock()
s.registryFetchMeta[reg.ID] = newMeta
s.registryMu.Unlock()
- return regDTO.Templates, nil
+ return templates, nil
}
func (s *TemplateService) fetchRegistryManifest(ctx context.Context, url string) (*tmpl.RemoteRegistry, error) {
@@ -629,15 +642,15 @@ func (s *TemplateService) convertRemoteToLocal(remote tmpl.RemoteTemplate, regis
EnvContent: nil,
IsCustom: false,
IsRemote: true,
- RegistryID: new(registry.ID),
- Registry: registry,
+ RegistryID: stringPtr(registry.ID),
+ Registry: cloneRegistry(registry),
Metadata: &models.ComposeTemplateMetadata{
- Version: new(remote.Version),
- Author: new(remote.Author),
+ Version: stringPtr(remote.Version),
+ Author: stringPtr(remote.Author),
Tags: remote.Tags,
- RemoteURL: new(remote.ComposeURL),
- EnvURL: new(remote.EnvURL),
- DocumentationURL: new(remote.DocumentationURL),
+ RemoteURL: stringPtr(remote.ComposeURL),
+ EnvURL: stringPtr(remote.EnvURL),
+ DocumentationURL: stringPtr(remote.DocumentationURL),
},
}
}
@@ -647,6 +660,14 @@ func (s *TemplateService) FetchTemplateContent(ctx context.Context, template *mo
return template.Content, "", fmt.Errorf("not a remote template or missing remote URL")
}
+ return s.fetchRemoteTemplateFiles(ctx, template)
+}
+
+func (s *TemplateService) fetchRemoteTemplateFiles(ctx context.Context, template *models.ComposeTemplate) (string, string, error) {
+ if template == nil || template.Metadata == nil || template.Metadata.RemoteURL == nil {
+ return "", "", fmt.Errorf("not a remote template or missing remote URL")
+ }
+
composeContent, err := s.fetchURL(ctx, *template.Metadata.RemoteURL)
if err != nil {
return "", "", fmt.Errorf("failed to fetch compose content from %s: %w", *template.Metadata.RemoteURL, err)
@@ -664,6 +685,32 @@ func (s *TemplateService) FetchTemplateContent(ctx context.Context, template *mo
return composeContent, envContent, nil
}
+func (s *TemplateService) enrichRemoteTemplateIcons(ctx context.Context, templates []models.ComposeTemplate) {
+ if len(templates) == 0 {
+ return
+ }
+
+ group, groupCtx := errgroup.WithContext(ctx)
+ group.SetLimit(remoteIconResolveLimit)
+
+ for i := range templates {
+ idx := i
+ group.Go(func() error {
+ composeContent, envContent, err := s.fetchRemoteTemplateFiles(groupCtx, &templates[idx])
+ if err != nil {
+ slog.WarnContext(groupCtx, "failed to fetch remote template content for icon extraction", "templateID", templates[idx].ID, "error", err)
+ setTemplateIconURL(&templates[idx], nil)
+ return nil
+ }
+
+ setTemplateIconURL(&templates[idx], s.resolveTemplateIconURL(groupCtx, composeContent, envContent))
+ return nil
+ })
+ }
+
+ _ = group.Wait()
+}
+
func (s *TemplateService) fetchURL(ctx context.Context, url string) (string, error) {
body, err := s.doGET(ctx, url)
if err != nil {
@@ -776,15 +823,40 @@ func cloneTemplateMetadata(meta *models.ComposeTemplateMetadata) *models.Compose
return nil
}
return &models.ComposeTemplateMetadata{
- Version: meta.Version,
- Author: meta.Author,
- Tags: meta.Tags,
- RemoteURL: meta.RemoteURL,
- EnvURL: meta.EnvURL,
- DocumentationURL: meta.DocumentationURL,
+ Version: stringPtr(derefString(meta.Version)),
+ Author: stringPtr(derefString(meta.Author)),
+ Tags: append([]string(nil), meta.Tags...),
+ RemoteURL: stringPtr(derefString(meta.RemoteURL)),
+ EnvURL: stringPtr(derefString(meta.EnvURL)),
+ DocumentationURL: stringPtr(derefString(meta.DocumentationURL)),
+ IconURL: stringPtr(derefString(meta.IconURL)),
}
}
+func cloneRemoteTemplates(items []models.ComposeTemplate) []models.ComposeTemplate {
+ if len(items) == 0 {
+ return nil
+ }
+
+ cloned := make([]models.ComposeTemplate, len(items))
+ for i := range items {
+ cloned[i] = items[i]
+ cloned[i].RegistryID = stringPtr(derefString(items[i].RegistryID))
+ cloned[i].Registry = cloneRegistry(items[i].Registry)
+ cloned[i].Metadata = cloneTemplateMetadata(items[i].Metadata)
+ }
+ return cloned
+}
+
+func cloneRegistry(registry *models.TemplateRegistry) *models.TemplateRegistry {
+ if registry == nil {
+ return nil
+ }
+
+ cloned := *registry
+ return &cloned
+}
+
func (s *TemplateService) invalidateRemoteCache() {
s.remoteMu.Lock()
s.remoteCache = remoteCache{}
@@ -800,6 +872,8 @@ func (s *TemplateService) SyncLocalTemplatesFromFilesystem(ctx context.Context)
}
func (s *TemplateService) upsertFilesystemTemplate(ctx context.Context, name, desc, compose string, envPtr *string) error {
+ iconURL := s.resolveTemplateIconURL(ctx, compose, derefString(envPtr))
+
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
var existing models.ComposeTemplate
q := tx.
@@ -812,6 +886,7 @@ func (s *TemplateService) upsertFilesystemTemplate(ctx context.Context, name, de
existing.EnvContent = envPtr
existing.IsCustom = true
existing.IsRemote = false
+ setTemplateIconURL(&existing, iconURL)
if err := tx.Save(&existing).Error; err != nil {
return fmt.Errorf("update template %s: %w", existing.ID, err)
}
@@ -833,6 +908,7 @@ func (s *TemplateService) upsertFilesystemTemplate(ctx context.Context, name, de
Registry: nil,
Metadata: nil,
}
+ setTemplateIconURL(tpl, iconURL)
if err := tx.Create(tpl).Error; err != nil {
return fmt.Errorf("insert template %s: %w", name, err)
}
@@ -1039,6 +1115,115 @@ func (s *TemplateService) ParseComposeServices(ctx context.Context, composeConte
return serviceNames
}
+func (s *TemplateService) resolveTemplateIconURL(ctx context.Context, composeContent, envContent string) *string {
+ if strings.TrimSpace(composeContent) == "" {
+ return nil
+ }
+
+ tmpDir, err := os.MkdirTemp("", "arcane-template-icon-*")
+ if err != nil {
+ slog.WarnContext(ctx, "failed to create temp dir for template icon parsing", "error", err)
+ return nil
+ }
+ defer func() { _ = os.RemoveAll(tmpDir) }()
+
+ envPath := filepath.Join(tmpDir, ".env")
+ if err := appfs.WriteFileWithPerm(envPath, envContent, common.FilePerm); err != nil {
+ slog.WarnContext(ctx, "failed to create temp env file for template icon parsing", "error", err)
+ }
+
+ envMap := make(composetypes.Mapping)
+ for _, variable := range templateutil.ParseEnvContent(envContent) {
+ if key := strings.TrimSpace(variable.Key); key != "" {
+ envMap[key] = variable.Value
+ }
+ }
+ envMap["PWD"] = tmpDir
+
+ configDetails := composetypes.ConfigDetails{
+ ConfigFiles: []composetypes.ConfigFile{
+ {
+ Content: []byte(composeContent),
+ },
+ },
+ WorkingDir: tmpDir,
+ Environment: envMap,
+ }
+
+ project, err := composeloader.LoadWithContext(ctx, configDetails, composeloader.WithSkipValidation, func(opts *composeloader.Options) {
+ opts.SkipConsistencyCheck = true
+ })
+ if err != nil {
+ slog.WarnContext(ctx, "failed to parse compose for template icon metadata", "error", err)
+ return nil
+ }
+
+ if project == nil {
+ return nil
+ }
+
+ arcaneBlock, ok := project.Extensions[templateArcaneBlockKey]
+ if !ok {
+ return nil
+ }
+
+ arcaneBlockMap, ok := utils.AsStringMap(arcaneBlock)
+ if !ok {
+ return nil
+ }
+
+ icon := utils.FirstNonEmpty(
+ getFirstString(arcaneBlockMap[templateArcaneIconKey]),
+ getFirstString(arcaneBlockMap[templateArcaneIconsAliasKey]),
+ )
+
+ return stringPtr(icon)
+}
+
+func getFirstString(value any) string {
+ values := utils.Collect(value, utils.ToString)
+ return utils.FirstNonEmpty(values...)
+}
+
+func stringPtr(value string) *string {
+ trimmed := strings.TrimSpace(value)
+ if trimmed == "" {
+ return nil
+ }
+ return &trimmed
+}
+
+func derefString(value *string) string {
+ if value == nil {
+ return ""
+ }
+ return *value
+}
+
+func setTemplateIconURL(template *models.ComposeTemplate, iconURL *string) {
+ if template == nil {
+ return
+ }
+
+ if template.Metadata == nil {
+ if iconURL == nil {
+ return
+ }
+ template.Metadata = &models.ComposeTemplateMetadata{}
+ }
+
+ template.Metadata.IconURL = iconURL
+ if template.Metadata.Version == nil &&
+ template.Metadata.Author == nil &&
+ len(template.Metadata.Tags) == 0 &&
+ template.Metadata.RemoteURL == nil &&
+ template.Metadata.EnvURL == nil &&
+ template.Metadata.DocumentationURL == nil &&
+ template.Metadata.IconURL == nil {
+ template.Metadata = nil
+ }
+}
+
// GetTemplateContentWithParsedData returns template content along with parsed metadata
func (s *TemplateService) GetTemplateContentWithParsedData(ctx context.Context, id string) (*tmpl.TemplateContent, error) {
composeTemplate, err := s.GetTemplate(ctx, id)
@@ -1046,11 +1231,6 @@ func (s *TemplateService) GetTemplateContentWithParsedData(ctx context.Context,
return nil, err
}
- var outTemplate tmpl.Template
- if mapErr := mapper.MapStruct(composeTemplate, &outTemplate); mapErr != nil {
- return nil, fmt.Errorf("failed to map template: %w", mapErr)
- }
-
var composeContent, envContent string
if composeTemplate.IsRemote {
composeContent, envContent, err = s.FetchTemplateContent(ctx, composeTemplate)
@@ -1064,6 +1244,13 @@ func (s *TemplateService) GetTemplateContentWithParsedData(ctx context.Context,
}
}
+ setTemplateIconURL(composeTemplate, s.resolveTemplateIconURL(ctx, composeContent, envContent))
+
+ var outTemplate tmpl.Template
+ if mapErr := mapper.MapStruct(composeTemplate, &outTemplate); mapErr != nil {
+ return nil, fmt.Errorf("failed to map template: %w", mapErr)
+ }
+
// Parse services from compose content using compose-go library
services := s.ParseComposeServices(ctx, composeContent)
@@ -1098,8 +1285,7 @@ func (s *TemplateService) getMergedTemplates(ctx context.Context) ([]models.Comp
slog.WarnContext(ctx, "failed to load remote templates", "error", err)
} else {
s.remoteMu.RLock()
- copied := make([]models.ComposeTemplate, len(s.remoteCache.templates))
- copy(copied, s.remoteCache.templates)
+ copied := cloneRemoteTemplates(s.remoteCache.templates)
s.remoteMu.RUnlock()
if len(copied) > 0 {
diff --git a/backend/internal/services/template_service_test.go b/backend/internal/services/template_service_test.go
new file mode 100644
index 000000000..bf68c90b0
--- /dev/null
+++ b/backend/internal/services/template_service_test.go
@@ -0,0 +1,282 @@
+package services
+
+import (
+ "context"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "sync/atomic"
+ "testing"
+
+ glsqlite "github.com/glebarez/sqlite"
+ "github.com/stretchr/testify/require"
+ "gorm.io/gorm"
+
+ "github.com/getarcaneapp/arcane/backend/internal/database"
+ "github.com/getarcaneapp/arcane/backend/internal/models"
+)
+
+func setupTemplateServiceTestDB(t *testing.T) *database.DB {
+ t.Helper()
+
+ db, err := gorm.Open(glsqlite.Open(":memory:"), &gorm.Config{})
+ require.NoError(t, err)
+ require.NoError(t, db.AutoMigrate(&models.TemplateRegistry{}, &models.ComposeTemplate{}))
+
+ return &database.DB{DB: db}
+}
+
+func setTestWorkingDir(t *testing.T, dir string) {
+ t.Helper()
+
+ originalDir, err := os.Getwd()
+ require.NoError(t, err)
+ require.NoError(t, os.Chdir(dir))
+
+ t.Cleanup(func() {
+ require.NoError(t, os.Chdir(originalDir))
+ })
+}
+
+func TestResolveTemplateIconURL(t *testing.T) {
+ service := &TemplateService{}
+
+ tests := []struct {
+ name string
+ compose string
+ envContent string
+ want string
+ }{
+ {
+ name: "top level icon",
+ compose: `x-arcane:
+ icon: https://cdn.example/icon.png
+services:
+ app:
+ image: nginx:alpine
+`,
+ want: "https://cdn.example/icon.png",
+ },
+ {
+ name: "icons alias",
+ compose: `x-arcane:
+ icons: https://cdn.example/alias.png
+services:
+ app:
+ image: nginx:alpine
+`,
+ want: "https://cdn.example/alias.png",
+ },
+ {
+ name: "env interpolation",
+ compose: `x-arcane:
+ icon: ${TEMPLATE_ICON}
+services:
+ app:
+ image: nginx:alpine
+`,
+ envContent: "TEMPLATE_ICON=https://cdn.example/from-env.png\n",
+ want: "https://cdn.example/from-env.png",
+ },
+ {
+ name: "invalid x arcane block",
+ compose: `x-arcane: plain-text
+services:
+ app:
+ image: nginx:alpine
+`,
+ want: "",
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ iconURL := service.resolveTemplateIconURL(context.Background(), tt.compose, tt.envContent)
+ if tt.want == "" {
+ require.Nil(t, iconURL)
+ return
+ }
+
+ require.NotNil(t, iconURL)
+ require.Equal(t, tt.want, *iconURL)
+ })
+ }
+}
+
+func TestFetchRegistryTemplates_ReusesCachedIconsOnNotModified(t *testing.T) {
+ var composeHits atomic.Int32
+ var okComposeURL string
+ var badComposeURL string
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch r.URL.Path {
+ case "/registry.json":
+ if r.Header.Get("If-Modified-Since") != "" {
+ w.WriteHeader(http.StatusNotModified)
+ return
+ }
+
+ w.Header().Set("Last-Modified", "Mon, 02 Jan 2006 15:04:05 GMT")
+ _, _ = w.Write([]byte(`{
+ "name": "Demo Registry",
+ "description": "Registry used in tests",
+ "version": "1.0.0",
+ "author": "Arcane",
+ "templates": [
+ {
+ "id": "good",
+ "name": "Good Template",
+ "description": "Has a compose icon",
+ "version": "1.0.0",
+ "author": "Arcane",
+ "compose_url": "` + okComposeURL + `",
+ "env_url": "",
+ "documentation_url": "",
+ "tags": ["demo"]
+ },
+ {
+ "id": "bad",
+ "name": "Broken Template",
+ "description": "Compose fetch fails",
+ "version": "1.0.0",
+ "author": "Arcane",
+ "compose_url": "` + badComposeURL + `",
+ "env_url": "",
+ "documentation_url": "",
+ "tags": ["demo"]
+ }
+ ]
+}`))
+ case "/ok.yml":
+ composeHits.Add(1)
+ _, _ = w.Write([]byte(`x-arcane:
+ icon: https://cdn.example/good.png
+services:
+ app:
+ image: nginx:alpine
+`))
+ case "/missing.yml":
+ http.NotFound(w, r)
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ defer server.Close()
+
+ registryURL := server.URL + "/registry.json"
+ okComposeURL = server.URL + "/ok.yml"
+ badComposeURL = server.URL + "/missing.yml"
+
+ service := &TemplateService{
+ httpClient: server.Client(),
+ registryFetchMeta: make(map[string]*registryFetchMeta),
+ }
+ registry := &models.TemplateRegistry{
+ BaseModel: models.BaseModel{ID: "reg-1"},
+ Name: "Demo Registry",
+ URL: registryURL,
+ Enabled: true,
+ }
+
+ templates, err := service.fetchRegistryTemplates(context.Background(), registry)
+ require.NoError(t, err)
+ require.Len(t, templates, 2)
+ require.NotNil(t, templates[0].Metadata)
+ require.NotNil(t, templates[0].Metadata.IconURL)
+ require.Equal(t, "https://cdn.example/good.png", *templates[0].Metadata.IconURL)
+ require.Nil(t, templates[1].Metadata.IconURL)
+ require.EqualValues(t, 1, composeHits.Load())
+
+ cachedTemplates, err := service.fetchRegistryTemplates(context.Background(), registry)
+ require.NoError(t, err)
+ require.Len(t, cachedTemplates, 2)
+ require.NotNil(t, cachedTemplates[0].Metadata)
+ require.NotNil(t, cachedTemplates[0].Metadata.IconURL)
+ require.Equal(t, "https://cdn.example/good.png", *cachedTemplates[0].Metadata.IconURL)
+ require.EqualValues(t, 1, composeHits.Load())
+}
+
+func TestDownloadTemplate_PreservesIconURL(t *testing.T) {
+ tempDir := t.TempDir()
+ setTestWorkingDir(t, tempDir)
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ switch r.URL.Path {
+ case "/compose.yaml":
+ _, _ = w.Write([]byte(`x-arcane:
+ icon: https://cdn.example/download.png
+services:
+ app:
+ image: nginx:alpine
+`))
+ case "/template.env":
+ _, _ = w.Write([]byte("DOWNLOAD_ICON=https://cdn.example/download.png\n"))
+ default:
+ http.NotFound(w, r)
+ }
+ }))
+ defer server.Close()
+
+ service := &TemplateService{
+ db: setupTemplateServiceTestDB(t),
+ httpClient: server.Client(),
+ registryFetchMeta: make(map[string]*registryFetchMeta),
+ }
+
+ remoteTemplate := &models.ComposeTemplate{
+ BaseModel: models.BaseModel{ID: "remote:reg-1:demo"},
+ Name: "Demo Template",
+ Description: "Remote template",
+ IsRemote: true,
+ IsCustom: false,
+ RegistryID: stringPtr("reg-1"),
+ Metadata: &models.ComposeTemplateMetadata{
+ RemoteURL: stringPtr(server.URL + "/compose.yaml"),
+ EnvURL: stringPtr(server.URL + "/template.env"),
+ IconURL: stringPtr("https://cdn.example/download.png"),
+ },
+ }
+
+ downloaded, err := service.DownloadTemplate(context.Background(), remoteTemplate)
+ require.NoError(t, err)
+ require.NotNil(t, downloaded)
+ require.False(t, downloaded.IsRemote)
+ require.NotNil(t, downloaded.Metadata)
+ require.NotNil(t, downloaded.Metadata.IconURL)
+ require.Equal(t, "https://cdn.example/download.png", *downloaded.Metadata.IconURL)
+
+ var stored models.ComposeTemplate
+ require.NoError(t, service.db.WithContext(context.Background()).First(&stored, "id = ?", downloaded.ID).Error)
+ require.NotNil(t, stored.Metadata)
+ require.NotNil(t, stored.Metadata.IconURL)
+ require.Equal(t, "https://cdn.example/download.png", *stored.Metadata.IconURL)
+}
+
+func TestSyncFilesystemTemplatesInternal_PopulatesIconURL(t *testing.T) {
+ tempDir := t.TempDir()
+ setTestWorkingDir(t, tempDir)
+
+ templateDir := filepath.Join(tempDir, "data", "templates", "example")
+ require.NoError(t, os.MkdirAll(templateDir, 0o755))
+ require.NoError(t, os.WriteFile(filepath.Join(templateDir, "compose.yaml"), []byte(`x-arcane:
+ icon: https://cdn.example/local.png
+services:
+ app:
+ image: nginx:alpine
+`), 0o644))
+
+ service := &TemplateService{
+ db: setupTemplateServiceTestDB(t),
+ httpClient: http.DefaultClient,
+ registryFetchMeta: make(map[string]*registryFetchMeta),
+ }
+
+ require.NoError(t, service.syncFilesystemTemplatesInternal(context.Background()))
+
+ var stored models.ComposeTemplate
+ require.NoError(t, service.db.WithContext(context.Background()).First(&stored, "name = ?", "example").Error)
+ require.NotNil(t, stored.Metadata)
+ require.NotNil(t, stored.Metadata.IconURL)
+ require.Equal(t, "https://cdn.example/local.png", *stored.Metadata.IconURL)
+}
diff --git a/frontend/src/lib/components/dialogs/template-selection-dialog.svelte b/frontend/src/lib/components/dialogs/template-selection-dialog.svelte
index c1e34bff5..2bbdbbf4f 100644
--- a/frontend/src/lib/components/dialogs/template-selection-dialog.svelte
+++ b/frontend/src/lib/components/dialogs/template-selection-dialog.svelte
@@ -10,6 +10,7 @@
import * as Select from '$lib/components/ui/select/index.js';
import * as Collapsible from '$lib/components/ui/collapsible/index.js';
import SwitchWithLabel from '$lib/components/form/labeled-switch.svelte';
+ import IconImage from '$lib/components/icon-image.svelte';
import {
ArrowDownIcon,
ArrowRightIcon,
@@ -157,7 +158,16 @@
<Card class="hover:bg-muted/50 hover:border-primary/20 border transition-colors">
<div class="p-4">
<div class="mb-2 flex items-start justify-between gap-2">
- <h4 class="truncate pr-2 font-semibold">{template.name}</h4>
+ <div class="flex min-w-0 items-start gap-3">
+ <IconImage
+ src={template.metadata?.iconUrl}
+ alt={template.name}
+ fallback={template.isRemote ? RegistryIcon : ProjectsIcon}
+ class="size-5"
+ containerClass="size-9"
+ />
+ <h4 class="min-w-0 truncate pr-2 font-semibold">{template.name}</h4>
+ </div>
<div class="ml-2 flex flex-shrink-0 flex-wrap items-center gap-1">
{#if template.metadata?.version}
<Badge variant="outline" class="text-xs">v{template.metadata.version}</Badge>
diff --git a/frontend/src/lib/types/template.type.ts b/frontend/src/lib/types/template.type.ts
index 62cfe1db0..ee925e8b0 100644
--- a/frontend/src/lib/types/template.type.ts
+++ b/frontend/src/lib/types/template.type.ts
@@ -25,6 +25,7 @@ export interface Template {
remoteUrl?: string;
envUrl?: string;
documentationUrl?: string;
+ iconUrl?: string;
updatedAt?: string;
};
createdAt: string;
diff --git a/frontend/src/routes/(app)/customize/templates/[id]/+page.svelte b/frontend/src/routes/(app)/customize/templates/[id]/+page.svelte
index 4f66fb3c8..bc314e0ef 100644
--- a/frontend/src/routes/(app)/customize/templates/[id]/+page.svelte
+++ b/frontend/src/routes/(app)/customize/templates/[id]/+page.svelte
@@ -4,6 +4,7 @@
import { Badge } from '$lib/components/ui/badge';
import { Spinner } from '$lib/components/ui/spinner';
import CodeEditor from '$lib/components/code-editor/editor.svelte';
+ import IconImage from '$lib/components/icon-image.svelte';
import { goto, invalidateAll } from '$app/navigation';
import { m } from '$lib/paraglide/messages.js';
import { templateService } from '$lib/services/template-service';
@@ -101,11 +102,20 @@
<span>{m.common_back_to({ resource: m.templates_title() })}</span>
</ArcaneButton>
- <div>
- <h1 class="text-xl font-bold break-words sm:text-2xl">{template.name}</h1>
- {#if template.description}
- <p class="text-muted-foreground mt-1.5 text-sm break-words sm:text-base">{template.description}</p>
- {/if}
+ <div class="flex min-w-0 items-start gap-3">
+ <IconImage
+ src={template.metadata?.iconUrl}
+ alt={template.name}
+ fallback={template.isRemote ? GlobeIcon : TemplateIcon}
+ class="size-6"
+ containerClass="size-9 bg-transparent ring-0"
+ />
+ <div class="min-w-0 flex-1">
+ <h1 class="text-xl font-bold break-words sm:text-2xl">{template.name}</h1>
+ {#if template.description}
+ <p class="text-muted-foreground mt-1.5 text-sm break-words sm:text-base">{template.description}</p>
+ {/if}
+ </div>
</div>
<div class="flex flex-wrap items-center gap-2">
diff --git a/frontend/src/routes/(app)/customize/templates/template-table.svelte b/frontend/src/routes/(app)/customize/templates/template-table.svelte
index df5fcd667..ff041101b 100644
--- a/frontend/src/routes/(app)/customize/templates/template-table.svelte
+++ b/frontend/src/routes/(app)/customize/templates/template-table.svelte
@@ -18,6 +18,7 @@
import { truncateString } from '$lib/utils/string.utils';
import { PersistedState } from 'runed';
import { onMount } from 'svelte';
+ import IconImage from '$lib/components/icon-image.svelte';
import {
InspectIcon,
FolderOpenIcon,
@@ -161,9 +162,18 @@
</script>
{#snippet NameCell({ item }: { item: Template })}
- <a class="font-medium hover:underline" href="/customize/templates/{item.id}">
- {item.name}
- </a>
+ <div class="flex items-center gap-2">
+ <IconImage
+ src={item.metadata?.iconUrl}
+ alt={item.name}
+ fallback={item.isRemote ? GlobeIcon : FolderOpenIcon}
+ class="size-8"
+ containerClass="size-10"
+ />
+ <a class="font-medium hover:underline" href="/customize/templates/{item.id}">
+ {item.name}
+ </a>
+ </div>
{/snippet}
{#snippet DescriptionCell({ item }: { item: Template })}
@@ -210,7 +220,9 @@
{item}
icon={(item) => ({
component: item.isRemote ? GlobeIcon : FolderOpenIcon,
- variant: item.isRemote ? 'emerald' : 'blue'
+ variant: item.isRemote ? 'emerald' : 'blue',
+ imageUrl: item.metadata?.iconUrl,
+ alt: item.name
})}
title={(item) => item.name}
subtitle={(item) => ((mobileFieldVisibility.description ?? true) ? item.description : null)}
diff --git a/types/meta/template_meta.go b/types/meta/template_meta.go
index 9c8fe04cf..aa197abd4 100644
--- a/types/meta/template_meta.go
+++ b/types/meta/template_meta.go
@@ -32,6 +32,11 @@ type TemplateMeta struct {
// Required: false
DocumentationURL *string `json:"documentationUrl,omitempty"`
+ // IconURL is the URL to the template icon extracted from x-arcane metadata.
+ //
+ // Required: false
+ IconURL *string `json:"iconUrl,omitempty"`
+
// UpdatedAt is the date and time when the template was last updated.
//
// Required: false