feat: add functions to exclude files from bundling in extensions

Author: archandatta

cmd/extensions.go

@@ -294,31 +294,94 @@ func (e ExtensionsCmd) Upload(ctx context.Context, in ExtensionsUploadInput) err
 		return fmt.Errorf("directory %s does not exist", absDir)
 	}
 
+	// Pre-flight size check
+	if in.Output != "json" {
+		pterm.Info.Println("Analyzing extension directory...")
+	}
+
+	estimatedSize, err := estimateExtensionSize(absDir)
+	if err != nil {
+		pterm.Warning.Printf("Could not estimate size: %v\n", err)
+	} else {
+		const maxSize = 50 * 1024 * 1024
+		if estimatedSize > maxSize {
+			pterm.Error.Printf("Estimated bundle size (%s) exceeds limit (50MB)\n",
+				formatBytes(estimatedSize))
+			pterm.Info.Println("\nTo reduce size:")
+			pterm.Info.Println("  1. Ensure node_modules/ is not needed (already excluded)")
+			pterm.Info.Println("  2. Remove large assets or documentation files")
+			pterm.Info.Println("  3. Build extension for production (minified)")
+			return fmt.Errorf("bundle would exceed maximum size")
+		}
+
+		if in.Output != "json" {
+			pterm.Info.Printf("Estimated bundle size: %s\n", formatBytes(estimatedSize))
+		}
+	}
+
 	tmpFile := filepath.Join(os.TempDir(), fmt.Sprintf("kernel_ext_%d.zip", time.Now().UnixNano()))
+
 	if in.Output != "json" {
 		pterm.Info.Println("Zipping extension directory...")
 	}
-	if err := util.ZipDirectory(absDir, tmpFile); err != nil {
+
+	// Use new extension-specific zip function
+	stats, err := util.ZipExtensionDirectory(absDir, tmpFile, &util.ExtensionZipOptions{
+		ExcludeDefaults: false, // Apply defaults
+		Verbose:         false,
+	})
+	if err != nil {
 		pterm.Error.Println("Failed to zip directory")
 		return err
 	}
 	defer os.Remove(tmpFile)
 
+	// Show helpful stats
+	if in.Output != "json" {
+		pterm.Success.Printf("Created bundle: %s (%d files)\n",
+			formatBytes(stats.BytesIncluded), stats.FilesIncluded)
+	}
+
+	// Final size validation
+	fileInfo, err := os.Stat(tmpFile)
+	if err != nil {
+		return fmt.Errorf("failed to stat zip: %w", err)
+	}
+
+	const maxSize = 50 * 1024 * 1024
+	if fileInfo.Size() > maxSize {
+		pterm.Error.Printf("Extension bundle is too large: %s (max: 50MB)\n",
+			formatBytes(fileInfo.Size()))
+		pterm.Info.Println("\nSuggestions to reduce size:")
+		pterm.Info.Println("  1. Ensure you're building the extension for production")
+		pterm.Info.Println("  2. Remove unnecessary assets (large images, videos)")
+		pterm.Info.Println("  3. Check manifest.json references only needed files")
+		return fmt.Errorf("bundle exceeds maximum size")
+	}
+
+	// Open file for upload
 	f, err := os.Open(tmpFile)
 	if err != nil {
 		return fmt.Errorf("failed to open temp zip: %w", err)
 	}
 	defer f.Close()
 
+	// Upload
+	if in.Output != "json" {
+		pterm.Info.Println("Uploading extension...")
+	}
+
 	params := kernel.ExtensionUploadParams{File: f}
 	if in.Name != "" {
 		params.Name = kernel.Opt(in.Name)
 	}
+
 	item, err := e.extensions.Upload(ctx, params)
 	if err != nil {
 		return util.CleanedUpSdkError{Err: err}
 	}
 
+	// Display results
 	if in.Output == "json" {
 		return util.PrintPrettyJSON(item)
 	}
@@ -336,6 +399,62 @@ func (e ExtensionsCmd) Upload(ctx context.Context, in ExtensionsUploadInput) err
 	return nil
 }
 
