fix(config-dir): Resolve relative TURBO_CONFIG_DIR_PATH before validation (#11122)

fix(config-dir): resolve relative TURBO_CONFIG_DIR_PATH before
validation

Fixes issue **#8645**

### Summary

This PR fixes a bug where setting `TURBO_CONFIG_DIR_PATH` to a
*relative* path
(e.g., `"configs"`) caused Turborepo to fail with:

    PathError::NotAbsolute("configs")

`AbsoluteSystemPathBuf::new()` only accepts absolute paths, but the
value from
the environment variable was passed directly without being resolved.  
This caused a startup failure even though the provided path was valid.

### Root Cause

When a user sets: TURBO_CONFIG_DIR_PATH="configs"


Turborepo attempted to validate `"configs"` as an absolute path.  
Since it is relative, the validator rejected it, causing Turborepo to
stop early.

### What This PR Changes

- Detects whether the provided `TURBO_CONFIG_DIR_PATH` is **relative**
- If relative, resolves it against the current working directory:

  ```rust
  std::env::current_dir()?.join(raw)

Converts the resolved path to UTF-8
Passes the resulting absolute path into AbsoluteSystemPathBuf::new()
Leaves absolute paths fully unchanged
Introduces zero breaking changes

Why This Fix Is Safe

- Relative → absolute resolution is deterministic and standard practice
- Absolute paths behave exactly the same as before
- Error surface area decreases (fewer startup failures)
- The change is minimal, well-scoped, and consistent with existing path
logic
- No impact on users who do not set the environment variable

---------

Co-authored-by: Anthony Shew <[email protected]>
Co-authored-by: Anthony Shew <[email protected]>

Author: praggCode

crates/turborepo-dirs/src/lib.rs

@@ -13,7 +13,23 @@ use turbopath::{AbsoluteSystemPathBuf, PathError};
 /// is set, it will return that path instead of `dirs_next::config_dir`.
 pub fn config_dir() -> Result<Option<AbsoluteSystemPathBuf>, PathError> {
     if let Ok(dir) = std::env::var("TURBO_CONFIG_DIR_PATH") {
-        return AbsoluteSystemPathBuf::new(dir).map(Some);
+        // Reject empty strings per Unix convention
+        if dir.is_empty() {
+            return Err(PathError::InvalidUnicode(dir));
+        }
+
+        let raw = std::path::PathBuf::from(&dir);
+
+        // Resolve to absolute path if necessary
+        let abs = if raw.is_absolute() {
+            raw
+        } else {
+            std::env::current_dir()?.join(raw)
+        };
+
+        let abs_str = abs.to_str().ok_or(PathError::InvalidUnicode(dir))?;
+
+        return AbsoluteSystemPathBuf::new(abs_str).map(Some);
     }
 
     dirs_config_dir()
@@ -28,6 +44,11 @@ pub fn config_dir() -> Result<Option<AbsoluteSystemPathBuf>, PathError> {
 /// is set, it will return that path instead of `dirs_next::config_dir`.
 pub fn vercel_config_dir() -> Result<Option<AbsoluteSystemPathBuf>, PathError> {
     if let Ok(dir) = std::env::var("VERCEL_CONFIG_DIR_PATH") {
+        // Reject empty strings per Unix convention.
+        if dir.is_empty() {
+            return Err(PathError::InvalidUnicode(dir));
+        }
+
         return AbsoluteSystemPathBuf::new(dir).map(Some);
     }
 
@@ -73,14 +94,18 @@ mod tests {
     }
 
     #[test]
-    fn test_config_dir_with_invalid_env_var() {
-        // Set TURBO_CONFIG_DIR_PATH to a relative path (invalid)
+    fn test_config_dir_with_relative_path() {
+        // Set TURBO_CONFIG_DIR_PATH to a relative path (should be resolved to absolute)
         unsafe {
             env::set_var("TURBO_CONFIG_DIR_PATH", "relative/path");
         }
 
         let result = config_dir();
-        assert!(result.is_err());
+        assert!(result.is_ok());
+        let path = result.unwrap();
+        assert!(path.is_some());
+        // Verify it was resolved to an absolute path
+        assert!(path.unwrap().as_path().is_absolute());
 
         unsafe {
             env::remove_var("TURBO_CONFIG_DIR_PATH");