bake: handle tilde expansion in filepaths

Signed-off-by: David Karlsson <[email protected]>

Author: dvdksn

bake/bake.go

@@ -21,6 +21,7 @@ import (
 	"github.com/docker/buildx/bake/hclparser"
 	"github.com/docker/buildx/build"
 	"github.com/docker/buildx/util/buildflags"
+	"github.com/docker/buildx/util/pathutil"
 	"github.com/docker/buildx/util/platformutil"
 	"github.com/docker/buildx/util/progress"
 	"github.com/docker/cli/cli/config"
@@ -815,7 +816,76 @@ var (
 	_ hclparser.WithGetName      = &Group{}
 )
 
+// expandPaths expands tilde in all path fields of the target
+func (t *Target) expandPaths() {
+	// Expand context path
+	if t.Context != nil {
+		expanded := pathutil.ExpandTilde(*t.Context)
+		t.Context = &expanded
+	}
+
+	// Expand dockerfile path
+	if t.Dockerfile != nil {
+		expanded := pathutil.ExpandTilde(*t.Dockerfile)
+		t.Dockerfile = &expanded
+	}
+
+	// Expand named contexts
+	if t.Contexts != nil {
+		for k, v := range t.Contexts {
+			t.Contexts[k] = pathutil.ExpandTilde(v)
+		}
+	}
+
+	// Expand secret file paths
+	for _, s := range t.Secrets {
+		if s.FilePath != "" {
+			s.FilePath = pathutil.ExpandTilde(s.FilePath)
+		}
+	}
+
+	// Expand SSH key paths
+	for _, s := range t.SSH {
+		if len(s.Paths) > 0 {
+			s.Paths = pathutil.ExpandTildePaths(s.Paths)
+		}
+	}
+
+	// Expand cache paths if they're local
+	for _, c := range t.CacheFrom {
+		if c.Type == "local" && c.Attrs != nil {
+			if src, ok := c.Attrs["src"]; ok {
+				c.Attrs["src"] = pathutil.ExpandTilde(src)
+			}
+		}
+	}
+	for _, c := range t.CacheTo {
+		if c.Type == "local" && c.Attrs != nil {
+			if dest, ok := c.Attrs["dest"]; ok {
+				c.Attrs["dest"] = pathutil.ExpandTilde(dest)
+			}
+		}
+	}
+
+	// Expand output paths
+	for _, o := range t.Outputs {
+		// Expand the Destination field
+		if o.Destination != "" {
+			o.Destination = pathutil.ExpandTilde(o.Destination)
+		}
+		// Also expand dest in Attrs if present
+		if o.Attrs != nil {
+			if dest, ok := o.Attrs["dest"]; ok {
+				o.Attrs["dest"] = pathutil.ExpandTilde(dest)
+			}
+		}
+	}
+}
+
 func (t *Target) normalize() {
+	// Expand tilde in all path fields
+	t.expandPaths()
+
 	t.Annotations = removeDupesStr(t.Annotations)
 	t.Attest = t.Attest.Normalize()
 	t.Tags = removeDupesStr(t.Tags)

bake/tilde_test.go

@@ -0,0 +1,119 @@
+package bake
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/docker/buildx/util/buildflags"
+	"github.com/stretchr/testify/require"
+)
+
+func TestTargetExpandPaths(t *testing.T) {
+	home, err := os.UserHomeDir()
+	require.NoError(t, err)
+
+	// Create a target with tilde paths
+	contextPath := "~/projects/test"
+	dockerfilePath := "~/dockerfiles/app.Dockerfile"
+
+	target := &Target{
+		Context:    &contextPath,
+		Dockerfile: &dockerfilePath,
+		Contexts: map[string]string{
+			"shared": "~/shared-configs",
+			"libs":   "/absolute/libs",
+		},
+		Secrets: []*buildflags.Secret{
+			{
+				ID:       "npm",
+				FilePath: "~/.npmrc",
+			},
+			{
+				ID:       "aws",
+				FilePath: "~/.aws/credentials",
+			},
+		},
+		SSH: []*buildflags.SSH{
+			{
+				ID:    "default",
+				Paths: []string{"~/.ssh/id_rsa", "~/.ssh/id_ed25519"},
+			},
+		},
+		CacheFrom: []*buildflags.CacheOptionsEntry{
+			{
+				Type: "local",
+				Attrs: map[string]string{
+					"src": "~/.docker/cache",
+				},
+			},
+		},
+		CacheTo: []*buildflags.CacheOptionsEntry{
+			{
+				Type: "local",
+				Attrs: map[string]string{
+					"dest": "~/.docker/cache",
+				},
+			},
+		},
+		Outputs: []*buildflags.ExportEntry{
+			{
+				Type:        "local",
+				Destination: "~/builds/output",
+			},
+		},
+	}
+
+	// Apply normalization which includes tilde expansion
+	target.normalize()
+
+	// Verify expansions
+	require.Equal(t, filepath.Join(home, "projects/test"), *target.Context)
+	require.Equal(t, filepath.Join(home, "dockerfiles/app.Dockerfile"), *target.Dockerfile)
+
+	// Check named contexts
+	require.Equal(t, filepath.Join(home, "shared-configs"), target.Contexts["shared"])
+	require.Equal(t, "/absolute/libs", target.Contexts["libs"]) // Should remain unchanged
+
+	// Check secrets
+	require.Equal(t, filepath.Join(home, ".npmrc"), target.Secrets[0].FilePath)
+	require.Equal(t, filepath.Join(home, ".aws/credentials"), target.Secrets[1].FilePath)
+
+	// Check SSH paths
+	require.Equal(t, filepath.Join(home, ".ssh/id_rsa"), target.SSH[0].Paths[0])
+	require.Equal(t, filepath.Join(home, ".ssh/id_ed25519"), target.SSH[0].Paths[1])
+
+	// Check cache paths
+	require.Equal(t, filepath.Join(home, ".docker/cache"), target.CacheFrom[0].Attrs["src"])
+	require.Equal(t, filepath.Join(home, ".docker/cache"), target.CacheTo[0].Attrs["dest"])
+
+	// Check output paths (stored in Destination field, not Attrs)
+	require.Equal(t, filepath.Join(home, "builds/output"), target.Outputs[0].Destination)
+}
+
+func TestTargetExpandPathsSpecialCases(t *testing.T) {
+	// Test that special prefixes and URLs are not expanded
+	gitURL := "[email protected]:user/repo.git"
+	dockerImage := "docker-image://myimage:latest"
+	cwdPath := "cwd://relative/path"
+
+	target := &Target{
+		Context:    &gitURL,
+		Dockerfile: &dockerImage,
+		Contexts: map[string]string{
+			"remote": "https://example.com/context.tar.gz",
+			"cwd":    cwdPath,
+			"target": "target:other-target",
+		},
+	}
+
+	// Apply normalization
+	target.normalize()
+
+	// Verify no expansion for special cases
+	require.Equal(t, gitURL, *target.Context)
+	require.Equal(t, dockerImage, *target.Dockerfile)
+	require.Equal(t, "https://example.com/context.tar.gz", target.Contexts["remote"])
+	require.Equal(t, cwdPath, target.Contexts["cwd"])
+	require.Equal(t, "target:other-target", target.Contexts["target"])
+}

util/pathutil/resolve.go

@@ -0,0 +1,65 @@
+package pathutil
+
+import (
+	"os"
+	"os/user"
+	"path/filepath"
+	"strings"
+)
+
+// ExpandTilde expands tilde in paths (~/ or ~username/)
+// Returns original path if expansion fails or path doesn't start with ~
+func ExpandTilde(path string) string {
+	if !strings.HasPrefix(path, "~") {
+		return path
+	}
+
+	// Handle ~/path or just ~
+	if path == "~" || strings.HasPrefix(path, "~/") {
+		home, err := os.UserHomeDir()
+		if err != nil {
+			return path
+		}
+		if path == "~" {
+			return home
+		}
+		return filepath.Join(home, path[2:])
+	}
+
+	// Handle ~username/path
+	var username string
+	var rest string
+
+	if idx := strings.Index(path, "/"); idx > 1 {
+		username = path[1:idx]
+		rest = path[idx+1:]
+	} else {
+		username = path[1:]
+	}
+
+	u, err := user.Lookup(username)
+	if err != nil {
+		// If the user doesn't exist, return the unresolved path.
+		// Matches shell behavior:
+		// $ echo ~nonexistentuser/path
+		// ~nonexistentuser/path
+		return path
+	}
+
+	if rest == "" {
+		return u.HomeDir
+	}
+	return filepath.Join(u.HomeDir, rest)
+}
+
+// ExpandTildePaths expands tilde in a slice of paths
+func ExpandTildePaths(paths []string) []string {
+	if paths == nil {
+		return nil
+	}
+	expanded := make([]string, len(paths))
+	for i, p := range paths {
+		expanded[i] = ExpandTilde(p)
+	}
+	return expanded
+}