fix: add node-version to vp cache key, revert version-dir approach

Include the resolved node-version in the cache key so multi-Node matrix
builds each get their own cache entry. Revert the version-specific
directory + symlink approach in favor of caching the entire ~/.vite-plus/
as a black box — avoids coupling to vp's internal installation layout.

Node version is now resolved before installVitePlus() so it can be
included in the cache key.

Author: fengmk2

dist/index.mjs

@@ -4,7 +4,6 @@ import { resolveVersion, restoreVpCache, saveVpCache } from "./cache-vp.js";
 import { State } from "./types.js";
 import { restoreCache, saveCache } from "@actions/cache";
 import { saveState, getState, warning } from "@actions/core";
-import { existsSync, symlinkSync, mkdirSync } from "node:fs";
 
 // Mock @actions/cache
 vi.mock("@actions/cache", () => ({
@@ -21,18 +20,6 @@ vi.mock("@actions/core", () => ({
   getState: vi.fn(),
 }));
 
-// Mock node:fs
-vi.mock("node:fs", async () => {
-  const actual = await vi.importActual<typeof import("node:fs")>("node:fs");
-  return {
-    ...actual,
-    existsSync: vi.fn(),
-    symlinkSync: vi.fn(),
-    mkdirSync: vi.fn(),
-    rmSync: vi.fn(),
-  };
-});
-
 describe("resolveVersion", () => {
   afterEach(() => {
     vi.restoreAllMocks();
@@ -94,51 +81,51 @@ describe("restoreVpCache", () => {
     vi.resetAllMocks();
   });
 
-  it("should return true on cache hit and create symlinks", async () => {
-    vi.mocked(restoreCache).mockResolvedValue(`setup-vp-Linux-${arch()}-0.1.8`);
-    vi.mocked(existsSync).mockReturnValue(false);
+  it("should return true on cache hit", async () => {
+    const expectedKey = `setup-vp-Linux-${arch()}-0.1.8-node20`;
+    vi.mocked(restoreCache).mockResolvedValue(expectedKey);
 
-    const result = await restoreVpCache("0.1.8");
+    const result = await restoreVpCache("0.1.8", "20");
 
     expect(result).toBe(true);
-    expect(saveState).toHaveBeenCalledWith(
-      State.VpCachePrimaryKey,
-      `setup-vp-Linux-${arch()}-0.1.8`,
-    );
-    expect(saveState).toHaveBeenCalledWith(
-      State.VpCacheMatchedKey,
-      `setup-vp-Linux-${arch()}-0.1.8`,
+    expect(saveState).toHaveBeenCalledWith(State.VpCachePrimaryKey, expectedKey);
+    expect(saveState).toHaveBeenCalledWith(State.VpCacheMatchedKey, expectedKey);
+  });
+
+  it("should include node version in cache key", async () => {
+    vi.mocked(restoreCache).mockResolvedValue(undefined);
+
+    await restoreVpCache("0.1.8", "22");
+
+    expect(restoreCache).toHaveBeenCalledWith(
+      ["/home/runner/.vite-plus"],
+      `setup-vp-Linux-${arch()}-0.1.8-node22`,
     );
-    expect(saveState).toHaveBeenCalledWith(State.VpCacheVersion, "0.1.8");
-    // Verify symlinks were created
-    expect(symlinkSync).toHaveBeenCalledTimes(2);
-    expect(mkdirSync).toHaveBeenCalled();
   });
 
-  it("should cache the version-specific directory, not the whole home", async () => {
+  it("should handle empty node version", async () => {
     vi.mocked(restoreCache).mockResolvedValue(undefined);
 
-    await restoreVpCache("0.1.8");
+    await restoreVpCache("0.1.8", "");
 
     expect(restoreCache).toHaveBeenCalledWith(
-      ["/home/runner/.vite-plus/0.1.8"],
-      `setup-vp-Linux-${arch()}-0.1.8`,
+      ["/home/runner/.vite-plus"],
+      `setup-vp-Linux-${arch()}-0.1.8-node`,
     );
   });
 
   it("should return false on cache miss", async () => {
     vi.mocked(restoreCache).mockResolvedValue(undefined);
 
-    const result = await restoreVpCache("0.1.8");
+    const result = await restoreVpCache("0.1.8", "20");
 
     expect(result).toBe(false);
-    expect(symlinkSync).not.toHaveBeenCalled();
   });
 
   it("should return false and warn on cache restore error", async () => {
     vi.mocked(restoreCache).mockRejectedValue(new Error("cache error"));
 
-    const result = await restoreVpCache("0.1.8");
+    const result = await restoreVpCache("0.1.8", "20");
 
     expect(result).toBe(false);
     expect(warning).toHaveBeenCalled();
@@ -164,10 +151,10 @@ describe("saveVpCache", () => {
   });
 
   it("should skip when primary key matches matched key", async () => {
-    vi.mocked(getState).mockImplementation((key: string) => {
-      if (key === State.VpCachePrimaryKey) return `setup-vp-Linux-${arch()}-0.1.8`;
-      if (key === State.VpCacheMatchedKey) return `setup-vp-Linux-${arch()}-0.1.8`;
-      if (key === State.VpCacheVersion) return "0.1.8";
+    const key = `setup-vp-Linux-${arch()}-0.1.8-node20`;
+    vi.mocked(getState).mockImplementation((k: string) => {
+      if (k === State.VpCachePrimaryKey) return key;
+      if (k === State.VpCacheMatchedKey) return key;
       return "";
     });
 
@@ -176,26 +163,22 @@ describe("saveVpCache", () => {
     expect(saveCache).not.toHaveBeenCalled();
   });
 
-  it("should save only the version-specific directory on cache miss", async () => {
-    vi.mocked(getState).mockImplementation((key: string) => {
-      if (key === State.VpCachePrimaryKey) return `setup-vp-Linux-${arch()}-0.1.8`;
-      if (key === State.VpCacheVersion) return "0.1.8";
+  it("should save cache on cache miss", async () => {
+    const key = `setup-vp-Linux-${arch()}-0.1.8-node20`;
+    vi.mocked(getState).mockImplementation((k: string) => {
+      if (k === State.VpCachePrimaryKey) return key;
       return "";
     });
     vi.mocked(saveCache).mockResolvedValue(12345);
 
     await saveVpCache();
 
-    expect(saveCache).toHaveBeenCalledWith(
-      ["/home/runner/.vite-plus/0.1.8"],
-      `setup-vp-Linux-${arch()}-0.1.8`,
-    );
+    expect(saveCache).toHaveBeenCalledWith(["/home/runner/.vite-plus"], key);
   });
 
   it("should handle save errors gracefully", async () => {
-    vi.mocked(getState).mockImplementation((key: string) => {
-      if (key === State.VpCachePrimaryKey) return `setup-vp-Linux-${arch()}-0.1.8`;
-      if (key === State.VpCacheVersion) return "0.1.8";
+    vi.mocked(getState).mockImplementation((k: string) => {
+      if (k === State.VpCachePrimaryKey) return `setup-vp-Linux-${arch()}-0.1.8-node20`;
       return "";
     });
     vi.mocked(saveCache).mockRejectedValue(new Error("ReserveCacheError"));

src/cache-vp.test.ts

@@ -1,8 +1,6 @@
 import { restoreCache, saveCache } from "@actions/cache";
 import { info, debug, saveState, getState, warning } from "@actions/core";
 import { arch, platform } from "node:os";
-import { join } from "node:path";
-import { mkdirSync, symlinkSync, rmSync, existsSync } from "node:fs";
 import { State } from "./types.js";
 import { getVitePlusHome } from "./utils.js";
 
@@ -29,24 +27,21 @@ export async function resolveVersion(versionInput: string): Promise<string | und
   }
 }
 
-export async function restoreVpCache(version: string): Promise<boolean> {
+export async function restoreVpCache(version: string, nodeVersion: string): Promise<boolean> {
   const vpHome = getVitePlusHome();
-  const versionDir = join(vpHome, version);
   const runnerOS = process.env.RUNNER_OS || platform();
   const runnerArch = arch();
-  const primaryKey = `setup-vp-${runnerOS}-${runnerArch}-${version}`;
+  const primaryKey = `setup-vp-${runnerOS}-${runnerArch}-${version}-node${nodeVersion}`;
 
   debug(`Vp cache key: ${primaryKey}`);
-  debug(`Vp cache path: ${versionDir}`);
+  debug(`Vp cache path: ${vpHome}`);
   saveState(State.VpCachePrimaryKey, primaryKey);
-  saveState(State.VpCacheVersion, version);
 
   try {
-    const matchedKey = await restoreCache([versionDir], primaryKey);
+    const matchedKey = await restoreCache([vpHome], primaryKey);
     if (matchedKey) {
       info(`Vite+ restored from cache (key: ${matchedKey})`);
       saveState(State.VpCacheMatchedKey, matchedKey);
-      linkVpVersion(vpHome, version);
       return true;
     }
   } catch (error) {
@@ -56,35 +51,11 @@ export async function restoreVpCache(version: string): Promise<boolean> {
   return false;
 }
 
-/**
- * Recreate the symlinks that the install script normally creates:
- *   ~/.vite-plus/current → {version}
- *   ~/.vite-plus/bin/vp  → ../current/bin/vp
- */
-function linkVpVersion(vpHome: string, version: string): void {
-  const currentLink = join(vpHome, "current");
-  const binDir = join(vpHome, "bin");
-  const binLink = join(binDir, process.platform === "win32" ? "vp.exe" : "vp");
-
-  // current → version directory
-  if (existsSync(currentLink)) rmSync(currentLink);
-  symlinkSync(version, currentLink);
-
-  // bin/vp → ../current/bin/vp
-  mkdirSync(binDir, { recursive: true });
-  if (existsSync(binLink)) rmSync(binLink);
-  symlinkSync(
-    join("..", "current", "bin", process.platform === "win32" ? "vp.exe" : "vp"),
-    binLink,
-  );
-}
-
 export async function saveVpCache(): Promise<void> {
   const primaryKey = getState(State.VpCachePrimaryKey);
   const matchedKey = getState(State.VpCacheMatchedKey);
-  const version = getState(State.VpCacheVersion);
 
-  if (!primaryKey || !version) {
+  if (!primaryKey) {
     debug("No vp cache key found. Skipping save.");
     return;
   }
@@ -95,8 +66,8 @@ export async function saveVpCache(): Promise<void> {
   }
 
   try {
-    const versionDir = join(getVitePlusHome(), version);
-    const cacheId = await saveCache([versionDir], primaryKey);
+    const vpHome = getVitePlusHome();
+    const cacheId = await saveCache([vpHome], primaryKey);
     if (cacheId === -1) {
       warning("Vp cache save failed or was skipped.");
       return;

src/cache-vp.ts

@@ -14,15 +14,16 @@ async function runMain(inputs: Inputs): Promise<void> {
   // Mark that post action should run
   saveState(State.IsPost, "true");
 
-  // Step 1: Install Vite+
-  await installVitePlus(inputs);
-
-  // Step 2: Set up Node.js version if specified
+  // Step 1: Resolve Node.js version (needed for cache key)
   let nodeVersion = inputs.nodeVersion;
   if (!nodeVersion && inputs.nodeVersionFile) {
     nodeVersion = resolveNodeVersionFile(inputs.nodeVersionFile);
   }
 
+  // Step 2: Install Vite+ (with cache keyed by vp version + node version)
+  await installVitePlus(inputs, nodeVersion || "");
+
+  // Step 3: Set up Node.js version if specified
   if (nodeVersion) {
     info(`Setting up Node.js ${nodeVersion} via vp env use...`);
     await exec("vp", ["env", "use", nodeVersion]);

src/index.ts

@@ -9,13 +9,13 @@ import { getVitePlusHome } from "./utils.js";
 const INSTALL_URL_SH = "https://viteplus.dev/install.sh";
 const INSTALL_URL_PS1 = "https://viteplus.dev/install.ps1";
 
-export async function installVitePlus(inputs: Inputs): Promise<void> {
+export async function installVitePlus(inputs: Inputs, nodeVersion: string): Promise<void> {
   const { version } = inputs;
 
   // Try to resolve version and restore from cache
   const resolvedVersion = await resolveVersion(version);
   if (resolvedVersion) {
-    const cacheHit = await restoreVpCache(resolvedVersion);
+    const cacheHit = await restoreVpCache(resolvedVersion, nodeVersion);
     if (cacheHit) {
       ensureVitePlusBinInPath();
       info(`${DISPLAY_NAME} restored from cache`);

src/install-viteplus.ts

@@ -48,7 +48,6 @@ export enum State {
   InstalledVersion = "INSTALLED_VERSION",
   VpCachePrimaryKey = "VP_CACHE_PRIMARY_KEY",
   VpCacheMatchedKey = "VP_CACHE_MATCHED_KEY",
-  VpCacheVersion = "VP_CACHE_VERSION",
 }
 
 // Output keys