[cloud] emulate user's local directory structure in VM (#440)

## Summary

**Problem**
A scenario we want to protect against is two distinct projects sharing
the same directory name. For example, consider projects located at
`~/customer1/my_project` and `~/customer2/my_project`. Prior to this PR,
we would attempt to sync both projects to the same folder in the VM:
`~/code/my_project`.

**Approach**
This PR attempts to solve this conflict by seeking to emulate the user's
directory structure in the VM. So, for the aforementioned example
projects, they will sync to `~/customer1/my_project` and
`~/customer2/my_project` in the VM as well. This has the additional
benefit that if a user has relative paths between two projects they are
actively developing (for example, a golang library and golang
application that uses that library), then these relative paths will
continue working in the cloud-shell, in accordance with our desires to
make the cloud-shell experience akin to local shells.

**Edge case: projects outside homedir**
An edge case is for projects that are located locally outside the user's
homedir. For security reasons, in the VM, we do not want to give the
user root access, or access to folders outside their homedir. We choose
to sync to a special folder called: `~/outside-homedir-code/<absolute
path>`. For example, a project located locally at
`/my_company/my_project` will sync to
`~/outside-homedir-code/my_company/my_project`. There are two downsides
to this which are tolerable IMO:
1. If a user _also has_ a local folder called `~/devbox-cloud` and they
want to sync those projects then there will be a conflict.
2. Relative paths between a project in homedir and outside the homedir
will not work. The user can inspect the paths in the cloud-shells via
`pwd` and update the relative paths to match that.



## How was it tested?

for `testdata/go/go-1.19`: could sync to VM via `devbox cloud shell`,
and inspect directory in VM with `pwd`.


for edge case: projects outside homedir:
1. copied `examples/testdata/rust/rust-stable` to
`/usr/local/testy-nonhome-dir/rust-stable`
2. fixed permissions: `sudo chown savil:staff
/usr/local/testy-nonhome-dir/rust-stable`
3. `devbox cloud shell` to VM
4. `pwd` in VM gave:
`/home/savil/outside-homedir-code/usr/local/testy-nonhome-dir/rust-stable`
5. `devbox add gcc` and then `cargo run` ran successfully.

Author: savil

internal/cloud/cloud.go

