fix(installer): require split-layout releases

Author: fengmk2

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

@@ -9,6 +9,7 @@ on:
       - 'packages/cli/install.sh'
       - 'packages/cli/install.ps1'
       - 'packages/tools/src/install-global-cli.ts'
+      - 'packages/tools/src/local-npm-registry.ts'
       - 'crates/vp_installer/**'
       - 'crates/vp_trampoline/**'
       - 'crates/vp_global_cli/**'
@@ -1257,40 +1258,33 @@ jobs:
           # exit code after the assertions so the PowerShell step succeeds.
           $global:LASTEXITCODE = 0
 
-      - name: vp-setup.exe pre-split fallback leaves no split roots
+      - name: vp-setup.exe rejects releases before 0.3.0
         shell: pwsh
         run: |
           $ErrorActionPreference = "Stop"
+          $PSNativeCommandUseErrorActionPreference = $false
           $installer = Join-Path $env:DEV_DRIVE "target/release/vp-setup.exe"
-          $profile = Join-Path $env:RUNNER_TEMP "vp-setup-0.2.9-profile"
-          $localSplitRoot = Join-Path $env:LOCALAPPDATA "vite-plus"
-          $roamingSplitRoot = Join-Path $env:APPDATA "vite-plus"
-          $splitRoots = @($localSplitRoot, $roamingSplitRoot)
-          Remove-Item -Recurse -Force $profile -ErrorAction SilentlyContinue
-          foreach ($splitRoot in $splitRoots) {
-            if (Test-Path $splitRoot) {
-              throw "fresh-install test requires an absent split root: $splitRoot"
-            }
+          $installRoot = Join-Path $env:RUNNER_TEMP "vp-setup-unsupported-version"
+          Remove-Item -Recurse -Force $installRoot -ErrorAction SilentlyContinue
+          $env:VP_HOME = $installRoot
+          Remove-Item Env:VP_BIN_DIR, Env:VP_DATA_DIR, Env:VP_CACHE_DIR -ErrorAction SilentlyContinue
+
+          $output = (& $installer --yes --quiet --version 0.2.9 --no-node-manager --no-modify-path 2>&1) | Out-String
+          $exitCode = $LASTEXITCODE
+          Write-Host $output
+          if ($exitCode -ne 1) {
+            throw "vp-setup.exe exited with $exitCode, expected 1"
           }
-          New-Item -ItemType Directory -Force -Path $profile | Out-Null
-
-          Remove-Item Env:VP_HOME, Env:VP_BIN_DIR, Env:VP_DATA_DIR, Env:VP_CACHE_DIR -ErrorAction SilentlyContinue
-          $env:USERPROFILE = $profile
-          $env:HOME = $profile
-          & $installer --yes --version 0.2.9 --no-node-manager --no-modify-path
-          if ($LASTEXITCODE -ne 0) {
-            throw "vp-setup.exe exited with $LASTEXITCODE"
+          if (-not $output.Contains("Install vite-plus 0.3.0 or later")) {
+            throw "vp-setup.exe did not report its minimum supported version"
           }
-
-          $legacyRoot = Join-Path $profile ".vite-plus"
-          if (-not (Test-Path (Join-Path $legacyRoot "current/bin/vp.exe"))) {
-            throw "pre-split payload missing from $legacyRoot"
+          if ($output -match "(?i)preview") {
+            throw "vp-setup.exe exposed preview-build guidance"
           }
-          foreach ($splitRoot in $splitRoots) {
-            if (Test-Path $splitRoot) {
-              throw "vp-setup.exe left split root $splitRoot"
-            }
+          if (Test-Path $installRoot) {
+            throw "vp-setup.exe created unsupported-version root $installRoot"
           }
+          $global:LASTEXITCODE = 0
 
       - name: Incomplete directory overrides are rejected in PowerShell
         shell: pwsh
@@ -1569,9 +1563,58 @@ jobs:
           }
           & $vp --version
 
-      - name: Install via vp-setup.exe (silent)
+      - name: Start local preview registry for vp-setup.exe
+        shell: bash
+        run: |
+          test_version="0.0.0-commit.${GITHUB_SHA}"
+          registry_root="$RUNNER_TEMP/vp-setup-local-registry"
+          packages_dir="$registry_root/packages"
+          main_dir="$registry_root/vite-plus"
+          platform_dir="$registry_root/vite-plus-cli-win32-x64-msvc"
+          rm -rf "$registry_root"
+          mkdir -p "$packages_dir" "$main_dir" "$platform_dir"
+
+          node -e '
+            const fs = require("node:fs");
+            const path = require("node:path");
+            const [dir, version] = process.argv.slice(1);
+            fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "vite-plus", version }));
+          ' "$main_dir" "$test_version"
+          node -e '
+            const fs = require("node:fs");
+            const path = require("node:path");
+            const [dir, version] = process.argv.slice(1);
+            const manifest = {
+              name: "@voidzero-dev/vite-plus-cli-win32-x64-msvc",
+              version,
+              files: ["vp.exe", "vp-shim.exe"],
+            };
+            fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify(manifest));
+          ' "$platform_dir" "$test_version"
+          cp "$DEV_DRIVE/target/release/vp.exe" "$DEV_DRIVE/target/release/vp-shim.exe" "$platform_dir/"
+          npm pack "$main_dir" --pack-destination "$packages_dir"
+          npm pack "$platform_dir" --pack-destination "$packages_dir"
+
+          registry_log="$registry_root/registry.out"
+          node "$GITHUB_WORKSPACE/packages/tools/src/local-npm-registry.ts" --serve --packages-dir "$packages_dir" > "$registry_log" 2>&1 &
+          server_pid=$!
+          until grep -q '"registry"' "$registry_log" 2>/dev/null; do
+            if ! kill -0 "$server_pid" 2>/dev/null; then
+              cat "$registry_log"
+              exit 1
+            fi
+            sleep 0.2
+          done
+          handshake=$(grep -m1 '"registry"' "$registry_log")
+          registry=$(echo "$handshake" | node -e 'process.stdin.on("data", data => process.stdout.write(JSON.parse(data).registry))')
+          echo "VP_SETUP_TEST_REGISTRY=$registry" >> "$GITHUB_ENV"
+          echo "VP_SETUP_TEST_VERSION=$test_version" >> "$GITHUB_ENV"
+
+      - name: Install local preview via vp-setup.exe (silent)
         shell: pwsh
