feat: allow task caching to github

action.yml

@@ -37,6 +37,10 @@ inputs:
     description: "Enable caching of project dependencies"
     required: false
     default: "false"
+  task-cache:
+    description: "Enable task caching via GitHub Actions"
+    required: false
+    default: "false"
   cache-dependency-path:
     description: "Path to lock file for cache key generation. Auto-detected if not specified."
     required: false
@@ -52,6 +56,8 @@ outputs:
     description: "The installed version of Vite+"
   cache-hit:
     description: "Boolean indicating if cache was restored"
+  task-cache-hit:
+    description: "Boolean indicating if task cache was restored"
 
 runs:
   using: node24

src/index.ts

@@ -6,6 +6,8 @@ import { setupSfw } from "./install-sfw.js";
 import { runViteInstall } from "./run-install.js";
 import { restoreCache } from "./cache-restore.js";
 import { saveCache } from "./cache-save.js";
+import { restoreTaskCache } from "./task-cache-restore.js";
+import { saveTaskCache } from "./task-cache-save.js";
 import { State, Outputs } from "./types.js";
 import type { Inputs } from "./types.js";
 import { resolveNodeVersionFile } from "./node-version-file.js";
@@ -53,6 +55,11 @@ async function runMain(inputs: Inputs): Promise<void> {
     await restoreCache(inputs);
   }
 
+  // Step 5.5: Restore task cache if enabled
+  if (inputs.taskCache) {
+    await restoreTaskCache(inputs);
+  }
+
   // Step 6: Install Socket Firewall Free if requested (must run before vp install).
   // setupSfw centralizes all the decision branches: run-install disabled, sfw
   // already on PATH (e.g. via socketdev/action@<sha>), supported platform
