fix(cache): upload successfully built packages even when build fails

When building packages with dependencies, if any dependency fails, the entire
build would fail without uploading successfully built packages to remote cache.
This caused unnecessary rebuilds after cache cleanup.

Changes:
- Upload packages to remote cache regardless of overall build outcome
- Add CacheUploadFailed reporter method for visibility
- Cache upload failures are non-fatal warnings
- Build errors still take precedence in return values

This ensures partial build results are cached, reducing rebuild time in
complex dependency graphs.

Co-authored-by: Ona <no-reply@ona.com>

Author: geropl

pkg/leeway/build.go

@@ -537,21 +537,29 @@ func Build(pkg *Package, opts ...BuildOption) (err error) {
 
 	buildErr := pkg.build(ctx)
 
-	// Check for build errors immediately and return if there are any
-	if buildErr != nil {
-		// We deliberately swallow the target package build error as that will have already been reported using the reporter.
-		return xerrors.Errorf("build failed")
+	// Upload successfully built packages to remote cache regardless of build outcome
+	// This ensures partial build results are cached for future builds
+	pkgsToUpload := ctx.GetNewPackagesForCache()
+	if len(pkgsToUpload) > 0 {
+		log.WithField("count", len(pkgsToUpload)).Debug("uploading packages to remote cache")
 	}
 
-	// Only proceed with cache upload if build succeeded
-	pkgsToUpload := ctx.GetNewPackagesForCache()
 	// Convert []*Package to []cache.Package
 	pkgsToUploadCache := make([]cache.Package, len(pkgsToUpload))
 	for i, p := range pkgsToUpload {
 		pkgsToUploadCache[i] = p
 	}
 
 	cacheErr := ctx.RemoteCache.Upload(context.Background(), ctx.LocalCache, pkgsToUploadCache)
+	if cacheErr != nil {
+		ctx.Reporter.CacheUploadFailed(pkgsToUploadCache, cacheErr)
+	}
+
+	// Check for build errors and return after cache upload
+	if buildErr != nil {
+		// We deliberately swallow the target package build error as that will have already been reported using the reporter.
+		return xerrors.Errorf("build failed")
+	}
 	if cacheErr != nil {
 		return cacheErr
 	}

pkg/leeway/reporter.go

@@ -19,6 +19,8 @@ import (
 	"github.com/gookit/color"
 	segment "github.com/segmentio/analytics-go/v3"
 	"github.com/segmentio/textio"
+
+	"github.com/gitpod-io/leeway/pkg/leeway/cache"
 )
 
 // Reporter provides feedback about the build progress to the user.
@@ -46,6 +48,10 @@ type Reporter interface {
 	// PackageBuildFinished is called when the package build has finished. If an error is passed in
 	// the package build was not succesfull.
 	PackageBuildFinished(pkg *Package, rep *PackageBuildReport)
+
+	// CacheUploadFailed is called when uploading build artifacts to remote cache fails.
+	// This is a non-fatal error that doesn't prevent the build from succeeding.
+	CacheUploadFailed(pkgs []cache.Package, err error)
 }
 
 type PackageBuildReport struct {
@@ -247,6 +253,25 @@ func (r *ConsoleReporter) PackageBuildFinished(pkg *Package, rep *PackageBuildRe
 	io.WriteString(out, msg)
 }
 
+// CacheUploadFailed is called when uploading build artifacts to remote cache fails.
+func (r *ConsoleReporter) CacheUploadFailed(pkgs []cache.Package, err error) {
+	if len(pkgs) == 0 {
+		return
+	}
+
+	color.Printf("<yellow>⚠️  cache upload failed</> <gray>(built packages remain in local cache)</>\n")
+	color.Printf("<white>Reason:</> %s\n", err)
+
+	if len(pkgs) <= 5 {
+		color.Printf("<gray>Affected packages:</>\n")
+		for _, pkg := range pkgs {
+			color.Printf("  - %s\n", pkg.FullName())
+		}
+	} else {
+		color.Printf("<gray>%d packages affected</>\n", len(pkgs))
+	}
+}
+
 func getRunPrefix(p *Package) string {
 	return color.Gray.Render(fmt.Sprintf("[%s] ", p.FullName()))
 }
@@ -297,6 +322,11 @@ func (r *WerftReporter) PackageBuildFinished(pkg *Package, rep *PackageBuildRepo
 	fmt.Printf("[%s|%s] %s\n", pkg.FullName(), status, msg)
 }
 
+// CacheUploadFailed is called when uploading build artifacts to remote cache fails.
+func (r *WerftReporter) CacheUploadFailed(pkgs []cache.Package, err error) {
+	log.WithError(err).WithField("packageCount", len(pkgs)).Warn("cache upload failed")
+}
+
 type HTMLPackageReport struct {
 	ID       string
 	logs     strings.Builder
@@ -425,6 +455,11 @@ func (r *HTMLReporter) PackageBuildFinished(pkg *Package, rep *PackageBuildRepor
 	}
 }
 
+// CacheUploadFailed is called when uploading build artifacts to remote cache fails.
+func (r *HTMLReporter) CacheUploadFailed(pkgs []cache.Package, err error) {
+	// HTML reporter doesn't need to track cache upload failures
+}
+
 func (r *HTMLReporter) Report() {
 	vars := make(map[string]interface{})
 	vars["Name"] = r.filename
@@ -535,6 +570,13 @@ func (cr CompositeReporter) PackageBuildStarted(pkg *Package) {
 	}
 }
 
+// CacheUploadFailed implements Reporter
+func (cr CompositeReporter) CacheUploadFailed(pkgs []cache.Package, err error) {
+	for _, r := range cr {
+		r.CacheUploadFailed(pkgs, err)
+	}
+}
+
 var _ Reporter = CompositeReporter{}
 
 type NoopReporter struct{}
@@ -554,6 +596,9 @@ func (*NoopReporter) PackageBuildLog(pkg *Package, isErr bool, buf []byte) {}
 // PackageBuildStarted implements Reporter
 func (*NoopReporter) PackageBuildStarted(pkg *Package) {}
 
+// CacheUploadFailed implements Reporter
+func (*NoopReporter) CacheUploadFailed(pkgs []cache.Package, err error) {}
+
 var _ Reporter = ((*NoopReporter)(nil))
 
 func NewSegmentReporter(key string) *SegmentReporter {
@@ -650,6 +695,11 @@ func (sr *SegmentReporter) track(event string, props segment.Properties) {
 	}
 }
 
+// CacheUploadFailed is called when uploading build artifacts to remote cache fails.
+func (sr *SegmentReporter) CacheUploadFailed(pkgs []cache.Package, err error) {
+	// Could track cache upload failures for analytics in the future
+}
+
 func NewGitHubReporter() *GitHubActionReporter {
 	return &GitHubActionReporter{}
 }
@@ -681,3 +731,8 @@ func (sr *GitHubActionReporter) PackageBuildFinished(pkg *Package, rep *PackageB
 	}
 	fmt.Fprintf(f, "%s=%v\n", pkg.FilesystemSafeName(), success)
 }
+
+// CacheUploadFailed is called when uploading build artifacts to remote cache fails.
+func (sr *GitHubActionReporter) CacheUploadFailed(pkgs []cache.Package, err error) {
+	fmt.Printf("::warning::Cache upload failed: %s (%d packages affected)\n", err, len(pkgs))
+}