fix(devcontainer): preserve remote user ownership

cmd/snapshot/create.go

@@ -120,6 +120,7 @@ func (cmd *CreateCmd) Run(ctx context.Context, devsyConfig *config.Config, args
 		MountPrefix:             vols.MountPrefix,
 		RunArgs:                 vols.RunArgs,
 		ContainerEnv:            vols.ContainerEnv,
+		RemoteUser:              vols.RemoteUser,
 		ContainerImageMediaType: img.MediaType,
 		ContainerImageDigest:    img.Digest,
 		ContainerImageSize:      img.Size,
@@ -301,6 +302,7 @@ type pushedVolumes struct {
 	MountPrefix  string
 	RunArgs      []string
 	ContainerEnv map[string]string
+	RemoteUser   string
 }
 
 // The volumes RPC (StreamSnapshotVolumes) is served by a tunnelServer reading
@@ -341,6 +343,7 @@ func (cmd *CreateCmd) pushVolumes(
 		MountPrefix:  mountPrefix,
 		RunArgs:      result.MergedConfig.RunArgs,
 		ContainerEnv: redactedContainerEnv(result.MergedConfig.ContainerEnv),
+		RemoteUser:   result.MergedConfig.RemoteUser,
 	}, nil
 }
 

cmd/snapshot/restore.go

@@ -94,6 +94,7 @@ func (cmd *RestoreCmd) Run(
 	if err != nil {
 		return fmt.Errorf("read snapshot container env: %w", err)
 	}
+	remoteUser := manifest.RemoteUser()
 
 	log.Infof("restoring snapshot: ref=%s workspaceId=%s", snapshotRef, ws.ID)
 
@@ -105,6 +106,7 @@ func (cmd *RestoreCmd) Run(
 		DevContainerSource: ws.DevContainerSource,
 		RunArgs:            runArgs,
 		ContainerEnv:       containerEnv,
+		RemoteUser:         remoteUser,
 	})
 }
 

cmd/workspace/up/up.go

