fix: inherit .node-version from ancestor directories in monorepos (#606)

Previously, `download_runtime_for_project` only checked the current
directory for version sources. When no local source was found, it
defaulted to LTS and wrote a new `.node-version` — even if the monorepo
root already had one.

Add `find_ancestor_node_version()` to walk up and check for `.node-version`
in parent directories. When found, inherit that version and suppress the
write-back — similar to how packageManager is workspace-wide.

Author: fengmk2

.github/workflows/test-standalone-install.yml

@@ -38,8 +38,6 @@ jobs:
       - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Run install.sh
-        env:
-          VITE_PLUS_VERSION: test
         run: cat packages/global/install.sh | bash
 
       - name: Verify installation
@@ -130,7 +128,6 @@ jobs:
         run: |
           docker run --rm --platform linux/arm64 \
             -v "${{ github.workspace }}:/workspace" \
-            -e VITE_PLUS_VERSION=test \
             ubuntu:20.04 bash -c "
               ls -al ~/
               apt-get update && apt-get install -y curl ca-certificates
@@ -187,8 +184,6 @@ jobs:
 
       - name: Run install.ps1
         shell: pwsh
-        env:
-          VITE_PLUS_VERSION: test
         run: |
           & ./packages/global/install.ps1
 

crates/vite_js_runtime/src/runtime.rs

@@ -343,14 +343,14 @@ pub async fn download_runtime_for_project(project_path: &AbsolutePath) -> Result
     let provider = NodeProvider::new();
     let cache_dir = crate::cache::get_cache_dir()?;
 
-    // Use resolve_node_version to find the version (no directory walking for project downloads)
-    let resolution = resolve_node_version(project_path, false).await?;
+    // Resolve version from the project directory, walking up to inherit from ancestors
+    let resolution = resolve_node_version(project_path, true).await?;
 
     // Validate the version from the resolved source
     let version_req =
         resolution.as_ref().and_then(|r| normalize_version(&r.version, &r.source.to_string()));
 
-    // For compatibility checking, we need to read all sources
+    // For compatibility checking, we need to read all sources from the local package.json
     let package_json_path = project_path.join("package.json");
     let pkg = read_package_json(&package_json_path).await?;
 
@@ -662,18 +662,21 @@ mod tests {
 
         let runtime = download_runtime_for_project(&temp_path).await.unwrap();
 
-        // Should download latest Node.js
+        // Should download Node.js
         assert_eq!(runtime.runtime_type(), JsRuntimeType::Node);
 
         // Should have a valid version
         let version = runtime.version();
         let parsed = node_semver::Version::parse(version).unwrap();
         assert!(parsed.major >= 20);
 
-        // Should write resolved version to .node-version
-        let node_version_content =
-            tokio::fs::read_to_string(temp_path.join(".node-version")).await.unwrap();
-        assert_eq!(node_version_content, format!("{version}\n"));
+        // .node-version is written only if no ancestor has one (write-back is
+        // suppressed when an ancestor .node-version exists, e.g. in a monorepo)
+        if tokio::fs::try_exists(temp_path.join(".node-version")).await.unwrap() {
+            let node_version_content =
+                tokio::fs::read_to_string(temp_path.join(".node-version")).await.unwrap();
+            assert_eq!(node_version_content, format!("{version}\n"));
+        }
 
         // package.json should remain unchanged
         let pkg_content = tokio::fs::read_to_string(temp_path.join("package.json")).await.unwrap();
@@ -700,10 +703,13 @@ mod tests {
         let runtime = download_runtime_for_project(&temp_path).await.unwrap();
         let version = runtime.version();
 
-        // Should write resolved version to .node-version
-        let node_version_content =
-            tokio::fs::read_to_string(temp_path.join(".node-version")).await.unwrap();
-        assert_eq!(node_version_content, format!("{version}\n"));
+        // .node-version is written only if no ancestor has one (write-back is
+        // suppressed when an ancestor .node-version exists, e.g. in a monorepo)
+        if tokio::fs::try_exists(temp_path.join(".node-version")).await.unwrap() {
+            let node_version_content =
+                tokio::fs::read_to_string(temp_path.join(".node-version")).await.unwrap();
+            assert_eq!(node_version_content, format!("{version}\n"));
+        }
 
         // package.json should remain unchanged
         let pkg_content = tokio::fs::read_to_string(temp_path.join("package.json")).await.unwrap();
@@ -773,6 +779,31 @@ mod tests {
         assert_eq!(runtime.runtime_type(), JsRuntimeType::Node);
     }
 
+    #[tokio::test]
+    async fn test_download_runtime_for_project_inherits_parent_node_version() {
+        let temp_dir = TempDir::new().unwrap();
+        let temp_path = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+
+        // Write .node-version in root (simulating monorepo root)
+        tokio::fs::write(temp_path.join(".node-version"), "20.18.0\n").await.unwrap();
+
+        // Create a sub-package directory with a minimal package.json (no engines/devEngines)
+        let subdir = temp_path.join("packages").join("foo");
+        tokio::fs::create_dir_all(&subdir).await.unwrap();
+        tokio::fs::write(subdir.join("package.json"), r#"{"name": "foo"}"#).await.unwrap();
+
+        let runtime = download_runtime_for_project(&subdir).await.unwrap();
+
+        // Should inherit version from parent's .node-version
+        assert_eq!(runtime.version(), "20.18.0");
+
+        // Should NOT write .node-version in the sub-package
+        assert!(
+            !tokio::fs::try_exists(subdir.join(".node-version")).await.unwrap(),
+            ".node-version should not be written in sub-package when parent already has one"
+        );
+    }
+
     /// Integration test that downloads a real Node.js version
     #[tokio::test]
     async fn test_download_node_integration() {

packages/global/install.ps1

@@ -406,6 +406,11 @@ function Main {
     $pkg.PSObject.Properties.Remove("optionalDependencies")
     $pkg | ConvertTo-Json -Depth 10 | Set-Content $pkgFile
 
+    # Remove stale lockfile and node_modules to avoid frozen-lockfile conflicts
+    # when package.json changes between installs
+    Remove-Item -Path "$VersionDir\pnpm-lock.yaml" -Force -ErrorAction SilentlyContinue
+    Remove-Item -Path "$VersionDir\node_modules" -Recurse -Force -ErrorAction SilentlyContinue
+
     # Install production dependencies
     Push-Location $VersionDir
     try {

packages/global/install.sh

@@ -640,6 +640,11 @@ main() {
     { print }
   ' "$pkg_file" > "$pkg_file.tmp" && mv "$pkg_file.tmp" "$pkg_file"
 
+  # Remove stale lockfile and node_modules to avoid frozen-lockfile conflicts
+  # when package.json changes between installs
+  rm -f "$VERSION_DIR/pnpm-lock.yaml"
+  rm -rf "$VERSION_DIR/node_modules"
+
   # Install production dependencies
   (cd "$VERSION_DIR" && CI=true "$BIN_DIR/vp" install --silent)
 

packages/global/snap-tests/shim-inherits-parent-dev-engines-runtime/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "shim-inherits-parent-dev-engines-runtime",
+  "version": "1.0.0",
+  "private": true,
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": "20.18.0"
+    }
+  }
+}

packages/global/snap-tests/shim-inherits-parent-dev-engines-runtime/packages/app/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "app",
+  "version": "1.0.0",
+  "private": true
+}

packages/global/snap-tests/shim-inherits-parent-dev-engines-runtime/snap.txt

@@ -0,0 +1,8 @@
+> vp env exec node -v # Root: uses devEngines.runtime directly
+v20.18.0
+
+> cd packages/app && vp env exec node -v # Sub-package: inherits parent devEngines.runtime
+v20.18.0
+
+> test ! -f packages/app/.node-version && echo 'No .node-version written in sub-package' # Verify no .node-version created in sub-package
+No .node-version written in sub-package

packages/global/snap-tests/shim-inherits-parent-dev-engines-runtime/steps.json

@@ -0,0 +1,9 @@
+{
+  "env": {},
+  "ignoredPlatforms": ["win32"],
+  "commands": [
+    "vp env exec node -v # Root: uses devEngines.runtime directly",
+    "cd packages/app && vp env exec node -v # Sub-package: inherits parent devEngines.runtime",
+    "test ! -f packages/app/.node-version && echo 'No .node-version written in sub-package' # Verify no .node-version created in sub-package"
+  ]
+}

packages/global/snap-tests/shim-inherits-parent-engines-node/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "shim-inherits-parent-engines-node",
+  "version": "1.0.0",
+  "private": true,
+  "engines": {
+    "node": "20.18.0"
+  }
+}

packages/global/snap-tests/shim-inherits-parent-engines-node/packages/app/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "app",
+  "version": "1.0.0",
+  "private": true
+}