begin support for helm-charts

pkg/appview/db/models.go

···
 	MediaType     string
 	ConfigDigest  string
 	ConfigSize    int64
+	ArtifactType  string // container-image, helm-chart, unknown
 	CreatedAt     time.Time
 	// Annotations removed - now stored in repository_annotations table
 }
···
 	CreatedAt    time.Time
 	HoldEndpoint string // Hold endpoint for health checking
 	Reachable    bool   // Whether the hold endpoint is reachable
+	ArtifactType string // container-image, helm-chart, unknown
 }
 
 // Repository represents an aggregated view of a user's repository
···
 
 // FeaturedRepository represents a repository in the featured section
 type FeaturedRepository struct {
-	OwnerDID    string
-	OwnerHandle string
-	Repository  string
-	Title       string
-	Description string
-	IconURL     string
-	StarCount   int
-	PullCount   int
-	IsStarred   bool // Whether the current user has starred this repository
+	OwnerDID     string
+	OwnerHandle  string
+	Repository   string
+	Title        string
+	Description  string
+	IconURL      string
+	StarCount    int
+	PullCount    int
+	IsStarred    bool   // Whether the current user has starred this repository
+	ArtifactType string // container-image, helm-chart, unknown
 }
 
 // RepositoryWithStats combines repository data with statistics
···
 
 // RepoCardData contains all data needed to render a repository card
 type RepoCardData struct {
-	OwnerHandle string
-	Repository  string
-	Title       string
-	Description string
-	IconURL     string
-	StarCount   int
-	PullCount   int
-	IsStarred   bool // Whether the current user has starred this repository
+	OwnerHandle  string
+	Repository   string
+	Title        string
+	Description  string
+	IconURL      string
+	StarCount    int
+	PullCount    int
+	IsStarred    bool   // Whether the current user has starred this repository
+	ArtifactType string // container-image, helm-chart, unknown
 }
 
 // PlatformInfo represents platform information (OS/Architecture)
···
 	HasAttestations bool // true if manifest list contains attestation references
 	Reachable       bool // Whether the hold endpoint is reachable
 	Pending         bool // Whether health check is still in progress
+	// Note: ArtifactType is available via embedded Manifest struct
 }

pkg/appview/db/queries.go

···
 	return fmt.Sprintf("https://imgs.blue/%s/%s", did, cid)
 }
 