-        run: ${{ format('{0}/target/release/vp-setup.exe', env.DEV_DRIVE) }}
+        run: |
+          $installer = Join-Path $env:DEV_DRIVE "target/release/vp-setup.exe"
+          & $installer --version $env:VP_SETUP_TEST_VERSION --registry $env:VP_SETUP_TEST_REGISTRY
 
       - name: Set PATH
         shell: bash

crates/vp_global_cli/src/commands/upgrade/mod.rs

@@ -101,7 +101,7 @@ pub async fn execute(options: UpgradeOptions) -> Result<ExitStatus, Error> {
     // binary. A monolithic install accepts each release. This includes a
     // VP_HOME pin and an existing ~/.vite-plus install.
     let legacy = vp_shared::VpDirs::legacy_single_root(&config.user_home);
-    if legacy.data != config.dirs.data && !supports_split_layout(&resolved.version) {
+    if legacy.data != config.dirs.data && !vp_setup::supports_split_layout(&resolved.version) {
         return Err(Error::Upgrade(
             format!(
                 "vite-plus {} does not support this split directory layout. \
@@ -280,35 +280,3 @@ async fn execute_rollback(
 
     Ok(ExitStatus::default())
 }
-
-/// Return `true` if `version` supports the split layout.
-///
-/// Version 0.3.0 and later support it, including prereleases. Preview builds
-/// (`0.0.0-commit.<sha>`) also support it because they track the current branch.
-fn supports_split_layout(version: &str) -> bool {
-    let Ok(version) = node_semver::Version::parse(version) else {
-        return false;
-    };
-    if version.major == 0 && version.minor == 0 && version.patch == 0 {
-        return !version.pre_release.is_empty() || !version.build.is_empty();
-    }
-    version.major > 0 || version.minor >= 3
-}
-
-#[cfg(test)]
-mod tests {
-    use super::supports_split_layout;
-
-    #[test]
-    fn split_layout_support_by_version() {
-        assert!(supports_split_layout("0.3.0"));
-        assert!(supports_split_layout("0.3.0-alpha.1"));
-        assert!(supports_split_layout("0.4.2"));
-        assert!(supports_split_layout("1.0.0"));
-        assert!(supports_split_layout("0.0.0-commit.0123abc"));
-        assert!(!supports_split_layout("0.2.9"));
-        assert!(!supports_split_layout("0.2.0"));
-        assert!(!supports_split_layout("0.1.14-alpha.1"));
-        assert!(!supports_split_layout("not-a-version"));
-    }
-}

crates/vp_installer/src/main.rs

@@ -31,39 +31,6 @@ use vp_setup::{VP_BINARY_NAME, install, integrity, platform, registry};
 use vp_shared::VpDirs;
 use vt_path::AbsolutePathBuf;
 
-#[derive(Debug)]
-struct AbandonedSplitData {
-    data: AbsolutePathBuf,
-    parent_to_remove: Option<std::path::PathBuf>,
-}
-
-impl AbandonedSplitData {
-    async fn capture(data: AbsolutePathBuf) -> Option<Self> {
-        if tokio::fs::try_exists(&data).await.unwrap_or(true) {
-            return None;
-        }
-
-        let parent_to_remove = if let Some(parent) = data.as_path().parent()
-            && !tokio::fs::try_exists(parent).await.unwrap_or(true)
-        {
-            Some(parent.to_path_buf())
-        } else {
-            None
-        };
-        Some(Self { data, parent_to_remove })
-    }
-
-    async fn remove(self) {
-        let _ = tokio::fs::remove_dir_all(&self.data).await;
-        if let Some(parent) = self.parent_to_remove {
-            // Remove only the parent that did not exist before probing. A
-            // concurrent file or directory makes this non-recursive removal
-            // fail and preserves the parent.
-            let _ = tokio::fs::remove_dir(parent).await;
-        }
-    }
-}
-
 /// Restrict DLL search to system32 only to prevent DLL hijacking
 /// when the installer is run from a Downloads folder.
 #[cfg(windows)]
@@ -185,10 +152,7 @@ async fn run(mut opts: cli::Options, dirs: VpDirs) -> i32 {
     }
 
     let code = match do_install(&opts, &dirs).await {
-        Ok(effective_dirs) => {
-            // do_install uses the monolithic root for a pre-split payload.
-            // Report the directories that it used.
-            let (data_dir_display, bin_dir_display) = dir_displays(&effective_dirs);
+        Ok(()) => {
             print_success(&opts, &data_dir_display, &bin_dir_display);
             0
         }
@@ -207,23 +171,17 @@ async fn run(mut opts: cli::Options, dirs: VpDirs) -> i32 {
     code
 }
 
-/// Install the resolved version and return the directories that the installer
-/// used. The installer uses the monolithic root for a pre-split payload.
+/// Install the resolved version.
 #[allow(clippy::print_stdout)]
-async fn do_install(
-    opts: &cli::Options,
-    dirs: &VpDirs,
-) -> Result<VpDirs, Box<dyn std::error::Error>> {
-    let mut dirs = dirs.clone();
+async fn do_install(opts: &cli::Options, dirs: &VpDirs) -> Result<(), Box<dyn std::error::Error>> {
     let platform_suffix = platform::detect_platform_suffix()?;
     if !opts.quiet {
         print_info(&format!("detected platform: {platform_suffix}"));
     }
 
     // Check local version first to potentially skip HTTP requests.
     // This operation is read-only. Create the install root only after the
-    // downloaded payload confirms the layout. Thus, a pre-split fallback does
-    // not leave empty split directories.
+    // installer resolves and validates the target version.
     let current_version = install::read_current_version(&dirs.data).await;
 
     let version_or_tag = opts.version.as_deref().unwrap_or(&opts.tag);
@@ -235,6 +193,12 @@ async fn do_install(
     }
     let target_version =
         registry::resolve_version_string(version_or_tag, opts.registry.as_deref()).await?;
+    if !vp_setup::supports_split_layout(&target_version) {
+        return Err(format!(
+            "vite-plus {target_version} is not supported by vp-setup. Install vite-plus 0.3.0 or later."
+        )
+        .into());
+    }
 
     // Same version only if the binary is intact — a corrupted install needs a full reinstall.
     // `is_install_dir_for_version` also matches `{version}+force.*` dirs left by a forced
@@ -278,41 +242,6 @@ async fn do_install(
         }
         integrity::verify_integrity(&platform_data, &resolved.platform_integrity)?;
 
-        // A pre-split release resolves every path from VP_HOME. Its default is
-        // ~/.vite-plus. Its environment setup, shims, and trampolines cannot
-        // use split roots. Use that monolithic root when the payload cannot
-        // report split category roots.
-        let legacy = VpDirs::legacy_single_root(&vp_shared::EnvConfig::get().user_home);
-        let abandoned_split_data = if legacy.data == dirs.data {
-            // Pre-split and split-aware payloads use the same monolithic root
-            // here. Skip the probe because it extracts and starts the payload.
-            None
-        } else {
-            let split_data_cleanup = AbandonedSplitData::capture(dirs.data.clone()).await;
-            if let Some(probed) = install::probe_payload_dirs(&platform_data).await {
-                // Use the payload's resolution, as install.sh and install.ps1 do.
-                // This keeps the written layout equal to the resolved layout.
-                dirs = VpDirs::from_resolved_parts(
-                    probed.bin,
-                    probed.data,
-                    probed.cache,
-                    probed.config,
-                    probed.state,
-                    probed.layout,
-                );
-                None
-            } else {
-                if !opts.quiet {
-                    print_info(&format!(
-                        "vite-plus {target_version} does not support the split directory layout. Vite+ will install it in {}.",
-                        legacy.data.as_path().display()
-                    ));
-                }
-                dirs = legacy;
-                split_data_cleanup
-            }
-        };
-
         let install_dir = &dirs.data;
         let version_dir = install_dir.join(&target_version);
         tokio::fs::create_dir_all(&version_dir).await?;
@@ -332,13 +261,6 @@ async fn do_install(
             let _ = tokio::fs::remove_dir_all(&version_dir).await;
         }
 
-        // The managed node and pnpm use paths from the process EnvConfig. The
-        // installer pinned this configuration before the payload selected the
-        // monolithic root. Remove the split data root and its empty application
-        // parent if this run created them.
-        if let Some(split_data) = abandoned_split_data {
-            split_data.remove().await;
-        }
         result?;
     }
 
@@ -371,7 +293,7 @@ async fn do_install(
         }
     }
 
-    Ok(dirs)
+    Ok(())
 }
 
 /// Auto-detect whether the Node.js version manager should be enabled.
@@ -489,6 +411,10 @@ async fn install_new_version(
     if !tokio::fs::try_exists(&binary_path).await.unwrap_or(false) {
         return Err("Binary not found after extraction. The download may be corrupted.".into());
     }
+    #[cfg(windows)]
+    if !tokio::fs::try_exists(version_dir.join("bin").join("vp-shim.exe")).await.unwrap_or(false) {
+        return Err("Trampoline not found after extraction. The download may be corrupted.".into());
+    }
 
     install::generate_wrapper_package_json(version_dir, version).await?;
 
@@ -545,17 +471,8 @@ async fn setup_bin_shims(dirs: &VpDirs) -> Result<(), Box<dyn std::error::Error>
         let shim_src = dirs.data.join("current").join("bin").join("vp-shim.exe");
         let shim_dst = bin_dir.join("vp.exe");
 
-        // Prefer vp-shim.exe (trampoline); fall back to vp.exe for pre-trampoline releases
-        let src = if tokio::fs::try_exists(&shim_src).await.unwrap_or(false) {
-            shim_src
-        } else {
-            dirs.data.join("current").join("bin").join("vp.exe")
-        };
-
-        if tokio::fs::try_exists(&src).await.unwrap_or(false) {
-            replace_windows_exe(&src, &shim_dst, &bin_dir).await?;
-            dirs.write_shim_pointer("vp")?;
-        }
+        replace_windows_exe(&shim_src, &shim_dst, &bin_dir).await?;
+        dirs.write_shim_pointer("vp")?;
 
         // Best-effort cleanup of old shim files
         if let Ok(mut entries) = tokio::fs::read_dir(&bin_dir).await {
@@ -968,32 +885,4 @@ mod tests {
             }
         });
     }
-
-    #[tokio::test]
-    async fn abandoned_split_data_cleanup_removes_new_empty_parent() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = tmp.path().join("vite-plus");
-        let data = AbsolutePathBuf::new(parent.join("data")).unwrap();
-        let cleanup = AbandonedSplitData::capture(data.clone()).await.unwrap();
-
-        tokio::fs::create_dir_all(&data).await.unwrap();
-        cleanup.remove().await;
-
-        assert!(!parent.exists());
-    }
-
-    #[tokio::test]
-    async fn abandoned_split_data_cleanup_preserves_existing_parent() {
-        let tmp = tempfile::tempdir().unwrap();
-        let parent = tmp.path().join("vite-plus");
-        std::fs::create_dir(&parent).unwrap();
-        let data = AbsolutePathBuf::new(parent.join("data")).unwrap();
-        let cleanup = AbandonedSplitData::capture(data.clone()).await.unwrap();
-
-        tokio::fs::create_dir_all(&data).await.unwrap();
-        cleanup.remove().await;
-
-        assert!(parent.is_dir());
-        assert!(!data.as_path().exists());
-    }
 }