feat/Add OCI Regisrty repo smurf selm

Author: anket-cd

internal/helm/install.go

@@ -3,6 +3,7 @@ package helm
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
@@ -127,13 +128,17 @@ func LoadChart(chartRef, repoURL, version string, settings *cli.EnvSettings) (*c
 	return loader.Load(chartRef)
 }
 
-// LoadOCIChart loads a chart from an OCI registry
 // LoadOCIChart loads a chart from an OCI registry
 func LoadOCIChart(chartRef, version string, settings *cli.EnvSettings, debug bool) (*chart.Chart, error) {
 	if debug {
 		pterm.Printf("Loading OCI chart: %s (version: %s)\n", chartRef, version)
 	}
 
+	// Ensure cache directory exists
+	if err := ensureHelmCacheDir(settings.RepositoryCache); err != nil {
+		return nil, fmt.Errorf("failed to create helm cache directory: %w", err)
+	}
+
 	// Create registry client
 	registryClient, err := newRegistryClient(debug)
 	if err != nil {
@@ -154,36 +159,67 @@ func LoadOCIChart(chartRef, version string, settings *cli.EnvSettings, debug boo
 
 	// Run the pull command
 	fmt.Printf("⬇️  Pulling OCI chart: %s...\n", chartRef)
-	_, err = pull.Run(chartRef)
+	downloadedFile, err := pull.Run(chartRef)
 	if err != nil {
-		// Check if error is about file not found (might be a temp file issue)
-		if strings.Contains(err.Error(), "no such file or directory") {
-			// Try to find the actual downloaded file
-			return findAndLoadChartFromCache(chartRef, settings, debug)
+		// The error might be about the file path, not the pull itself
+		if debug {
+			fmt.Printf("⚠️  Pull returned error but may have succeeded: %v\n", err)
+			fmt.Printf("⚠️  Downloaded file path from pull.Run(): %s\n", downloadedFile)
 		}
-		return nil, fmt.Errorf("failed to pull OCI chart: %w", err)
+
+		// Continue to try loading the chart anyway
+		return findAndLoadChartFromCache(chartRef, settings, debug)
+	}
+
+	if debug {
+		fmt.Printf("✅ Pull reported success, downloaded to: %s\n", downloadedFile)
 	}
 
 	// Try to find and load the chart
 	return findAndLoadChartFromCache(chartRef, settings, debug)
 }
 
+// Helper function to ensure helm cache directory exists
+func ensureHelmCacheDir(cacheDir string) error {
+	if _, err := os.Stat(cacheDir); os.IsNotExist(err) {
+		fmt.Printf("📁 Creating helm cache directory: %s\n", cacheDir)
+		if err := os.MkdirAll(cacheDir, 0755); err != nil {
+			return fmt.Errorf("failed to create directory %s: %w", cacheDir, err)
+		}
+	} else if err != nil {
+		return fmt.Errorf("failed to check cache directory: %w", err)
+	}
+	return nil
+}
+
 // Helper function to find and load chart from cache
 func findAndLoadChartFromCache(chartRef string, settings *cli.EnvSettings, debug bool) (*chart.Chart, error) {
+	// Ensure directory exists (double-check)
+	if err := ensureHelmCacheDir(settings.RepositoryCache); err != nil {
+		return nil, err
+	}
+
 	// List all files in cache directory
 	files, err := os.ReadDir(settings.RepositoryCache)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read cache directory: %w", err)
+		return nil, fmt.Errorf("failed to read cache directory %s: %w", settings.RepositoryCache, err)
 	}
 
 	if debug {
 		fmt.Printf("📁 Searching for chart in cache directory: %s\n", settings.RepositoryCache)
 		fmt.Printf("📁 Files found (%d):\n", len(files))
 		for i, file := range files {
-			fmt.Printf("  %d. %s (dir: %v)\n", i+1, file.Name(), file.IsDir())
+			info, _ := file.Info()
+			fmt.Printf("  %d. %s (size: %d)\n", i+1, file.Name(), info.Size())
 		}
 	}
 
+	// If no files found, try a different approach
+	if len(files) == 0 {
+		fmt.Println("⚠️  No files found in cache, attempting direct helm CLI pull...")
+		return pullWithHelmCLI(chartRef, settings, debug)
+	}
+
 	// Extract chart name from OCI reference
 	ref := strings.TrimPrefix(chartRef, "oci://")
 	baseName := filepath.Base(ref)
@@ -198,74 +234,153 @@ func findAndLoadChartFromCache(chartRef string, settings *cli.EnvSettings, debug
 		fmt.Printf("🔍 Looking for chart matching: %s\n", chartName)
 	}
 
-	// Look for .tgz files
-	var tgzFiles []string
+	// Look for .tgz files (most common)
 	for _, file := range files {
-		if !file.IsDir() && strings.HasSuffix(file.Name(), ".tgz") {
+		if !file.IsDir() && strings.HasSuffix(strings.ToLower(file.Name()), ".tgz") {
 			fullPath := filepath.Join(settings.RepositoryCache, file.Name())
-			tgzFiles = append(tgzFiles, fullPath)
 
 			if debug {
-				fmt.Printf("   Found .tgz: %s\n", file.Name())
+				fmt.Printf("   Trying .tgz file: %s\n", file.Name())
+			}
+
+			chartObj, err := loader.Load(fullPath)
+			if err == nil {
+				if debug {
+					fmt.Printf("✅ Successfully loaded chart from: %s\n", fullPath)
+				}
+				return chartObj, nil
+			}
+
+			if debug {
+				fmt.Printf("❌ Failed to load as chart: %v\n", err)
 			}
 		}
 	}
 
-	// If no .tgz files found, check for any files that might be the chart
-	if len(tgzFiles) == 0 {
-		if debug {
-			fmt.Println("⚠️  No .tgz files found, checking all files...")
-		}
+	// Try any file (might not have .tgz extension)
+	for _, file := range files {
+		if !file.IsDir() {
+			fullPath := filepath.Join(settings.RepositoryCache, file.Name())
 
-		// Look for any file containing the chart name
-		for _, file := range files {
-			if !file.IsDir() && strings.Contains(strings.ToLower(file.Name()), strings.ToLower(chartName)) {
-				fullPath := filepath.Join(settings.RepositoryCache, file.Name())
-				tgzFiles = append(tgzFiles, fullPath)
+			if debug {
+				fmt.Printf("   Trying any file: %s\n", file.Name())
+			}
 
+			chartObj, err := loader.Load(fullPath)
+			if err == nil {
 				if debug {
-					fmt.Printf("   Found matching file: %s\n", file.Name())
+					fmt.Printf("✅ Successfully loaded chart from: %s\n", fullPath)
 				}
+				return chartObj, nil
 			}
 		}
 	}
 
-	// Try to load each potential file
-	for _, filePath := range tgzFiles {
-		if debug {
-			fmt.Printf("🔄 Attempting to load: %s\n", filePath)
-		}
+	return nil, fmt.Errorf("no valid chart file found in cache directory: %s", settings.RepositoryCache)
+}
 
-		chartObj, err := loader.Load(filePath)
-		if err == nil {
-			if debug {
-				fmt.Printf("✅ Successfully loaded chart from: %s\n", filePath)
-			}
-			return chartObj, nil
+// Fallback function using helm CLI directly
+func pullWithHelmCLI(chartRef string, settings *cli.EnvSettings, debug bool) (*chart.Chart, error) {
+	fmt.Printf("🔄 Using helm CLI for OCI pull...\n")
+
+	// Ensure cache directory exists
+	if err := ensureHelmCacheDir(settings.RepositoryCache); err != nil {
+		return nil, err
+	}
+
+	// Create a temporary directory
+	tempDir, err := os.MkdirTemp("", "helm-oci-*")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temp directory: %w", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Build helm command
+	args := []string{"pull", chartRef, "--destination", tempDir}
+
+	// Add version if specified
+	if strings.Contains(chartRef, ":") {
+		// Version might be in the chartRef itself
+		fmt.Printf("📦 Chart reference includes version/tag\n")
+	} else {
+		// Parse version from chartRef or use default
+		ref := strings.TrimPrefix(chartRef, "oci://")
+		if idx := strings.LastIndex(ref, ":"); idx != -1 {
+			version := ref[idx+1:]
+			args = append(args, "--version", version)
 		}
+	}
 
-		if debug {
-			fmt.Printf("❌ Failed to load %s: %v\n", filePath, err)
+	if debug {
+		args = append(args, "--debug")
+	}
+
+	// Execute helm pull
+	cmd := exec.Command("helm", args...)
+	cmd.Env = os.Environ()
+
+	// Enable OCI experimental feature
+	cmd.Env = append(cmd.Env, "HELM_EXPERIMENTAL_OCI=1")
+
+	// Handle GitHub Container Registry authentication
+	if strings.Contains(chartRef, "ghcr.io") {
+		fmt.Println("🔑 Detected GHCR registry")
+		if token := os.Getenv("GITHUB_TOKEN"); token != "" {
+			fmt.Println("🔑 Using GITHUB_TOKEN for authentication")
+			// Helm should automatically use GITHUB_TOKEN for ghcr.io
+			cmd.Env = append(cmd.Env, "GITHUB_TOKEN="+token)
 		}
 	}
 
-	// Last resort: try to find any file that can be loaded as a chart
-	if len(tgzFiles) == 0 {
-		for _, file := range files {
-			if !file.IsDir() {
-				filePath := filepath.Join(settings.RepositoryCache, file.Name())
-				chartObj, err := loader.Load(filePath)
-				if err == nil {
-					if debug {
-						fmt.Printf("✅ Successfully loaded chart from unexpected file: %s\n", filePath)
-					}
-					return chartObj, nil
+	output, err := cmd.CombinedOutput()
+	if debug {
+		fmt.Printf("📋 Helm CLI output:\n%s\n", output)
+	}
+
+	if err != nil {
+		return nil, fmt.Errorf("helm CLI pull failed: %w\nOutput: %s", err, output)
+	}
+
+	// Find and load the downloaded chart
+	files, err := os.ReadDir(tempDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read temp directory: %w", err)
+	}
+
+	for _, file := range files {
+		if !file.IsDir() {
+			fullPath := filepath.Join(tempDir, file.Name())
+			fmt.Printf("📦 Attempting to load: %s\n", file.Name())
+
+			chartObj, err := loader.Load(fullPath)
+			if err == nil {
+				fmt.Printf("✅ Successfully loaded chart\n")
+
+				// Copy to cache directory for future use
+				cachePath := filepath.Join(settings.RepositoryCache, file.Name())
+				if err := copyFile(fullPath, cachePath); err == nil && debug {
+					fmt.Printf("📁 Copied to cache: %s\n", cachePath)
 				}
+
+				return chartObj, nil
+			}
+
+			if debug {
+				fmt.Printf("❌ Failed to load: %v\n", err)
 			}
 		}
 	}
 
-	return nil, fmt.Errorf("no chart file found in cache directory: %s", settings.RepositoryCache)
+	return nil, fmt.Errorf("no chart file found after helm pull")
+}
+
+// Helper function to copy file
+func copyFile(src, dst string) error {
+	input, err := os.ReadFile(src)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(dst, input, 0644)
 }
 
 // newRegistryClient creates a registry client for OCI operations
@@ -320,7 +435,14 @@ func helmHome() string {
 		return home
 	}
 	userHome, _ := os.UserHomeDir()
-	return filepath.Join(userHome, ".helm")
+	helmPath := filepath.Join(userHome, ".helm")
+
+	// Ensure directory exists
+	if _, err := os.Stat(helmPath); os.IsNotExist(err) {
+		os.MkdirAll(helmPath, 0755)
+	}
+
+	return helmPath
 }
 
 // loadFromLocalRepo loads a chart from a local repository