@@ -163,10 +163,14 @@ func getVirtualMachine(client openssh.Client) (vmHost string, region string) {
 
 func syncFiles(username, hostname, projectDir string) error {
 
-	projectName := projectDirName(projectDir)
-	debug.Log("Will sync files to directory: ~/code/%s", projectName)
+	relProjectPathInVM, err := relativeProjectPathInVM(projectDir)
+	if err != nil {
+		return err
+	}
+	absPathInVM := absoluteProjectPathInVM(username, relProjectPathInVM)
+	debug.Log("absPathInVM: %s", absPathInVM)
 
-	err := copyConfigFileToVM(hostname, username, projectDir, projectName)
+	err = copyConfigFileToVM(hostname, username, projectDir, absPathInVM)
 	if err != nil {
 		return err
 	}
@@ -184,7 +188,9 @@ func syncFiles(username, hostname, projectDir string) error {
 	// TODO: instead of id, have the server return the machine's name and use that
 	// here to. It'll make things easier to debug.
 	machineID, _, _ := strings.Cut(hostname, ".")
-	mutagenSessionName := mutagen.SanitizeSessionName(fmt.Sprintf("devbox-%s-%s", projectName, machineID))
+	mutagenSessionName := mutagen.SanitizeSessionName(fmt.Sprintf("devbox-%s-%s", machineID,
+		hyphenatePath(relProjectPathInVM)))
+
 	_, err = mutagen.Sync(&mutagen.SessionSpec{
 		// If multiple projects can sync to the same machine, we need the name to also include
 		// the project's id.
@@ -195,7 +201,7 @@ func syncFiles(username, hostname, projectDir string) error {
 		// the projects files. If we pick a pre-existing directories with other files, those
 		// files will be synced back to the local directory (due to two-way-sync) and pollute
 		// the user's local project
-		BetaPath: projectPathInVM(projectName),
+		BetaPath: absPathInVM,
 		EnvVars:  env,
 		Ignore: mutagen.SessionIgnore{
 			VCS:   true,
@@ -210,20 +216,21 @@ func syncFiles(username, hostname, projectDir string) error {
 	time.Sleep(1 * time.Second)
 
 	// In a background routine, update the sync status in the cloud VM
-	go updateSyncStatus(mutagenSessionName, username, hostname, projectName)
+	go updateSyncStatus(mutagenSessionName, username, hostname, relProjectPathInVM)
 	return nil
 }
 
 // updateSyncStatus updates the starship prompt.
 //
 // wait for the mutagen session's status to change to "watching", and update the remote VM
 // when the initial project sync completes and then exit.
-func updateSyncStatus(mutagenSessionName, username, hostname, projectName string) {
+func updateSyncStatus(mutagenSessionName, username, hostname, relProjectPathInVM string) {
+
 	status := "disconnected"
 
 	// Ensure the destination directory exists
 	destServer := fmt.Sprintf("%s@%s", username, hostname)
-	destDir := fmt.Sprintf("/home/%s/.config/devbox/starship/%s", username, projectName)
+	destDir := fmt.Sprintf("/home/%s/.config/devbox/starship/%s", username, hyphenatePath(filepath.Base(relProjectPathInVM)))
 	remoteCmd := fmt.Sprintf("mkdir -p %s", destDir)
 	cmd := exec.Command("ssh", destServer, remoteCmd)
 	err := cmd.Run()
@@ -274,11 +281,11 @@ func getSyncStatus(mutagenSessionName string) (string, error) {
 	return sessions[0].Status, nil
 }
 
-func copyConfigFileToVM(hostname, username, projectDir, projectName string) error {
+func copyConfigFileToVM(hostname, username, projectDir, pathInVM string) error {
 
 	// Ensure the devbox-project's directory exists in the VM
 	destServer := fmt.Sprintf("%s@%s", username, hostname)
-	cmd := exec.Command("ssh", destServer, "--", "mkdir", "-p", projectPathInVM(projectName))
+	cmd := exec.Command("ssh", destServer, "--", "mkdir", "-p", pathInVM)
 	err := cmd.Run()
 	debug.Log("ssh mkdir command: %s with error: %s", cmd, err)
 	if err != nil {
@@ -287,36 +294,68 @@ func copyConfigFileToVM(hostname, username, projectDir, projectName string) erro
 
 	// Copy the config file to the devbox-project directory in the VM
 	configFilePath := filepath.Join(projectDir, "devbox.json")
-	destPath := fmt.Sprintf("%s:%s", destServer, projectPathInVM(projectName))
+	destPath := fmt.Sprintf("%s:%s", destServer, pathInVM)
 	cmd = exec.Command("scp", configFilePath, destPath)
 	err = cmd.Run()
 	debug.Log("scp devbox.json command: %s with error: %s", cmd, err)
 	return errors.WithStack(err)
 }
 
-func projectPathInVM(projectName string) string {
-	return fmt.Sprintf("~/code/%s/", projectName)
-}
-
 func shell(username, hostname, projectDir string) error {
+	projectPath, err := relativeProjectPathInVM(projectDir)
+	if err != nil {
+		return err
+	}
+
 	client := &openssh.Client{
-		Username:       username,
-		Addr:           hostname,
-		ProjectDirName: projectDirName(projectDir),
+		Username: username,
+		Addr:     hostname,
+		PathInVM: absoluteProjectPathInVM(username, projectPath),
 	}
 	return client.Shell()
 }
 
-const defaultProjectDirName = "devbox_project"
-
+// relativeProjectPathInVM refers to the project path relative to the user's
+// home-directory within the VM.
+//
 // Ideally, we'd pass in devbox.Devbox struct and call ProjectDir but it
 // makes it hard to wrap this in a test
-func projectDirName(projectDir string) string {
-	name := filepath.Base(projectDir)
-	if name == "/" || name == "." {
-		return defaultProjectDirName
+func relativeProjectPathInVM(projectDir string) (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", errors.WithStack(err)
+	}
+
+	// get absProjectDir to expand "." and so on
+	absProjectDir, err := filepath.Abs(projectDir)
+	if err != nil {
+		return "", errors.WithStack(err)
 	}
-	return name
+	projectDir = filepath.Clean(absProjectDir)
+
+	if !strings.HasPrefix(projectDir, home) {
+		projectDir, err = filepath.Abs(projectDir)
+		if err != nil {
+			return "", errors.WithStack(err)
+		}
+		return filepath.Join(outsideHomedirDirectory, projectDir), nil
+	}
+
+	relativeProjectDir, err := filepath.Rel(home, projectDir)
+	if err != nil {
+		return "", errors.WithStack(err)
+	}
+	return relativeProjectDir, nil
+}
+
+const outsideHomedirDirectory = "outside-homedir-code"
+
+func absoluteProjectPathInVM(sshUser, relativeProjectPath string) string {
+	vmHomeDir := fmt.Sprintf("/home/%s", sshUser)
+	if strings.HasPrefix(relativeProjectPath, outsideHomedirDirectory) {
+		return fmt.Sprintf("%s/%s", vmHomeDir, relativeProjectPath)
+	}
+	return fmt.Sprintf("%s/%s/", vmHomeDir, relativeProjectPath)
 }
 
 func parseVMEnvVar() (username string, vmHostname string) {
@@ -385,3 +424,7 @@ func vmHostnameFromSSHControlPath() string {
 	// empty string means that aren't any active VM connections
 	return ""
 }
+
+func hyphenatePath(path string) string {
+	return strings.ReplaceAll(path, "/", "-")
+}

internal/cloud/cloud_test.go

@@ -1,29 +1,48 @@
 package cloud
 
 import (
+	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
 func TestProjectDirName(t *testing.T) {
+	assertion := assert.New(t)
+
+	homeDir, err := os.UserHomeDir()
+	assertion.NoError(err)
+
+	workingDir, err := os.Getwd()
+	assertion.NoError(err)
+
+	relWorkingDir, err := filepath.Rel(homeDir, workingDir)
+	assertion.NoError(err)
 
 	testCases := []struct {
 		projectDir string
-		dirName    string
+		dirPath    string
 	}{
-		{"/", defaultProjectDirName},
-		{".", defaultProjectDirName},
-		{"/foo", "foo"},
-		{"foo/bar", "bar"},
-		{"foo/bar/", "bar"},
-		{"foo/bar///", "bar"},
+		// inside homedir
+		{".", relWorkingDir},
+		{filepath.Join(homeDir, "foo"), "foo"},
+		{filepath.Join(homeDir, "foo/bar"), "foo/bar"},
+
+		// non-home-dir
+		{"/", filepath.Join(outsideHomedirDirectory, "/")},
+		{"/foo", filepath.Join(outsideHomedirDirectory, "/foo")},
+		{"/foo/bar", filepath.Join(outsideHomedirDirectory, "/foo/bar")},
+		{"/foo/bar/", filepath.Join(outsideHomedirDirectory, "/foo/bar")},
+		{"/foo/bar///", filepath.Join(outsideHomedirDirectory, "/foo/bar")},
 	}
 
 	for _, testCase := range testCases {
 		t.Run(testCase.projectDir, func(t *testing.T) {
 			assert := assert.New(t)
-			assert.Equal(testCase.dirName, projectDirName(testCase.projectDir))
+			path, err := relativeProjectPathInVM(testCase.projectDir)
+			assert.NoError(err)
+			assert.Equal(testCase.dirPath, path)
 		})
 	}
 }

internal/cloud/openssh/client.go

@@ -17,14 +17,14 @@ import (
 )
 
 type Client struct {
-	Username       string
-	Addr           string
-	ProjectDirName string
+	Username string
+	Addr     string
+	PathInVM string
 }
 
 func (c *Client) Shell() error {
 	cmd := c.cmd("-t")
-	remoteCmd := fmt.Sprintf(`bash -l -c "start_devbox_shell.sh \"%s\""`, c.ProjectDirName)
+	remoteCmd := fmt.Sprintf(`bash -l -c "start_devbox_shell.sh \"%s\""`, c.PathInVM)
 	cmd.Args = append(cmd.Args, remoteCmd)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout