vercel · kodiakhq · Apr 12, 2022 · Mar 21, 2022 · Mar 27, 2022 · Apr 5, 2022
@@ -53,7 +53,7 @@ type Config struct {
 	// package.json at the root of the repo
 	RootPackageJSON *fs.PackageJSON
 	// Current Working Directory
-	Cwd string
+	Cwd fs.AbsolutePath
 }
 
 // IsLoggedIn returns true if we have a token and either a team id or team slug
@@ -99,8 +99,8 @@ func ParseAndValidate(args []string, ui cli.Ui, turboVersion string) (c *Config,
 		return nil, err
 	}
 	// Precedence is flags > env > config > default
-	packageJSONPath := filepath.Join(cwd, "package.json")
-	rootPackageJSON, err := fs.ReadPackageJSON(packageJSONPath)
+	packageJSONPath := cwd.Join("package.json")
+	rootPackageJSON, err := fs.ReadPackageJSON(packageJSONPath.ToStringDuringMigration())
 	if err != nil {
 		return nil, fmt.Errorf("package.json: %w", err)
 	}
@@ -214,14 +214,14 @@ func ParseAndValidate(args []string, ui cli.Ui, turboVersion string) (c *Config,
 	return c, nil
 }
 
-func ReadTurboConfig(rootPath string, rootPackageJSON *fs.PackageJSON) (*fs.TurboConfigJSON, error) {
+func ReadTurboConfig(rootPath fs.AbsolutePath, rootPackageJSON *fs.PackageJSON) (*fs.TurboConfigJSON, error) {
 	// If turbo.json exists, we use that
 	// If pkg.Turbo exists, we warn about running the migration
 	// Use pkg.Turbo if turbo.json doesn't exist
 	// If neither exists, it's a fatal error
-	turboJSONPath := filepath.Join(rootPath, "turbo.json")
+	turboJSONPath := rootPath.Join("turbo.json")
 
-	if !fs.FileExists(turboJSONPath) {
+	if !turboJSONPath.FileExists() {
 		if rootPackageJSON.LegacyTurboConfig == nil {
 			// TODO: suggestion on how to create one
 			return nil, fmt.Errorf("Could not find turbo.json. Follow directions at https://turborepo.org/docs/getting-started to create one")
@@ -244,17 +244,23 @@ func ReadTurboConfig(rootPath string, rootPackageJSON *fs.PackageJSON) (*fs.Turb
 
 // Selects the current working directory from OS
 // and overrides with the `--cwd=` input argument
-func selectCwd(inputArgs []string) (string, error) {
-	cwd, err := os.Getwd()
+func selectCwd(inputArgs []string) (fs.AbsolutePath, error) {
+	cwd, err := fs.GetCwd()
 	if err != nil {
-		return "", fmt.Errorf("invalid working directory: %w", err)
+		return "", err
 	}
 	for _, arg := range inputArgs {
 		if arg == "--" {
 			break
 		} else if strings.HasPrefix(arg, "--cwd=") {
 			if len(arg[len("--cwd="):]) > 0 {
-				cwd = arg[len("--cwd="):]
+				cwdArgRaw := arg[len("--cwd="):]
+				cwdArg, err := fs.CheckedToAbsolutePath(cwdArgRaw)
+				if err != nil {
+					// the argument is a relative path. Join it with our actual cwd
+					return cwd.Join(cwdArgRaw), nil
+				}
+				return cwdArg, nil
 			}
 		}
 	}

@@ -2,22 +2,22 @@ package config
 
 import (
 	"fmt"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/vercel/turborepo/cli/internal/fs"
 )
 
 func TestSelectCwd(t *testing.T) {
-	defaultCwd, err := os.Getwd()
+	defaultCwd, err := fs.GetCwd()
 	if err != nil {
 		t.Errorf("failed to get cwd: %v", err)
 	}
 
 	cases := []struct {
 		Name      string
 		InputArgs []string
-		Expected  string
+		Expected  fs.AbsolutePath
 	}{
 		{
 			Name:      "default",
@@ -27,12 +27,12 @@ func TestSelectCwd(t *testing.T) {
 		{
 			Name:      "choose command-line flag cwd",
 			InputArgs: []string{"foo", "--cwd=zop"},
-			Expected:  "zop",
+			Expected:  defaultCwd.Join("zop"),
 		},
 		{
 			Name:      "ignore other flags not cwd",
 			InputArgs: []string{"foo", "--ignore-this-1", "--cwd=zop", "--ignore-this=2"},
-			Expected:  "zop",
+			Expected:  defaultCwd.Join("zop"),
 		},
 		{
 			Name:      "ignore args after pass through",

@@ -3,7 +3,6 @@ package fs
 import (
 	"encoding/json"
 	"io/ioutil"
-	"os"
 	"strings"
 	"sync"
 
@@ -24,8 +23,8 @@ type TurboConfigJSON struct {
 	RemoteCacheOptions RemoteCacheOptions `json:"remoteCache,omitempty"`
 }
 
-func ReadTurboConfigJSON(path string) (*TurboConfigJSON, error) {
-	file, err := os.Open(path)
+func ReadTurboConfigJSON(path AbsolutePath) (*TurboConfigJSON, error) {
+	file, err := path.Open()
 	if err != nil {
 		return nil, err
 	}

@@ -2,7 +2,6 @@ package fs
 
 import (
 	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 
@@ -14,7 +13,11 @@ func Test_ParseTurboConfigJson(t *testing.T) {
 	if err != nil {
 		t.Errorf("failed to get cwd: %v", err)
 	}
-	turboJSONPath := filepath.Join(defaultCwd, "testdata", "turbo.json")
+	cwd, err := CheckedToAbsolutePath(defaultCwd)
+	if err != nil {
+		t.Fatalf("cwd is not an absolute directory %v: %v", defaultCwd, err)
+	}
+	turboJSONPath := cwd.Join("testdata", "turbo.json")
 	turboConfig, err := ReadTurboConfigJSON(turboJSONPath)
 	if err != nil {
 		t.Fatalf("invalid parse: %#v", err)

@@ -0,0 +1,64 @@
+package fs
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+// AbsolutePath represents a platform-dependent absolute path on the filesystem,
+// and is used to enfore correct path manipulation
+type AbsolutePath string
+
+func CheckedToAbsolutePath(s string) (AbsolutePath, error) {
+	if filepath.IsAbs(s) {
+		return AbsolutePath(s), nil
+	}
+	return "", fmt.Errorf("%v is not an absolute path", s)
+}
+
+func UnsafeToAbsolutePath(s string) AbsolutePath {
+	return AbsolutePath(s)
+}
+
+func GetCwd() (AbsolutePath, error) {
+	cwdRaw, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("invalid working directory: %w", err)
+	}
+	cwd, err := CheckedToAbsolutePath(cwdRaw)
+	if err != nil {
+		return "", fmt.Errorf("cwd is not an absolute path %v: %v", cwdRaw, err)
+	}
+	return cwd, nil
+}
+
+func (ap AbsolutePath) ToStringDuringMigration() string {
+	return ap.asString()
+}
+
+func (ap AbsolutePath) Join(args ...string) AbsolutePath {
+	return AbsolutePath(filepath.Join(ap.asString(), filepath.Join(args...)))
+}
+func (ap AbsolutePath) asString() string {
+	return string(ap)
+}
+func (ap AbsolutePath) Dir() AbsolutePath {
+	return AbsolutePath(filepath.Dir(ap.asString()))
+}
+func (ap AbsolutePath) MkdirAll() error {
+	return os.MkdirAll(ap.asString(), DirPermissions)
+}
+func (ap AbsolutePath) Remove() error {
+	return os.Remove(ap.asString())
+}
+func (ap AbsolutePath) Open() (*os.File, error) {
+	return os.Open(ap.asString())
+}
+func (ap AbsolutePath) ReadFile() ([]byte, error) {
+	return ioutil.ReadFile(ap.asString())
+}
+func (ap AbsolutePath) FileExists() bool {
+	return FileExists(ap.asString())
+}
@@ -58,8 +58,8 @@ type PruneOptions struct {
 	docker bool
 }
 
-func parsePruneArgs(args []string, cwd string) (*PruneOptions, error) {
-	var options = &PruneOptions{cwd: cwd}
+func parsePruneArgs(args []string, cwd fs.AbsolutePath) (*PruneOptions, error) {
+	var options = &PruneOptions{cwd: cwd.ToStringDuringMigration()}
 
 	if len(args) == 0 {
 		return nil, errors.Errorf("At least one target must be specified.")

@@ -445,14 +445,14 @@ func getDefaultRunOptions() *RunOptions {
 	}
 }
 
-func parseRunArgs(args []string, cwd string, output cli.Ui) (*RunOptions, error) {
+func parseRunArgs(args []string, cwd fs.AbsolutePath, output cli.Ui) (*RunOptions, error) {
 	var runOptions = getDefaultRunOptions()
 
 	if len(args) == 0 {
 		return nil, errors.Errorf("At least one task must be specified.")
 	}
 
-	runOptions.cwd = cwd
+	runOptions.cwd = cwd.ToStringDuringMigration()
 	unresolvedCacheFolder := filepath.FromSlash("./node_modules/.cache/turbo")
 
 	if os.Getenv("TURBO_FORCE") == "true" {

@@ -16,11 +16,11 @@ import (
 )
 
 func TestParseConfig(t *testing.T) {
-	defaultCwd, err := os.Getwd()
+	defaultCwd, err := fs.GetCwd()
 	if err != nil {
 		t.Errorf("failed to get cwd: %v", err)
 	}
-	defaultCacheFolder := filepath.Join(defaultCwd, filepath.FromSlash("node_modules/.cache/turbo"))
+	defaultCacheFolder := defaultCwd.Join(filepath.FromSlash("node_modules/.cache/turbo"))
 	cases := []struct {
 		Name     string
 		Args     []string
@@ -39,8 +39,8 @@ func TestParseConfig(t *testing.T) {
 				cache:               true,
 				forceExecution:      false,
 				profile:             "",
-				cwd:                 defaultCwd,
-				cacheFolder:         defaultCacheFolder,
+				cwd:                 defaultCwd.ToStringDuringMigration(),
+				cacheFolder:         defaultCacheFolder.ToStringDuringMigration(),
 				cacheHitLogsMode:    FullLogs,
 				cacheMissLogsMode:   FullLogs,
 			},
@@ -59,8 +59,8 @@ func TestParseConfig(t *testing.T) {
 				forceExecution:      false,
 				profile:             "",
 				scope:               []string{"foo", "blah"},
-				cwd:                 defaultCwd,
-				cacheFolder:         defaultCacheFolder,
+				cwd:                 defaultCwd.ToStringDuringMigration(),
+				cacheFolder:         defaultCacheFolder.ToStringDuringMigration(),
 				cacheHitLogsMode:    FullLogs,
 				cacheMissLogsMode:   FullLogs,
 			},
@@ -78,8 +78,8 @@ func TestParseConfig(t *testing.T) {
 				cache:               true,
 				forceExecution:      false,
 				profile:             "",
-				cwd:                 defaultCwd,
-				cacheFolder:         defaultCacheFolder,
+				cwd:                 defaultCwd.ToStringDuringMigration(),
+				cacheFolder:         defaultCacheFolder.ToStringDuringMigration(),
 				cacheHitLogsMode:    FullLogs,
 				cacheMissLogsMode:   FullLogs,
 			},
@@ -97,8 +97,8 @@ func TestParseConfig(t *testing.T) {
 				cache:               true,
 				forceExecution:      false,
 				profile:             "",
-				cwd:                 defaultCwd,
-				cacheFolder:         defaultCacheFolder,
+				cwd:                 defaultCwd.ToStringDuringMigration(),
+				cacheFolder:         defaultCacheFolder.ToStringDuringMigration(),
 				cacheHitLogsMode:    FullLogs,
 				cacheMissLogsMode:   FullLogs,
 			},
@@ -116,8 +116,8 @@ func TestParseConfig(t *testing.T) {
 				cache:               true,
 				forceExecution:      false,
 				profile:             "",
-				cwd:                 defaultCwd,
-				cacheFolder:         defaultCacheFolder,
+				cwd:                 defaultCwd.ToStringDuringMigration(),
+				cacheFolder:         defaultCacheFolder.ToStringDuringMigration(),
 				passThroughArgs:     []string{"--boop", "zoop"},
 				cacheHitLogsMode:    FullLogs,
 				cacheMissLogsMode:   FullLogs,
@@ -136,8 +136,8 @@ func TestParseConfig(t *testing.T) {
 				cache:               true,
 				forceExecution:      false,
 				profile:             "",
-				cwd:                 defaultCwd,
-				cacheFolder:         defaultCacheFolder,
+				cwd:                 defaultCwd.ToStringDuringMigration(),
+				cacheFolder:         defaultCacheFolder.ToStringDuringMigration(),
 				passThroughArgs:     []string{},
 				cacheHitLogsMode:    FullLogs,
 				cacheMissLogsMode:   FullLogs,
@@ -153,8 +153,8 @@ func TestParseConfig(t *testing.T) {
 				bail:              true,
 				concurrency:       10,
 				cache:             true,
-				cwd:               defaultCwd,
-				cacheFolder:       defaultCacheFolder,
+				cwd:               defaultCwd.ToStringDuringMigration(),
+				cacheFolder:       defaultCacheFolder.ToStringDuringMigration(),
 				cacheHitLogsMode:  FullLogs,
 				cacheMissLogsMode: FullLogs,
 			},