fix(cargo): resolve relative build dirs against workspace root and use FIFO-safe file reads

- Relative build.target-dir and build.build-dir now resolve against the
  workspace root as Cargo does, not the config file's directory. Fixes
  invalidation when target-dir is set in ~/.cargo/config.toml (#387).
- Replace std::fs::read_to_string with read_regular_to_string_sync for
  Cargo.toml and .cargo/config reads to prevent hangs on FIFO/device files.

Author: cursoragent

crates/socket-patch-core/src/utils/cargo_build_cache.rs

@@ -61,7 +61,7 @@ pub fn build_dirs_with(
 ) -> BuildDirs {
     let env = |k: &str| env(k).filter(|v| !v.trim().is_empty());
     let ws_root = workspace_root(cwd);
-    let config = ConfigDirs::read(cwd, cargo_home);
+    let config = ConfigDirs::read(cwd, cargo_home, &ws_root);
 
     let mut candidates: Vec<PathBuf> = Vec::new();
     let mut unresolved = Vec::new();
@@ -77,11 +77,10 @@ pub fn build_dirs_with(
     // build-dir (cargo 1.91+): where the fingerprints live; defaults to
     // the target dir.
     let build_dir = env("CARGO_BUILD_BUILD_DIR")
-        .map(|v| (v, cwd.to_path_buf()))
         .or_else(|| config.build_dir.clone());
-    if let Some((raw, base)) = build_dir {
+    if let Some(raw) = build_dir {
         match expand_build_dir(&raw, &ws_root, cargo_home) {
-            Some(p) => candidates.push(base.join(p)),
+            Some(p) => candidates.push(ws_root.join(p)),
             None => unresolved.push(raw),
         }
     }
@@ -126,7 +125,7 @@ fn workspace_root(cwd: &Path) -> PathBuf {
     }
     for dir in cwd.ancestors() {
         let manifest = dir.join("Cargo.toml");
-        if let Ok(text) = std::fs::read_to_string(&manifest) {
+        if let Ok(text) = crate::utils::fs::read_regular_to_string_sync(&manifest) {
             if text
                 .parse::<toml_edit::DocumentMut>()
                 .is_ok_and(|d| d.contains_key("workspace"))
@@ -142,29 +141,28 @@ fn workspace_root(cwd: &Path) -> PathBuf {
 /// reads for `cwd`: `.cargo/config.toml` (or legacy `.cargo/config`) in
 /// `cwd` and every ancestor, then `$CARGO_HOME/config.toml`; the deepest
 /// file that sets a key wins. A relative value resolves against the
-/// directory holding the `.cargo` directory.
+/// workspace root.
 #[derive(Default)]
 struct ConfigDirs {
     target_dir: Option<PathBuf>,
-    /// The raw value and the base its relative form resolves against.
-    build_dir: Option<(String, PathBuf)>,
+    /// The raw value.
+    build_dir: Option<String>,
 }
 
 impl ConfigDirs {
-    fn read(cwd: &Path, cargo_home: Option<&Path>) -> Self {
-        let mut files: Vec<(PathBuf, PathBuf)> = cwd
+    fn read(cwd: &Path, cargo_home: Option<&Path>, ws_root: &Path) -> Self {
+        let mut files: Vec<PathBuf> = cwd
             .ancestors()
-            .map(|d| (d.join(".cargo"), d.to_path_buf()))
+            .map(|d| d.join(".cargo"))
             .collect();
         if let Some(home) = cargo_home {
-            let base = home.parent().map(Path::to_path_buf).unwrap_or_default();
-            files.push((home.to_path_buf(), base));
+            files.push(home.to_path_buf());
         }
         let mut out = ConfigDirs::default();
-        for (dot_cargo, base) in files {
+        for dot_cargo in files {
             let text = ["config.toml", "config"]
                 .iter()
-                .find_map(|f| std::fs::read_to_string(dot_cargo.join(f)).ok());
+                .find_map(|f| crate::utils::fs::read_regular_to_string_sync(&dot_cargo.join(f)).ok());
             let Some(doc) = text.and_then(|t| t.parse::<toml_edit::DocumentMut>().ok()) else {
                 continue;
             };
@@ -173,12 +171,12 @@ impl ConfigDirs {
             };
             if out.target_dir.is_none() {
                 if let Some(v) = build.get("target-dir").and_then(|v| v.as_str()) {
-                    out.target_dir = Some(base.join(v));
+                    out.target_dir = Some(ws_root.join(v));
                 }
             }
             if out.build_dir.is_none() {
                 if let Some(v) = build.get("build-dir").and_then(|v| v.as_str()) {
-                    out.build_dir = Some((v.to_string(), base.clone()));
+                    out.build_dir = Some(v.to_string());
                 }
             }
         }