feat: retry Vite+ install on transient network failures (#47)

## Summary
- Wrap the Vite+ install command (`curl | bash` on \*nix, `irm` on
Windows) in a retry loop — 3 attempts with 2s/4s backoff — so transient
network failures like `curl: (6) Could not resolve host: viteplus.dev`
no longer fail the action on the first try.
- Switch to `ignoreReturnCode: true` and catch thrown exec errors too,
so both non-zero exits and spawn failures are retryable.
- Emit a `warning()` between attempts with the failure reason and
attempt counter; final error reports "after 3 attempts".

## Test plan
- [x] `vp run test` — 97 passed (4 new cases in
`src/install-viteplus.test.ts` covering first-try success,
retry-then-success, exhaustion, and thrown exec errors)
- [x] `vp run check:fix` clean
- [x] `vp run build` — `dist/index.mjs` refreshed
- [ ] Observe a real CI run with the new action reference

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Low risk: adds a bounded retry/backoff loop around the installer
command; main behavior change is potentially longer runtime and slightly
different failure messaging when installs consistently fail.
> 
> **Overview**
> Makes `installVitePlus` resilient to transient network/process
failures by retrying the Vite+ install command up to 3 times with linear
backoff, treating both non-zero exit codes and thrown `exec` errors as
retryable.
> 
> Adds warnings between attempts with the failure reason and improves
the final error to include the attempt count; includes new unit tests
covering success, retry-then-success, retry exhaustion, and thrown
`exec` errors.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
6903c25. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: fengmk2

dist/index.mjs

@@ -0,0 +1,71 @@
+import { describe, it, expect, afterEach, vi } from "vite-plus/test";
+import { exec } from "@actions/exec";
+import { warning } from "@actions/core";
+import { installVitePlus } from "./install-viteplus.js";
+import type { Inputs } from "./types.js";
+
+vi.mock("@actions/core", () => ({
+  info: vi.fn(),
+  warning: vi.fn(),
+  addPath: vi.fn(),
+}));
+
+vi.mock("@actions/exec", () => ({
+  exec: vi.fn(),
+}));
+
+vi.mock("node:timers/promises", () => ({
+  setTimeout: vi.fn().mockResolvedValue(undefined),
+}));
+
+const baseInputs: Inputs = {
+  version: "latest",
+  nodeVersion: undefined,
+  nodeVersionFile: undefined,
+  workingDirectory: undefined,
+  runInstall: [],
+  cache: false,
+  cacheDependencyPath: undefined,
+  registryUrl: undefined,
+  scope: undefined,
+};
+
+describe("installVitePlus", () => {
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should succeed on first attempt without retrying", async () => {
+    vi.mocked(exec).mockResolvedValueOnce(0);
+
+    await installVitePlus(baseInputs);
+
+    expect(exec).toHaveBeenCalledTimes(1);
+    expect(warning).not.toHaveBeenCalled();
+  });
+
+  it("should retry on transient failure and eventually succeed", async () => {
+    vi.mocked(exec).mockResolvedValueOnce(6).mockResolvedValueOnce(6).mockResolvedValueOnce(0);
+
+    await installVitePlus(baseInputs);
+
+    expect(exec).toHaveBeenCalledTimes(3);
+    expect(warning).toHaveBeenCalledTimes(2);
+  });
+
+  it("should throw after exhausting all retries", async () => {
+    vi.mocked(exec).mockResolvedValue(6);
+
+    await expect(installVitePlus(baseInputs)).rejects.toThrow(/after 3 attempts/);
+    expect(exec).toHaveBeenCalledTimes(3);
+  });
+
+  it("should retry when exec itself throws (e.g. process spawn error)", async () => {
+    vi.mocked(exec).mockRejectedValueOnce(new Error("spawn bash ENOENT")).mockResolvedValueOnce(0);
+
+    await installVitePlus(baseInputs);
+
+    expect(exec).toHaveBeenCalledTimes(2);
+    expect(warning).toHaveBeenCalledTimes(1);
+  });
+});

src/install-viteplus.test.ts

@@ -1,12 +1,15 @@
-import { info, addPath } from "@actions/core";
+import { info, warning, addPath } from "@actions/core";
 import { exec } from "@actions/exec";
 import { join } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
 import type { Inputs } from "./types.js";
 import { DISPLAY_NAME } from "./types.js";
 import { getVitePlusHome } from "./utils.js";
 
 const INSTALL_URL_SH = "https://viteplus.dev/install.sh";
 const INSTALL_URL_PS1 = "https://viteplus.dev/install.ps1";
+const INSTALL_MAX_ATTEMPTS = 3;
+const INSTALL_RETRY_DELAY_MS = 2000;
 
 export async function installVitePlus(inputs: Inputs): Promise<void> {
   const { version } = inputs;
@@ -15,24 +18,49 @@ export async function installVitePlus(inputs: Inputs): Promise<void> {
 
   // TODO: Remove VITE_PLUS_VERSION once vite-plus versions before the VP_* env var
   // rename (see https://github.com/voidzero-dev/vite-plus/pull/1166) are no longer supported.
-  const env = { ...process.env, VP_VERSION: version, VITE_PLUS_VERSION: version };
-  let exitCode: number;
+  const env = {
+    ...process.env,
+    VP_VERSION: version,
+    VITE_PLUS_VERSION: version,
+  } as { [key: string]: string };
 
+  let failureReason = "";
+  for (let attempt = 1; attempt <= INSTALL_MAX_ATTEMPTS; attempt++) {
+    try {
+      const exitCode = await runInstallCommand(env);
+      if (exitCode === 0) {
+        ensureVitePlusBinInPath();
+        return;
+      }
+      failureReason = `exit code ${exitCode}`;
+    } catch (error) {
+      failureReason = error instanceof Error ? error.message : String(error);
+    }
+
+    if (attempt < INSTALL_MAX_ATTEMPTS) {
+      const delay = INSTALL_RETRY_DELAY_MS * attempt;
+      warning(
+        `Failed to install ${DISPLAY_NAME} (${failureReason}). Retrying in ${delay}ms... (attempt ${attempt + 1}/${INSTALL_MAX_ATTEMPTS})`,
+      );
+      await sleep(delay);
+    }
+  }
+
+  throw new Error(
+    `Failed to install ${DISPLAY_NAME} after ${INSTALL_MAX_ATTEMPTS} attempts: ${failureReason}`,
+  );
+}
+
+async function runInstallCommand(env: { [key: string]: string }): Promise<number> {
+  const options = { env, ignoreReturnCode: true };
   if (process.platform === "win32") {
-    exitCode = await exec(
+    return exec(
       "pwsh",
       ["-Command", `& ([scriptblock]::Create((irm ${INSTALL_URL_PS1})))`],
-      { env },
+      options,
     );
-  } else {
-    exitCode = await exec("bash", ["-c", `curl -fsSL ${INSTALL_URL_SH} | bash`], { env });
-  }
-
-  if (exitCode !== 0) {
-    throw new Error(`Failed to install ${DISPLAY_NAME}. Exit code: ${exitCode}`);
   }
-
-  ensureVitePlusBinInPath();
+  return exec("bash", ["-c", `curl -fsSL ${INSTALL_URL_SH} | bash`], options);
 }
 
 function ensureVitePlusBinInPath(): void {