+// GetArtifactType determines the artifact type based on config media type
+// Returns: "helm-chart", "container-image", or "unknown"
+func GetArtifactType(configMediaType string) string {
+	switch {
+	case strings.Contains(configMediaType, "helm.config"):
+		return "helm-chart"
+	case strings.Contains(configMediaType, "oci.image.config") ||
+		strings.Contains(configMediaType, "docker.container.image"):
+		return "container-image"
+	case configMediaType == "":
+		// Manifest lists don't have a config - treat as container-image
+		return "container-image"
+	default:
+		return "unknown"
+	}
+}
+
 // escapeLikePattern escapes SQL LIKE wildcards (%, _) and backslash for safe searching.
 // It also sanitizes the input to prevent injection attacks via special characters.
 func escapeLikePattern(s string) string {
···
             COALESCE((SELECT COUNT(*) FROM stars WHERE starrer_did = ? AND owner_did = u.did AND repository = t.repository), 0),
             t.created_at,
             m.hold_endpoint,
-            COALESCE(rp.avatar_cid, '')
+            COALESCE(rp.avatar_cid, ''),
+            COALESCE(m.artifact_type, 'container-image')
         FROM tags t
         JOIN users u ON t.did = u.did
         JOIN manifests m ON t.did = m.did AND t.repository = m.repository AND t.digest = m.digest
···
 		var p Push
 		var isStarredInt int
 		var avatarCID string
-		if err := rows.Scan(&p.DID, &p.Handle, &p.Repository, &p.Tag, &p.Digest, &p.Title, &p.Description, &p.IconURL, &p.PullCount, &p.StarCount, &isStarredInt, &p.CreatedAt, &p.HoldEndpoint, &avatarCID); err != nil {
+		if err := rows.Scan(&p.DID, &p.Handle, &p.Repository, &p.Tag, &p.Digest, &p.Title, &p.Description, &p.IconURL, &p.PullCount, &p.StarCount, &isStarredInt, &p.CreatedAt, &p.HoldEndpoint, &avatarCID, &p.ArtifactType); err != nil {
 			return nil, 0, err
 		}
 		p.IsStarred = isStarredInt > 0
···
             COALESCE((SELECT COUNT(*) FROM stars WHERE starrer_did = ? AND owner_did = u.did AND repository = t.repository), 0),
             t.created_at,
             m.hold_endpoint,
-            COALESCE(rp.avatar_cid, '')
+            COALESCE(rp.avatar_cid, ''),
+            COALESCE(m.artifact_type, 'container-image')
         FROM tags t
         JOIN users u ON t.did = u.did
         JOIN manifests m ON t.did = m.did AND t.repository = m.repository AND t.digest = m.digest
···
 		var p Push
 		var isStarredInt int
 		var avatarCID string
-		if err := rows.Scan(&p.DID, &p.Handle, &p.Repository, &p.Tag, &p.Digest, &p.Title, &p.Description, &p.IconURL, &p.PullCount, &p.StarCount, &isStarredInt, &p.CreatedAt, &p.HoldEndpoint, &avatarCID); err != nil {
+		if err := rows.Scan(&p.DID, &p.Handle, &p.Repository, &p.Tag, &p.Digest, &p.Title, &p.Description, &p.IconURL, &p.PullCount, &p.StarCount, &isStarredInt, &p.CreatedAt, &p.HoldEndpoint, &avatarCID, &p.ArtifactType); err != nil {
 			return nil, 0, err
 		}
 		p.IsStarred = isStarredInt > 0
···
 		// Get manifests for this repo
 		manifestRows, err := db.Query(`
             SELECT id, digest, hold_endpoint, schema_version, media_type,
-                   config_digest, config_size, created_at
+                   config_digest, config_size, artifact_type, created_at
             FROM manifests
             WHERE did = ? AND repository = ?
             ORDER BY created_at DESC
···
 			m.Repository = r.Name
 
 			if err := manifestRows.Scan(&m.ID, &m.Digest, &m.HoldEndpoint, &m.SchemaVersion,
-				&m.MediaType, &m.ConfigDigest, &m.ConfigSize, &m.CreatedAt); err != nil {
+				&m.MediaType, &m.ConfigDigest, &m.ConfigSize, &m.ArtifactType, &m.CreatedAt); err != nil {
 				manifestRows.Close()
 				return nil, err
 			}
···
 	_, err := db.Exec(`
         INSERT INTO manifests
         (did, repository, digest, hold_endpoint, schema_version, media_type,
-         config_digest, config_size, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         config_digest, config_size, artifact_type, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(did, repository, digest) DO UPDATE SET
             hold_endpoint = excluded.hold_endpoint,
             schema_version = excluded.schema_version,
             media_type = excluded.media_type,
             config_digest = excluded.config_digest,
-            config_size = excluded.config_size
+            config_size = excluded.config_size,
+            artifact_type = excluded.artifact_type
     `, manifest.DID, manifest.Repository, manifest.Digest, manifest.HoldEndpoint,
 		manifest.SchemaVersion, manifest.MediaType, manifest.ConfigDigest,
-		manifest.ConfigSize, manifest.CreatedAt)
+		manifest.ConfigSize, manifest.ArtifactType, manifest.CreatedAt)
 
 	if err != nil {
 		return 0, err
···
         SELECT
             m.id, m.did, m.repository, m.digest, m.media_type,
             m.schema_version, m.created_at,
-            m.config_digest, m.config_size, m.hold_endpoint,
+            m.config_digest, m.config_size, m.hold_endpoint, m.artifact_type,
             GROUP_CONCAT(DISTINCT t.tag) as tags,
             COUNT(DISTINCT mr.digest) as platform_count
         FROM manifests m
···
 		if err := rows.Scan(
 			&m.ID, &m.DID, &m.Repository, &m.Digest, &m.MediaType,
 			&m.SchemaVersion, &m.CreatedAt,
-			&configDigest, &configSize, &m.HoldEndpoint,
+			&configDigest, &configSize, &m.HoldEndpoint, &m.ArtifactType,
 			&tags, &m.PlatformCount,
 		); err != nil {
 			return nil, err
···
         SELECT
             m.id, m.did, m.repository, m.digest, m.media_type,
             m.schema_version, m.created_at,
-            m.config_digest, m.config_size, m.hold_endpoint,
+            m.config_digest, m.config_size, m.hold_endpoint, m.artifact_type,
             GROUP_CONCAT(DISTINCT t.tag) as tags
         FROM manifests m
         LEFT JOIN tags t ON m.digest = t.digest AND m.did = t.did AND m.repository = t.repository
···
     `, did, repository, digest).Scan(
 		&m.ID, &m.DID, &m.Repository, &m.Digest, &m.MediaType,
 		&m.SchemaVersion, &m.CreatedAt,
-		&configDigest, &configSize, &m.HoldEndpoint,
+		&configDigest, &configSize, &m.HoldEndpoint, &m.ArtifactType,
 		&tags,
 	)
 
···
 	// Get manifests for this repo
 	manifestRows, err := db.Query(`
         SELECT id, digest, hold_endpoint, schema_version, media_type,
-               config_digest, config_size, created_at
+               config_digest, config_size, artifact_type, created_at
         FROM manifests
         WHERE did = ? AND repository = ?
         ORDER BY created_at DESC
···
 		m.Repository = repository
 
 		if err := manifestRows.Scan(&m.ID, &m.Digest, &m.HoldEndpoint, &m.SchemaVersion,
-			&m.MediaType, &m.ConfigDigest, &m.ConfigSize, &m.CreatedAt); err != nil {
+			&m.MediaType, &m.ConfigDigest, &m.ConfigSize, &m.ArtifactType, &m.CreatedAt); err != nil {
 			manifestRows.Close()
 			return nil, err
 		}
···
 			rs.pull_count,
 			rs.star_count,
 			COALESCE((SELECT COUNT(*) FROM stars WHERE starrer_did = ? AND owner_did = m.did AND repository = m.repository), 0),
-			COALESCE(rp.avatar_cid, '')
+			COALESCE(rp.avatar_cid, ''),
+			COALESCE(m.artifact_type, 'container-image')
 		FROM latest_manifests lm
 		JOIN manifests m ON lm.latest_id = m.id
 		JOIN users u ON m.did = u.did
···
 		var avatarCID string
 
 		if err := rows.Scan(&f.OwnerDID, &f.OwnerHandle, &f.Repository,
-			&f.Title, &f.Description, &f.IconURL, &f.PullCount, &f.StarCount, &isStarredInt, &avatarCID); err != nil {
+			&f.Title, &f.Description, &f.IconURL, &f.PullCount, &f.StarCount, &isStarredInt, &avatarCID, &f.ArtifactType); err != nil {
 			return nil, err
 		}
 		f.IsStarred = isStarredInt > 0

pkg/appview/db/schema.sql

···
     media_type TEXT NOT NULL,
     config_digest TEXT,
     config_size INTEGER,
+    artifact_type TEXT NOT NULL DEFAULT 'container-image',  -- container-image, helm-chart, unknown
     created_at TIMESTAMP NOT NULL,
     UNIQUE(did, repository, digest),
     FOREIGN KEY(did) REFERENCES users(did) ON DELETE CASCADE
···
 CREATE INDEX IF NOT EXISTS idx_manifests_did_repo ON manifests(did, repository);
 CREATE INDEX IF NOT EXISTS idx_manifests_created_at ON manifests(created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_manifests_digest ON manifests(digest);
+CREATE INDEX IF NOT EXISTS idx_manifests_artifact_type ON manifests(artifact_type);
 
 CREATE TABLE IF NOT EXISTS repository_annotations (
     did TEXT NOT NULL,

pkg/appview/handlers/home.go

···
 	cards := make([]db.RepoCardData, len(featured))
 	for i, repo := range featured {
 		cards[i] = db.RepoCardData{
-			OwnerHandle: repo.OwnerHandle,
-			Repository:  repo.Repository,
-			Title:       repo.Title,
-			Description: repo.Description,
-			IconURL:     repo.IconURL,
-			StarCount:   repo.StarCount,
-			PullCount:   repo.PullCount,
-			IsStarred:   repo.IsStarred,
+			OwnerHandle:  repo.OwnerHandle,
+			Repository:   repo.Repository,
+			Title:        repo.Title,
+			Description:  repo.Description,
+			IconURL:      repo.IconURL,
+			StarCount:    repo.StarCount,
+			PullCount:    repo.PullCount,
+			IsStarred:    repo.IsStarred,
+			ArtifactType: repo.ArtifactType,
 		}
 	}
 

pkg/appview/handlers/repository.go

···
 		}
 	}
 
+	// Determine dominant artifact type from manifests
+	artifactType := "container-image"
+	if len(manifests) > 0 {
+		// Use the most recent manifest's artifact type
+		artifactType = manifests[0].ArtifactType
+	}
+
 	data := struct {
 		PageData
-		Owner      *db.User                  // Repository owner
-		Repository *db.Repository            // Repository summary
-		Tags       []db.TagWithPlatforms     // Tags with platform info
-		Manifests  []db.ManifestWithMetadata // Top-level manifests only
-		StarCount  int
-		IsStarred  bool
-		IsOwner    bool // Whether current user owns this repository
-		ReadmeHTML template.HTML
+		Owner        *db.User                  // Repository owner
+		Repository   *db.Repository            // Repository summary
+		Tags         []db.TagWithPlatforms     // Tags with platform info
+		Manifests    []db.ManifestWithMetadata // Top-level manifests only
+		StarCount    int
+		IsStarred    bool
+		IsOwner      bool // Whether current user owns this repository
+		ReadmeHTML   template.HTML
+		ArtifactType string // Dominant artifact type: container-image, helm-chart, unknown
 	}{
-		PageData:   NewPageData(r, h.RegistryURL),
-		Owner:      owner,
-		Repository: repo,
-		Tags:       tagsWithPlatforms,
-		Manifests:  manifests,
-		StarCount:  stats.StarCount,
-		IsStarred:  isStarred,
-		IsOwner:    isOwner,
-		ReadmeHTML: readmeHTML,
+		PageData:     NewPageData(r, h.RegistryURL),
+		Owner:        owner,
+		Repository:   repo,
+		Tags:         tagsWithPlatforms,
+		Manifests:    manifests,
+		StarCount:    stats.StarCount,
+		IsStarred:    isStarred,
+		IsOwner:      isOwner,
+		ReadmeHTML:   readmeHTML,
+		ArtifactType: artifactType,
 	}
 
 	if err := h.Templates.ExecuteTemplate(w, "repository", data); err != nil {

pkg/appview/jetstream/backfill.go

···
 
 	return &BackfillWorker{
 		db:             database,
-		client:         client,                             // This points to the relay
+		client:         client,                                         // This points to the relay
 		processor:      NewProcessor(database, false, NewStatsCache()), // Stats cache for aggregation
 		defaultHoldDID: defaultHoldDID,
 		testMode:       testMode,

pkg/appview/jetstream/processor.go

···
 		holdDID = atproto.ResolveHoldDIDFromURL(manifestRecord.HoldEndpoint)
 	}
 
+	// Detect artifact type from config media type
+	artifactType := "container-image"
+	if !isManifestList && manifestRecord.Config != nil {
+		artifactType = db.GetArtifactType(manifestRecord.Config.MediaType)
+	}
+
 	// Prepare manifest for insertion (WITHOUT annotation fields)
 	manifest := &db.Manifest{
 		DID:           did,
···
 		MediaType:     manifestRecord.MediaType,
 		SchemaVersion: manifestRecord.SchemaVersion,
 		HoldEndpoint:  holdDID,
+		ArtifactType:  artifactType,
 		CreatedAt:     manifestRecord.CreatedAt,
 		// Annotations removed - stored separately in repository_annotations table
 	}

pkg/appview/static/css/style.css

···
         font-size: 1.5rem;
     }
 }
+
+/* Artifact type badges */
+.artifact-badge {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0.15rem 0.35rem;
+    border-radius: 4px;
+    font-size: 0.7rem;
+    font-weight: 500;
+    margin-left: 0.5rem;
+    vertical-align: middle;
+}
+
+.artifact-badge.helm {
+    background-color: rgba(13, 108, 191, 0.15);
+    color: #0d6cbf;
+}
+
+.artifact-badge i {
+    width: 12px;
+    height: 12px;
+}
+
+.manifest-type.helm {
+    background-color: rgba(13, 108, 191, 0.15);
+    color: #0d6cbf;
+}

pkg/appview/templates/components/repo-card.html

···
     - IconURL: string (optional) - Repository icon URL
     - StarCount: int - Number of stars
     - PullCount: int - Number of pulls
+    - ArtifactType: string - container-image, helm-chart, unknown
 */}}
 <a href="/r/{{ .OwnerHandle }}/{{ .Repository }}" class="featured-card">
     <div class="featured-header">
···
                 <span class="featured-owner">{{ .OwnerHandle }}</span>
                 <span class="featured-separator">/</span>
                 <span class="featured-name">{{ .Repository }}</span>
+                {{ if eq .ArtifactType "helm-chart" }}
+                    <span class="artifact-badge helm"><i data-lucide="anchor"></i></span>
+                {{ end }}
             </div>
             {{ if .Description }}
                 <p class="featured-description">{{ .Description }}</p>

pkg/appview/templates/pages/repository.html

···
 
                 <!-- Pull Command -->
                 <div class="pull-command-section">
+                    {{ if eq .ArtifactType "helm-chart" }}
+                    <h3>Pull this chart</h3>
+                    {{ if .Tags }}
+                        {{ $firstTag := index .Tags 0 }}
+                        {{ template "docker-command" (print "helm pull oci://" $.RegistryURL "/" $.Owner.Handle "/" $.Repository.Name " --version " $firstTag.Tag.Tag) }}
+                    {{ else }}
+                        {{ template "docker-command" (print "helm pull oci://" $.RegistryURL "/" $.Owner.Handle "/" $.Repository.Name) }}
+                    {{ end }}
+                    {{ else }}
                     <h3>Pull this image</h3>
                     {{ if .Tags }}
                         {{ $firstTag := index .Tags 0 }}
                         {{ template "docker-command" (print "docker pull " $.RegistryURL "/" $.Owner.Handle "/" $.Repository.Name ":" $firstTag.Tag.Tag) }}
                     {{ else }}
                         {{ template "docker-command" (print "docker pull " $.RegistryURL "/" $.Owner.Handle "/" $.Repository.Name ":latest") }}
+                    {{ end }}
                     {{ end }}
                 </div>
             </div>
···
                                     {{ end }}
                                 </div>
                             </div>
-                            {{ template "docker-command" (print "docker pull " $.RegistryURL "/" $.Owner.Handle "/" $.Repository.Name ":" .Tag.Tag) }}
+                            {{ if eq $.ArtifactType "helm-chart" }}
+                                {{ template "docker-command" (print "helm pull oci://" $.RegistryURL "/" $.Owner.Handle "/" $.Repository.Name " --version " .Tag.Tag) }}
+                            {{ else }}
+                                {{ template "docker-command" (print "docker pull " $.RegistryURL "/" $.Owner.Handle "/" $.Repository.Name ":" .Tag.Tag) }}
+                            {{ end }}
                         </div>
                         {{ end }}
                     </div>
···
                                 <div>
                                     {{ if .IsManifestList }}
                                         <span class="manifest-type"><i data-lucide="package"></i> Multi-arch</span>
+                                    {{ else if eq .ArtifactType "helm-chart" }}
+                                        <span class="manifest-type helm"><i data-lucide="anchor"></i> Helm Chart</span>
                                     {{ else }}
-                                        <span class="manifest-type"><i data-lucide="file-text"></i> Image</span>
+                                        <span class="manifest-type"><i data-lucide="box"></i> Image</span>
                                     {{ end }}
                                     {{ if .HasAttestations }}
                                         <span class="badge-attestation"><i data-lucide="shield-check"></i> Attestations</span>

pkg/appview/templates/partials/push-list.html

···
                     <a href="/r/{{ .Handle }}/{{ .Repository }}" class="push-repo">{{ .Repository }}</a>
                     <span class="push-separator">:</span>
                     <span class="push-tag">{{ .Tag }}</span>
+                    {{ if eq .ArtifactType "helm-chart" }}
+                        <span class="artifact-badge helm"><i data-lucide="anchor"></i></span>
+                    {{ end }}
                 </div>
                 <div class="push-stats">
                     <span class="push-stat">

pkg/auth/oauth/client.go

···
 		"blob:application/vnd.docker.distribution.manifest.list.v2+json",
 		// OCI artifact manifests (for cosign signatures, SBOMs, attestations)
 		"blob:application/vnd.cncf.oras.artifact.manifest.v1+json",
+		// Helm chart support
+		"blob:application/vnd.cncf.helm.config.v1+json",
+		"blob:application/vnd.cncf.helm.chart.content.v1.tar+gzip",
 		// Image avatars
 		"blob:image/*",
 	}