@@ -86,6 +86,9 @@ type Options struct {
 	// the same suppressed-discovery circumstances as RunArgs. Used by
 	// snapshot restore to replay the original devcontainer.json's containerEnv.
 	ContainerEnv map[string]string
+	// RemoteUser is the remoteUser to replay under the same
+	// suppressed-discovery circumstances as RunArgs. Used by snapshot restore.
+	RemoteUser string
 }
 
 type HeadlessOptions struct {
@@ -202,6 +205,7 @@ func buildUpCmd(g *flags.GlobalFlags, opts Options) *UpCmd {
 	cmd.DevContainerSource = opts.DevContainerSource
 	cmd.RunArgs = opts.RunArgs
 	cmd.ContainerEnv = opts.ContainerEnv
+	cmd.RemoteUser = opts.RemoteUser
 	if opts.Name != "" {
 		cmd.ID = opts.Name
 	}

cmd/workspace/up/up_client.go

@@ -557,8 +557,9 @@ func (cmd *UpCmd) validateFromSnapshot(ctx context.Context, args []string) error
 }
 
 // applyFromSnapshotOverrides replays the create-time devcontainer.json
-// settings the snapshot's manifest carries (runArgs, containerEnv) onto cmd,
-// so the image-sourced restored container behaves like the original did.
+// settings the snapshot's manifest carries (runArgs, containerEnv,
+// remoteUser) onto cmd, so the image-sourced restored container behaves like
+// the original did.
 func (cmd *UpCmd) applyFromSnapshotOverrides(manifest *snapshotpkg.Manifest) error {
 	runArgs, err := manifest.RunArgs()
 	if err != nil {
@@ -571,6 +572,8 @@ func (cmd *UpCmd) applyFromSnapshotOverrides(manifest *snapshotpkg.Manifest) err
 		return fmt.Errorf("read --from-snapshot container env: %w", err)
 	}
 	cmd.ContainerEnv = containerEnv
+
+	cmd.RemoteUser = manifest.RemoteUser()
 	return nil
 }
 

e2e/tests/snapshot/snapshot.go

@@ -21,6 +21,7 @@ const (
 	snapshotCmd         = "snapshot"
 	snapshotVerbCreate  = "create"
 	snapshotVerbRestore = "restore"
+	nonRootRemoteUser   = "devsyuser"
 )
 
 var _ = ginkgo.Describe("devsy snapshot", ginkgo.Label("snapshot"), func() {
@@ -430,11 +431,6 @@ var _ = ginkgo.Describe("devsy snapshot", ginkgo.Label("snapshot"), func() {
 		restoredWorkspace, err := f.FindWorkspace(ctx, restoredID)
 		framework.ExpectNoError(err)
 
-		// The custom --label runArg only exists in this fixture's
-		// devcontainer.json, not in the base image or --add-host (which the
-		// registry fixture itself already depends on to function at all): its
-		// presence on the restored container proves restore replays the
-		// original runArgs generally, not just the one the test harness needs.
 		containerIDs, err := dockerHelper.FindContainer(ctx, []string{
 			fmt.Sprintf("%s=%s", pkgconfig.DevcontainerIDLabel, restoredWorkspace.UID),
 			"devsy-e2e-snapshot-runargs=true",
@@ -445,4 +441,60 @@ var _ = ginkgo.Describe("devsy snapshot", ginkgo.Label("snapshot"), func() {
 			"restored container should carry the original devcontainer.json's custom runArg label",
 		)
 	}, ginkgo.SpecTimeout(framework.TimeoutLong()))
+
+	ginkgo.It("restores files owned by the remote user when reusing the original id", func(
+		ctx context.Context,
+	) {
+		initialDir, err := os.Getwd()
+		framework.ExpectNoError(err)
+
+		tempDir, err := framework.CopyToTempDir("tests/snapshot/testdata/docker-nonroot")
+		framework.ExpectNoError(err)
+		ginkgo.DeferCleanup(framework.CleanupTempDir, initialDir, tempDir)
+		ginkgo.DeferCleanup(f.DevsyWorkspaceDelete, tempDir)
+		framework.ExpectNoError(f.DevsyUp(ctx, tempDir))
+
+		workspaceFolder, err := f.DevsySSH(ctx, tempDir, "pwd")
+		framework.ExpectNoError(err)
+		workspaceFolder = strings.TrimSpace(workspaceFolder)
+
+		markerCmd := fmt.Sprintf("echo mutated > %s/marker.txt", workspaceFolder)
+		_, err = f.DevsySSH(ctx, tempDir, markerCmd)
+		framework.ExpectNoError(err)
+
+		out, _, err := f.ExecCommandCapture(ctx, []string{
+			snapshotCmd, snapshotVerbCreate, tempDir, registryFlag, registryHost + "/e2e/snapshots",
+			debugFlag,
+		})
+		framework.ExpectNoError(err)
+		snapshotRef := strings.TrimSpace(out)
+
+		framework.ExpectNoError(f.DevsyWorkspaceDelete(ctx, tempDir))
+
+		_, _, err = f.ExecCommandCapture(ctx, []string{
+			snapshotCmd, snapshotVerbRestore, snapshotRef, debugFlag,
+		})
+		framework.ExpectNoError(err)
+
+		restoredWorkspaceFolder, err := f.DevsySSH(ctx, tempDir, "pwd")
+		framework.ExpectNoError(err)
+		restoredWorkspaceFolder = strings.TrimSpace(restoredWorkspaceFolder)
+
+		content, err := f.DevsySSH(
+			ctx, tempDir, fmt.Sprintf("cat %s/marker.txt", restoredWorkspaceFolder),
+		)
+		framework.ExpectNoError(err)
+		gomega.Expect(content).To(gomega.ContainSubstring("mutated"))
+
+		// Compare the recorded owner name against the devcontainer.json's
+		// remoteUser rather than the SSH session's uid: the ssh session may
+		// resolve to root when no ssh-config entry was written
+		ownerCmd := fmt.Sprintf(
+			`test "$(stat -c %%U %s/marker.txt)" = %q && echo OWNER_OK || echo OWNER_MISMATCH`,
+			restoredWorkspaceFolder, nonRootRemoteUser,
+		)
+		ownerOut, err := f.DevsySSH(ctx, tempDir, ownerCmd)
+		framework.ExpectNoError(err)
+		gomega.Expect(ownerOut).To(gomega.ContainSubstring("OWNER_OK"))
+	}, ginkgo.SpecTimeout(framework.TimeoutLong()))
 })

e2e/tests/snapshot/testdata/docker-nonroot/.devcontainer.json

@@ -0,0 +1,11 @@
+{
+  "name": "snapshot non-root",
+  "build": {
+    "dockerfile": "Dockerfile"
+  },
+  "remoteUser": "devsyuser",
+  "runArgs": ["--add-host=host.docker.internal:host-gateway"],
+  "containerEnv": {
+    "DEVSY_INSECURE_DOCKER_INTERNAL": "true"
+  }
+}

e2e/tests/snapshot/testdata/docker-nonroot/Dockerfile

@@ -0,0 +1,3 @@
+FROM ghcr.io/devsy-org/test-images/base:ubuntu
+
+RUN useradd --create-home --shell /bin/bash devsyuser

pkg/agent/snapshot/restore.go

@@ -70,7 +70,10 @@ func RestoreVolumes(
 	}
 
 	levels := len(strings.Split(layer.MountPrefix, "/"))
-	if err := extract.Extract(rc, target, extract.StripLevels(levels)); err != nil {
+	if err := extract.Extract(
+		rc, target,
+		extract.StripLevels(levels), extract.PreserveHeaderOwnership(),
+	); err != nil {
 		return fmt.Errorf("extract snapshot volumes into %s: %w", target, err)
 	}
 	return nil

pkg/copy/copy.go

@@ -1,7 +1,6 @@
 package copy
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	"io/fs"
@@ -28,6 +27,45 @@ func Chown(path string, userName string) error {
 	return os.Lchown(path, uidInt, gidInt)
 }
 
+// ChownFailure is one entry a recursive chown could not reassign.
+type ChownFailure struct {
+	Path string
+	Err  error
+}
+
+func (f ChownFailure) Error() string { return fmt.Sprintf("%s: %v", f.Path, f.Err) }
+
+func (f ChownFailure) Unwrap() error { return f.Err }
+
+// ChownFailures aggregates the entries ChownR could not chown. Callers
+// distinguish wholesale breakage from entries a shared filesystem refuses to
+// reassign via AllDenied.
+type ChownFailures []ChownFailure
+
+func (fs ChownFailures) Error() string {
+	return fmt.Sprintf("%d entries could not be chowned, first: %v", len(fs), fs[0])
+}
+
+func (fs ChownFailures) Unwrap() []error {
+	errs := make([]error, len(fs))
+	for i, f := range fs {
+		errs[i] = f
+	}
+	return errs
+}
+
+// AllDenied reports whether every failure was refused by the filesystem
+// (permission denied or read-only share) — the expected case for entries on
+// virtiofs shares such as read-only .git pack files.
+func (fs ChownFailures) AllDenied() bool {
+	for _, f := range fs {
+		if !deniedByFilesystem(f.Err) {
+			return false
+		}
+	}
+	return len(fs) > 0
+}
+
 func ChownR(path string, userName string) error {
 	if userName == "" {
 		return nil
@@ -44,28 +82,30 @@ func ChownR(path string, userName string) error {
 	// #nosec G115 -- a resolved system uid is non-negative and fits uint32.
 	uidU32 := uint32(uidInt)
 
-	// A single un-chownable entry (e.g. a read-only file on a virtiofs share)
-	// must not abort the walk and leave the rest of the tree unowned.
-	var errs []error
+	var failures ChownFailures
 	_ = filepath.WalkDir(path, func(name string, dirEntry fs.DirEntry, err error) error {
 		if err != nil {
-			errs = append(errs, err)
+			failures = append(failures, ChownFailure{Path: name, Err: err})
 			return nil
 		}
 		info, err := dirEntry.Info()
 		if err != nil {
+			failures = append(failures, ChownFailure{Path: name, Err: err})
 			return nil
 		}
 		if IsUID(info, uidU32) {
 			return nil
 		}
 		// #nosec G122 -- best-effort chown of a freshly provisioned tree we own; WalkDir yields real paths.
-		if err := os.Lchown(name, uidInt, gidInt); err != nil {
-			errs = append(errs, err)
+		if lerr := os.Lchown(name, uidInt, gidInt); lerr != nil {
+			failures = append(failures, ChownFailure{Path: name, Err: lerr})
 		}
 		return nil
 	})
-	return errors.Join(errs...)
+	if len(failures) == 0 {
+		return nil
+	}
+	return failures
 }
 
 func MkdirAllChown(path string, perm os.FileMode, userName string) error {

pkg/copy/copy_supported.go

@@ -3,6 +3,7 @@
 package copy
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"syscall"
@@ -13,6 +14,12 @@ func IsUID(info os.FileInfo, uid uint32) bool {
 	return ok && stat.Uid == uid
 }
 
+// deniedByFilesystem reports whether err means the filesystem refused the
+// reassignment (insufficient privilege or a read-only share).
+func deniedByFilesystem(err error) bool {
+	return errors.Is(err, os.ErrPermission) || errors.Is(err, syscall.EROFS)
+}
+
 func Lchown(info os.FileInfo, sourcePath, destPath string) error {
 	stat, ok := info.Sys().(*syscall.Stat_t)
 	if !ok {

pkg/copy/copy_test.go

@@ -3,6 +3,7 @@
 package copy
 
 import (
+	"errors"
 	"os"
 	"os/user"
 	"path/filepath"
@@ -231,3 +232,42 @@ func mustReadFile(t *testing.T, path string) []byte {
 	}
 	return b
 }
+
+// Chowning a file to a different owner requires privileges, so pointing
+// ChownR at root as an unprivileged user exercises the denied-failure path
+// deterministically.
+func TestChownRDeniedFailuresAreTyped(t *testing.T) {
+	root := t.TempDir()
+	file := filepath.Join(root, "f.txt")
+	//nolint:gosec // G306 — test temp file
+	if err := os.WriteFile(file, []byte("x"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	err := ChownR(root, "root")
+	var failures ChownFailures
+	if !errors.As(err, &failures) {
+		t.Fatalf("ChownR err = %v, want ChownFailures", err)
+	}
+	if !failures.AllDenied() {
+		t.Errorf("AllDenied() = false for %v", failures)
+	}
+	for _, f := range failures {
+		if !deniedByFilesystem(f.Err) {
+			t.Errorf("%s: unexpected cause %v", f.Path, f.Err)
+		}
+	}
+}
+
+func TestChownRSameOwnerSucceeds(t *testing.T) {
+	root := t.TempDir()
+	file := filepath.Join(root, "f.txt")
+	//nolint:gosec // G306 — test temp file
+	if err := os.WriteFile(file, []byte("x"), 0o600); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+
+	if err := ChownR(root, currentUserName(t)); err != nil {
+		t.Fatalf("ChownR same owner: %v", err)
+	}
+}

pkg/copy/copy_unsupported.go

@@ -3,13 +3,23 @@
 package copy
 
 import (
+	"errors"
 	"os"
+	"syscall"
 )
 
 func IsUID(info os.FileInfo, uid uint32) bool {
 	return true
 }
 
+// deniedByFilesystem reports whether the platform refused the reassignment.
+// IsUID short-circuits ChownR on Windows so this is rarely consulted, but a
+// direct os.Lchown fails with EWINDOWS: that is "unsupported here", a
+// tolerated denial, not a hard failure.
+func deniedByFilesystem(err error) bool {
+	return errors.Is(err, syscall.EWINDOWS)
+}
+
 func Lchown(info os.FileInfo, sourcePath, destPath string) error {
 	return nil
 }

pkg/devcontainer/config.go

@@ -186,6 +186,9 @@ func (r *runner) rawConfigFromSource(
 		log.Infof("ignoring project devcontainer, using image %s", spec.Image)
 		return r.saveSynthesizedConfig(&config.DevContainerConfig{
 			ImageContainer: config.ImageContainer{Image: spec.Image},
+			DevContainerConfigBase: config.DevContainerConfigBase{
+				RemoteUser: options.RemoteUser,
+			},
 			NonComposeBase: config.NonComposeBase{
 				RunArgs:      options.RunArgs,
 				ContainerEnv: options.ContainerEnv,