+// formatBytes formats bytes in a human-readable format
+func formatBytes(bytes int64) string {
+	const unit = 1024
+	if bytes < unit {
+		return fmt.Sprintf("%d B", bytes)
+	}
+	div, exp := int64(unit), 0
+	for n := bytes / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}
+
+// estimateExtensionSize walks the directory and estimates the final zip size
+// This provides fast feedback if the bundle will be too large
+func estimateExtensionSize(srcDir string) (int64, error) {
+	var totalSize int64
+	excludeMap := make(map[string]bool)
+
+	// Build exclusion map for fast lookup
+	for _, pattern := range util.DefaultExtensionExclusions.ExcludeDirectory {
+		excludeMap[pattern] = true
+	}
+
+	err := filepath.Walk(srcDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		// Check if path should be excluded
+		if info.IsDir() {
+			if excludeMap[filepath.Base(path)] {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+
+		// Check against exact file names
+		base := filepath.Base(path)
+		// Check against file patterns
+		for _, pattern := range util.DefaultExtensionExclusions.ExcludeFilenamePatterns {
+			if matched, _ := filepath.Match(pattern, base); matched {
+				return nil
+			}
+		}
+
+		totalSize += info.Size()
+		return nil
+	})
+
+	// Zip typically compresses 20-40% for code/text files
+	// Use conservative 30% compression estimate
+	return int64(float64(totalSize) * 0.7), err
+}
+
 // --- Cobra wiring ---
 
 var extensionsCmd = &cobra.Command{

pkg/util/zip_extensions.go

@@ -0,0 +1,225 @@
+package util
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/boyter/gocodewalker"
+)
+
+// DefaultExtensionExclusions contains patterns for files that are not needed
+// Focus on large directories and files that provide meaningful size reduction.
+// These will be passed to gocodewalker's ExcludeDirectory and ExcludeFilename fields.
+var DefaultExtensionExclusions = struct {
+	// ExcludeDirectory: exact directory names (case-sensitive)
+	ExcludeDirectory []string
+	// ExcludeFilenamePatterns: patterns for filename matching (handled manually)
+	ExcludeFilenamePatterns []string
+}{
+	ExcludeDirectory: []string{
+		// Dependencies
+		"node_modules",
+
+		// Version control
+		".git",
+
+		// Test/Coverage
+		"__tests__",
+		"coverage",
+	},
+
+	ExcludeFilenamePatterns: []string{
+		// Test files
+		"*.test.js",
+		"*.test.ts",
+		"*.spec.js",
+		"*.spec.ts",
+
+		// Log files
+		"*.log",
+
+		// Temp files
+		"*.swp",
+	},
+}
+
+// ExtensionZipOptions configures extension-specific zipping behavior
+type ExtensionZipOptions struct {
+	ExcludeDefaults bool // If true, don't apply default exclusions
+	Verbose         bool // Track individual excluded files
+}
+
+// ZipStats tracks statistics about the zipping operation
+type ZipStats struct {
+	mu            sync.Mutex
+	FilesIncluded int
+	FilesExcluded int
+	BytesIncluded int64
+	BytesExcluded int64
+	ExcludedPaths []string
+}
+
+func (s *ZipStats) AddIncluded(bytes int64) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.FilesIncluded++
+	s.BytesIncluded += bytes
+}
+
+func (s *ZipStats) AddExcluded(path string, bytes int64, verbose bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.FilesExcluded++
+	s.BytesExcluded += bytes
+	if verbose {
+		s.ExcludedPaths = append(s.ExcludedPaths, path)
+	}
+}
+
+// ZipExtensionDirectory zips a Chrome extension directory with smart defaults
+// that automatically exclude development files (node_modules, .git, etc.)
+func ZipExtensionDirectory(srcDir, destZip string, opts *ExtensionZipOptions) (*ZipStats, error) {
+	if opts == nil {
+		opts = &ExtensionZipOptions{}
+	}
+
+	stats := &ZipStats{}
+
+	zipFile, err := os.Create(destZip)
+	if err != nil {
+		return nil, err
+	}
+	defer zipFile.Close()
+
+	zipWriter := zip.NewWriter(zipFile)
+	defer zipWriter.Close()
+
+	// Configure file walker with exclusions
+	fileQueue := make(chan *gocodewalker.File, 256)
+	walker := gocodewalker.NewFileWalker(srcDir, fileQueue)
+	walker.IncludeHidden = true
+
+	// Apply default exclusions unless disabled
+	if !opts.ExcludeDefaults {
+		walker.ExcludeDirectory = append(walker.ExcludeDirectory, DefaultExtensionExclusions.ExcludeDirectory...)
+		walker.ExcludeFilename = append(walker.ExcludeFilename, DefaultExtensionExclusions.ExcludeFilenamePatterns...)
+	}
+
+	// Track walker errors
+	errChan := make(chan error, 1)
+	go func() {
+		errChan <- walker.Start()
+	}()
+
+	// Track directories we've added to avoid duplicates
+	dirsAdded := make(map[string]struct{})
+
+	// Process files from walker
+	for f := range fileQueue {
+		relPath, err := filepath.Rel(srcDir, f.Location)
+		if err != nil {
+			return stats, err
+		}
+		relPath = filepath.ToSlash(relPath)
+
+		// Check against pattern-based exclusions (if defaults are enabled)
+		shouldExclude := false
+		if !opts.ExcludeDefaults {
+			// Check filename against patterns only if defaults are enabled
+			filename := filepath.Base(f.Location)
+			for _, pattern := range DefaultExtensionExclusions.ExcludeFilenamePatterns {
+				matched, err := filepath.Match(pattern, filename)
+				if err == nil && matched {
+					shouldExclude = true
+					break
+				}
+			}
+		}
+
+		if shouldExclude {
+			continue
+		}
+
+		// Ensure parent directories exist in archive
+		if dir := filepath.Dir(relPath); dir != "." && dir != "" {
+			segments := strings.Split(dir, "/")
+			var current string
+			for _, segment := range segments {
+				if current == "" {
+					current = segment
+				} else {
+					current = current + "/" + segment
+				}
+				if _, exists := dirsAdded[current+"/"]; !exists {
+					if _, err := zipWriter.Create(current + "/"); err != nil {
+						return stats, err
+					}
+					dirsAdded[current+"/"] = struct{}{}
+				}
+			}
+		}
+
+		// Get file info
+		fileInfo, err := os.Lstat(f.Location)
+		if err != nil {
+			return stats, err
+		}
+
+		// Handle symlinks
+		if fileInfo.Mode()&os.ModeSymlink != 0 {
+			linkTarget, err := os.Readlink(f.Location)
+			if err != nil {
+				return stats, err
+			}
+
+			hdr := &zip.FileHeader{
+				Name:   relPath,
+				Method: zip.Store,
+			}
+			hdr.SetMode(os.ModeSymlink | 0777)
+
+			zipFileWriter, err := zipWriter.CreateHeader(hdr)
+			if err != nil {
+				return stats, err
+			}
+			if _, err := zipFileWriter.Write([]byte(linkTarget)); err != nil {
+				return stats, err
+			}
+			stats.AddIncluded(int64(len(linkTarget)))
+		} else {
+			// Regular file
+			zipFileWriter, err := zipWriter.Create(relPath)
+			if err != nil {
+				return stats, err
+			}
+
+			file, err := os.Open(f.Location)
+			if err != nil {
+				return stats, err
+			}
+
+			written, err := io.Copy(zipFileWriter, file)
+			closeErr := file.Close()
+			if closeErr != nil {
+				return stats, closeErr
+			}
+			if err != nil {
+				return stats, err
+			}
+
+			stats.AddIncluded(written)
+		}
+	}
+
+	// Check if walker had an error
+	if err := <-errChan; err != nil {
+		return stats, fmt.Errorf("directory walk failed: %w", err)
+	}
+
+	return stats, nil
+}