fix: preserve portable installer shell compatibility

Author: fengmk2

dist/azure/index.mjs

@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import type { SpawnSyncOptions, SpawnSyncReturns } from "node:child_process";
+import { writeFileSync } from "node:fs";
+import { installVitePlus } from "./install-viteplus.js";
+
+const { spawnSync } = vi.hoisted(() => ({ spawnSync: vi.fn() }));
+vi.mock("node:child_process", () => ({ spawnSync }));
+
+function result(status: number | null, error?: NodeJS.ErrnoException): SpawnSyncReturns<Buffer> {
+  return {
+    pid: 1,
+    output: [],
+    stdout: Buffer.alloc(0),
+    stderr: Buffer.alloc(0),
+    status,
+    signal: null,
+    error,
+  };
+}
+
+const missingCommand = Object.assign(new Error("spawn ENOENT"), { code: "ENOENT" });
+const options = {
+  platform: "win32" as const,
+  sleep: async () => undefined,
+  logWarningFn: () => undefined,
+};
+
+beforeEach(() => {
+  spawnSync.mockReset();
+});
+
+describe("portable installer shell selection", () => {
+  it.each(["0.2.9", "0.3.1"])(
+    "uses Windows PowerShell when pwsh is missing for Vite+ %s",
+    async (version) => {
+      spawnSync.mockImplementation(
+        (command: string, _args: string[], spawnOptions: SpawnSyncOptions) => {
+          if (command === "pwsh") return result(null, missingCommand);
+          if (command !== "powershell.exe") throw new Error(`Unexpected shell: ${command}`);
+          const dirsFile = spawnOptions.env?.SETUP_VP_DIRS_FILE;
+          if (dirsFile) {
+            writeFileSync(
+              dirsFile,
+              "data\t/data\nbin\t/bin\ncache\t/cache\nconfig\t/config\nstate\t/state\n",
+            );
+          }
+          return result(0);
+        },
+      );
+      await installVitePlus(version, { ...options, env: { PATH: "" } });
+
+      expect(spawnSync.mock.calls.map(([command]) => command)).toEqual(["pwsh", "powershell.exe"]);
+      expect(spawnSync.mock.calls[1]!.slice(1)).toEqual(spawnSync.mock.calls[0]!.slice(1));
+    },
+  );
+
+  it("prefers pwsh when it is available", async () => {
+    spawnSync.mockReturnValue(result(0));
+    await installVitePlus("0.2.9", { ...options, env: { PATH: "" } });
+    expect(spawnSync).toHaveBeenCalledTimes(1);
+    expect(spawnSync.mock.calls[0]![0]).toBe("pwsh");
+  });
+
+  it.each([
+    { status: 23, error: undefined, reason: "exit code 23" },
+    {
+      status: null,
+      error: Object.assign(new Error("spawn EACCES"), { code: "EACCES" }),
+      reason: "EACCES",
+    },
+  ])("does not switch shells after $reason", async ({ status, error, reason }) => {
+    spawnSync.mockReturnValue(result(status, error));
+    await expect(installVitePlus("0.2.9", { ...options, env: { PATH: "" } })).rejects.toThrow(
+      reason,
+    );
+    expect(spawnSync).toHaveBeenCalledTimes(8);
+    expect(spawnSync.mock.calls.every(([command]) => command === "pwsh")).toBe(true);
+  });
+
+  it("does not try PowerShell when bash is missing on Unix", async () => {
+    spawnSync.mockReturnValue(result(null, missingCommand));
+    await expect(
+      installVitePlus("0.2.9", { ...options, platform: "linux", env: { PATH: "" } }),
+    ).rejects.toThrow("ENOENT");
+    expect(spawnSync).toHaveBeenCalledTimes(8);
+    expect(spawnSync.mock.calls.every(([command]) => command === "bash")).toBe(true);
+  });
+});

dist/gitlab/index.mjs