@@ -88,6 +95,9 @@ async function runPost(inputs: Inputs): Promise<void> {
   if (inputs.cache) {
     await saveCache();
   }
+  if (inputs.taskCache) {
+    await saveTaskCache();
+  }
 }
 
 async function main(): Promise<void> {

src/inputs.ts

@@ -28,6 +28,7 @@ export function getInputs(): Inputs {
     sfw: getBooleanInput("sfw"),
     cache: getBooleanInput("cache"),
     cacheDependencyPath: getInput("cache-dependency-path") || undefined,
+    taskCache: getBooleanInput("task-cache"),
     registryUrl: getInput("registry-url") || undefined,
     scope: getInput("scope") || undefined,
   };

src/install-sfw.test.ts

@@ -144,6 +144,7 @@ function makeInputs(overrides: Partial<Inputs> = {}): Inputs {
     sfw: true,
     cache: false,
     cacheDependencyPath: undefined,
+    taskCache: false,
     registryUrl: undefined,
     scope: undefined,
     ...overrides,

src/install-viteplus.test.ts

@@ -27,6 +27,7 @@ const baseInputs: Inputs = {
   sfw: false,
   cache: false,
   cacheDependencyPath: undefined,
+  taskCache: false,
   registryUrl: undefined,
   scope: undefined,
 };

src/task-cache-restore.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vite-plus/test";
+
+// Mock external dependencies before importing the module
+vi.mock("@actions/cache", () => ({
+  restoreCache: vi.fn(),
+}));
+vi.mock("@actions/core", () => ({
+  warning: vi.fn(),
+  info: vi.fn(),
+  debug: vi.fn(),
+  saveState: vi.fn(),
+  setOutput: vi.fn(),
+}));
+vi.mock("./utils.js", () => ({
+  getConfiguredProjectDir: vi.fn(() => "/workspace"),
+}));
+
+import { restoreCache as restoreCacheAction } from "@actions/cache";
+import { warning, info, saveState, setOutput } from "@actions/core";
+import { restoreTaskCache } from "./task-cache-restore.js";
+import { State, Outputs } from "./types.js";
+import type { Inputs } from "./types.js";
+
+const mockedRestoreCacheAction = vi.mocked(restoreCacheAction);
+const mockedWarning = vi.mocked(warning);
+const mockedInfo = vi.mocked(info);
+const mockedSaveState = vi.mocked(saveState);
+const mockedSetOutput = vi.mocked(setOutput);
+
+const baseInputs: Inputs = {
+  version: "latest",
+  nodeVersion: undefined,
+  nodeVersionFile: undefined,
+  workingDirectory: undefined,
+  runInstall: [],
+  sfw: false,
+  cache: false,
+  cacheDependencyPath: undefined,
+  taskCache: true,
+  registryUrl: undefined,
+  scope: undefined,
+};
+
+describe("restoreTaskCache", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it("restores task cache with correct key pattern", async () => {
+    process.env.RUNNER_OS = "Linux";
+    process.env.GITHUB_RUN_ID = "12345";
+    process.env.GITHUB_RUN_ATTEMPT = "1";
+
+    mockedRestoreCacheAction.mockResolvedValue("vite-task-Linux-x64-12345-1");
+
+    await restoreTaskCache(baseInputs);
+
+    expect(mockedRestoreCacheAction).toHaveBeenCalledWith(
+      expect.arrayContaining([expect.stringContaining("node_modules")]),
+      "vite-task-Linux-x64-12345-1",
+      ["vite-task-Linux-x64-"],
+    );
+
+    expect(mockedSaveState).toHaveBeenCalledWith(
+      State.TaskCachePrimaryKey,
+      "vite-task-Linux-x64-12345-1",
+    );
+    expect(mockedSaveState).toHaveBeenCalledWith(
+      State.TaskCacheMatchedKey,
+      "vite-task-Linux-x64-12345-1",
+    );
+    expect(mockedSetOutput).toHaveBeenCalledWith(Outputs.TaskCacheHit, true);
+    expect(mockedInfo).toHaveBeenCalledWith(expect.stringContaining("Task cache restored"));
+  });
+
+  it("sets cache-hit to false when cache is not found", async () => {
+    process.env.RUNNER_OS = "Linux";
+    process.env.GITHUB_RUN_ID = "12345";
+    process.env.GITHUB_RUN_ATTEMPT = "1";
+
+    mockedRestoreCacheAction.mockResolvedValue(undefined);
+
+    await restoreTaskCache(baseInputs);
+
+    expect(mockedSetOutput).toHaveBeenCalledWith(Outputs.TaskCacheHit, false);
+    expect(mockedInfo).toHaveBeenCalledWith("Task cache not found");
+  });
+
+  it("warns and skips when GITHUB_RUN_ID is missing", async () => {
+    process.env.RUNNER_OS = "Linux";
+    process.env.GITHUB_RUN_ATTEMPT = "1";
+    delete process.env.GITHUB_RUN_ID;
+
+    await restoreTaskCache(baseInputs);
+
+    expect(mockedWarning).toHaveBeenCalledWith(
+      expect.stringContaining("GitHub run ID or attempt not found"),
+    );
+    expect(mockedSetOutput).toHaveBeenCalledWith(Outputs.TaskCacheHit, false);
+    expect(mockedRestoreCacheAction).not.toHaveBeenCalled();
+  });
+
+  it("warns and skips when GITHUB_RUN_ATTEMPT is missing", async () => {
+    process.env.RUNNER_OS = "Linux";
+    process.env.GITHUB_RUN_ID = "12345";
+    delete process.env.GITHUB_RUN_ATTEMPT;
+
+    await restoreTaskCache(baseInputs);
+
+    expect(mockedWarning).toHaveBeenCalledWith(
+      expect.stringContaining("GitHub run ID or attempt not found"),
+    );
+    expect(mockedSetOutput).toHaveBeenCalledWith(Outputs.TaskCacheHit, false);
+    expect(mockedRestoreCacheAction).not.toHaveBeenCalled();
+  });
+
+  it("uses correct cache path relative to project directory", async () => {
+    process.env.RUNNER_OS = "Windows";
+    process.env.GITHUB_RUN_ID = "67890";
+    process.env.GITHUB_RUN_ATTEMPT = "2";
+
+    mockedRestoreCacheAction.mockResolvedValue(undefined);
+
+    await restoreTaskCache(baseInputs);
+
+    const cachePathsCall = mockedSaveState.mock.calls.find(([key]) => key === State.TaskCachePaths);
+    expect(cachePathsCall).toBeDefined();
+    if (cachePathsCall) {
+      const paths = JSON.parse(cachePathsCall[1] as string);
+      expect(paths[0]).toMatch(/node_modules/);
+      expect(paths[0]).toMatch(/task-cache/);
+    }
+  });
+
+  it("handles different OS and architecture combinations", async () => {
+    process.env.RUNNER_OS = "macOS";
+    process.env.GITHUB_RUN_ID = "11111";
+    process.env.GITHUB_RUN_ATTEMPT = "3";
+
+    // Mock process.arch
+    const originalArch = process.arch;
+    Object.defineProperty(process, "arch", {
+      value: "arm64",
+      configurable: true,
+    });
+
+    mockedRestoreCacheAction.mockResolvedValue(undefined);
+
+    await restoreTaskCache(baseInputs);
+
+    expect(mockedSaveState).toHaveBeenCalledWith(
+      State.TaskCachePrimaryKey,
+      "vite-task-macOS-arm64-11111-3",
+    );
+
+    // Restore original arch
+    Object.defineProperty(process, "arch", {
+      value: originalArch,
+      configurable: true,
+    });
+  });
+
+  it("saves cache paths as JSON string", async () => {
+    process.env.RUNNER_OS = "Linux";
+    process.env.GITHUB_RUN_ID = "12345";
+    process.env.GITHUB_RUN_ATTEMPT = "1";
+
+    mockedRestoreCacheAction.mockResolvedValue(undefined);
+
+    await restoreTaskCache(baseInputs);
+
+    expect(mockedSaveState).toHaveBeenCalledWith(
+      State.TaskCachePaths,
+      expect.stringMatching(/^\[.*\]$/),
+    );
+
+    const cachePathsCall = mockedSaveState.mock.calls.find(([key]) => key === State.TaskCachePaths);
+    if (cachePathsCall) {
+      const paths = JSON.parse(cachePathsCall[1] as string);
+      expect(Array.isArray(paths)).toBe(true);
+      expect(paths.length).toBeGreaterThan(0);
+    }
+  });
+});

src/task-cache-restore.ts

@@ -0,0 +1,52 @@
+import { restoreCache as restoreCacheAction } from "@actions/cache";
+import { warning, info, debug, saveState, setOutput } from "@actions/core";
+import { arch, platform } from "node:os";
+import { resolve } from "node:path";
+import type { Inputs } from "./types.js";
+import { State, Outputs } from "./types.js";
+import { getConfiguredProjectDir } from "./utils.js";
+
+export async function restoreTaskCache(inputs: Inputs): Promise<void> {
+  const projectDir = getConfiguredProjectDir(inputs);
+
+  // Task cache path is fixed: node_modules/.vite/task-cache
+  const taskCachePath = resolve(projectDir, "node_modules", ".vite", "task-cache");
+  const cachePaths = [taskCachePath];
+
+  debug(`Task cache path: ${taskCachePath}`);
+  saveState(State.TaskCachePaths, JSON.stringify(cachePaths));
+
+  // Generate cache key: vite-task-{runner.os}-{runner.arch}-{run_id}-{run_attempt}
+  const runnerOS = process.env.RUNNER_OS || platform();
+  const runnerArch = arch();
+  const runId = process.env.GITHUB_RUN_ID;
+  const runAttempt = process.env.GITHUB_RUN_ATTEMPT;
+
+  if (!runId || !runAttempt) {
+    warning(
+      `GitHub run ID or attempt not found. Task cache requires GITHUB_RUN_ID and GITHUB_RUN_ATTEMPT. Skipping task cache restore.`,
+    );
+    setOutput(Outputs.TaskCacheHit, false);
+    return;
+  }
+
+  const primaryKey = `vite-task-${runnerOS}-${runnerArch}-${runId}-${runAttempt}`;
+  const restoreKeys = [`vite-task-${runnerOS}-${runnerArch}-`];
+
+  debug(`Task cache primary key: ${primaryKey}`);
+  debug(`Task cache restore keys: ${restoreKeys.join(", ")}`);
+
+  saveState(State.TaskCachePrimaryKey, primaryKey);
+
+  // Attempt to restore cache
+  const matchedKey = await restoreCacheAction(cachePaths, primaryKey, restoreKeys);
+
+  if (matchedKey) {
+    info(`Task cache restored from key: ${matchedKey}`);
+    saveState(State.TaskCacheMatchedKey, matchedKey);
+    setOutput(Outputs.TaskCacheHit, true);
+  } else {
+    info("Task cache not found");
+    setOutput(Outputs.TaskCacheHit, false);
+  }
+}