@@ -29,10 +29,19 @@ function runInstallCommand(
   platform: NodeJS.Platform = process.platform,
 ): number {
   const { command, args } = getInstallScriptCommand(url, platform, env.VP_VPDIRS_AWARE === "1");
-  const result = spawnSync(command, args, {
+  const spawnOptions = {
     env: { ...process.env, ...env },
-    stdio: "inherit",
-  });
+    stdio: "inherit" as const,
+  };
+  let result = spawnSync(command, args, spawnOptions);
+  // GitLab PowerShell Desktop runners need not have PowerShell Core installed.
+  // Only fall back when the executable is missing, not when an installer fails.
+  if (
+    platform === "win32" &&
+    (result.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT"
+  ) {
+    result = spawnSync("powershell.exe", args, spawnOptions);
+  }
   if (result.error) throw result.error;
   return result.status ?? 1;
 }

dist/index.mjs

@@ -1,4 +1,16 @@
 import { describe, expect, it } from "vite-plus/test";
+import { spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { getInstallScriptCommand, parseVitePlusDirs, supportsVitePlusDirs } from "./vp-dirs.js";
 
 describe("Vite+ directory resolution", () => {
@@ -53,6 +65,90 @@ describe("Vite+ directory resolution", () => {
     expect(command.args[1]).toContain('>> "$SETUP_VP_DIRS_FILE"');
   });
 
+  it.skipIf(process.platform === "win32").each([true, false])(
+    "isolates inherited nounset and preserves installer failures (detectDirs: %s)",
+    (detectDirs) => {
+      const fixture = mkdtempSync(join(tmpdir(), "setup-vp-shell-options-"));
+      const bin = join(fixture, "bin");
+      const installer = join(fixture, "installer.sh");
+      const dirsFile = join(fixture, "dirs");
+      const continued = join(fixture, "continued");
+      mkdirSync(bin);
+      writeFileSync(
+        join(bin, "curl"),
+        `#!/usr/bin/env bash
+if [ "$#" -eq 8 ]; then
+  cp "$SETUP_VP_TEST_INSTALLER" "$8"
+else
+  cat "$SETUP_VP_TEST_INSTALLER"
+fi
+`,
+      );
+      writeFileSync(
+        join(bin, "vp"),
+        `#!/usr/bin/env bash
+if [ "\${VP_DUMP_DIRS:-}" = "1" ]; then
+  printf 'data\\t/data\\nbin\\t/bin\\ncache\\t/cache\\nconfig\\t/config\\nstate\\t/state\\n'
+else
+  printf 'vp v0.3.0\\n'
+fi
+`,
+      );
+      chmodSync(join(bin, "curl"), 0o755);
+      chmodSync(join(bin, "vp"), 0o755);
+      const command = getInstallScriptCommand(
+        "https://example.com/install.sh",
+        "linux",
+        detectDirs,
+      );
+      const runInstaller = () =>
+        spawnSync(command.command, command.args, {
+          encoding: "utf8",
+          env: {
+            ...process.env,
+            PATH: `${bin}:${process.env.PATH}`,
+            SHELLOPTS: "nounset",
+            SETUP_VP_DIRS_FILE: dirsFile,
+            SETUP_VP_TEST_INSTALLER: installer,
+            SETUP_VP_TEST_SHIM_DIR: bin,
+            SETUP_VP_TEST_CONTINUED: continued,
+          },
+        });
+
+      try {
+        writeFileSync(
+          installer,
+          `set -e
+setup_vp_test_optional() { local optional="$4"; }
+setup_vp_test_optional one two three
+SHIM_DIR="$SETUP_VP_TEST_SHIM_DIR"
+printf 'installer completed\\n'
+`,
+        );
+        const success = runInstaller();
+        expect(success.status, success.stderr).toBe(0);
+        expect(success.stderr).toBe("");
+        expect(success.stdout).toContain("installer completed");
+        if (detectDirs) {
+          expect(parseVitePlusDirs(readFileSync(dirsFile, "utf8"))?.bin).toBe("/bin");
+        }
+
+        writeFileSync(installer, "exit 23\n");
+        expect(runInstaller().status).toBe(23);
+        if (detectDirs) {
+          writeFileSync(installer, "return 23\n");
+          expect(runInstaller().status).toBe(23);
+        }
+
+        writeFileSync(installer, 'set -e\nfalse\nprintf continued > "$SETUP_VP_TEST_CONTINUED"\n');
+        expect(runInstaller().status).not.toBe(0);
+        expect(existsSync(continued)).toBe(false);
+      } finally {
+        rmSync(fixture, { recursive: true, force: true });
+      }
+    },
+  );
+
   it("dumps directories from the installer-resolved Windows shim", () => {
     const command = getInstallScriptCommand("https://example.com/install.ps1", "win32");
 
@@ -61,6 +157,8 @@ describe("Vite+ directory resolution", () => {
     expect(command.args[1]).toContain("Join-Path $vpDir 'vp.exe'");
     expect(command.args[1]).toContain("& $vpPath --version");
     expect(command.args[1]).toContain("$env:VP_DUMP_DIRS = '1'");
+    expect(command.args[1]).toContain("Set-Content -LiteralPath $dirsFile -Encoding UTF8");
+    expect(command.args[1]).toContain("Add-Content -LiteralPath $dirsFile -Encoding UTF8");
   });
 
   it.each([

src/ci/install-viteplus.test.ts

@@ -121,7 +121,7 @@ export function getInstallScriptCommand(
 
     const script = `
 $dirsFile = $env:${VP_DIRS_FILE_ENV}
-Set-Content -LiteralPath $dirsFile -Value '' -NoNewline
+Set-Content -LiteralPath $dirsFile -Value '' -NoNewline -Encoding UTF8
 . ([scriptblock]::Create((irm -TimeoutSec ${PWSH_TIMEOUT_SEC} ${url})))
 $vpDir = if ($script:ShimDir) {
   $script:ShimDir
@@ -135,25 +135,29 @@ if (-not (Test-Path -LiteralPath $vpPath)) {
   $vpPath = Join-Path $vpDir 'vp.cmd'
 }
 if (Test-Path -LiteralPath $vpPath) {
-  & $vpPath --version | Set-Content -LiteralPath $dirsFile
+  & $vpPath --version | Set-Content -LiteralPath $dirsFile -Encoding UTF8
   if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
   $env:VP_DUMP_DIRS = '1'
-  & $vpPath | Add-Content -LiteralPath $dirsFile
+  & $vpPath | Add-Content -LiteralPath $dirsFile -Encoding UTF8
   if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
 }
 `.trim();
     return { command: "pwsh", args: ["-Command", script] };
   }
 
+  // Upstream installers read optional positional arguments without defaults.
+  // Do not inherit nounset from a caller that exports SHELLOPTS.
   if (!detectDirs) {
     const script = `
+set +u
 set -o pipefail
 curl -fsSL ${CURL_TIMEOUT_FLAGS} ${url} | bash
 `.trim();
     return { command: "bash", args: ["-c", script] };
   }
 
   const script = `
+set +u
 set -eo pipefail
 installer_file="$(mktemp "\${TMPDIR:-/tmp}/setup-vp-install.XXXXXX")"
 trap 'rm -f "$installer_file"' EXIT

src/ci/install-viteplus.ts

@@ -270,7 +270,7 @@ describe("installVitePlus", () => {
     const [cmd, args] = vi.mocked(exec).mock.calls[0];
     expect(cmd).toBe("bash");
     const script = (args as string[])[1];
-    expect(script).toMatch(/^set -eo pipefail\n/);
+    expect(script).toMatch(/^set \+u\nset -eo pipefail\n/);
     expect(script).toContain("--connect-timeout");
     expect(script).toContain("--max-time");
     expect(script).toContain('-o "$installer_file"');