pwvm 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Millan Kaul
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# pwvm
+
+### **Playwright Version Manager**
+
+A simple *Playwright Version Manager* that solves a common pain point:
+
+> Uncontrolled Playwright upgrades and breaking changes disrupt local setups and CI pipelines.
+
+`pwvm` lets you install, manage, and switch Playwright versions reliably — **one command, predictable behavior**, just like `nvm` for Node.js.
+
+---
+
+## Why pwvm
+
+Playwright evolves fast. That’s great — until a minor upgrade breaks tests you didn’t plan to touch.
+
+`pwvm` keeps Playwright versions:
+
+* isolated per version
+* explicit and reproducible
+* easy to switch locally and in CI
+
+You upgrade **when you choose**, not when your tooling surprises you.
+
+---
+
+## Install
+
+```sh
+npm install -g pwvm
+```
+
+Then run the one-time setup:
+
+```sh
+pwvm setup
+```
+
+Follow the printed instructions to add pwvm shims to your `PATH`.
+
+---
+
+## Common usage
+
+```sh
+pwvm install 1.53.0
+pwvm use 1.53.0
+playwright test
+```
+
+Pin versions per project with `.pwvmrc`:
+
+```text
+1.53.0
+```
+
+---
+
+## CI-friendly
+
+`pwvm` works in GitHub Actions, Azure Pipelines, Bitbucket, and any CI where you control `PATH`.
+
+Install → setup → select version → run Playwright.
+
+---
+
+## Support pwvm
+
+`pwvm` is built and maintained independently to fix a problem many teams quietly struggle with.
+
+If this tool saves you time, CI hours, or debugging frustration:
+
+* ⭐ [Star the project](https://github.com/eaccmk/pwvm)
+* ❤️ [Sponsor via GitHub](https://github.com/sponsors/eaccmk)
+* 🔁 Share it with your team
+
+Your support helps keep pwvm maintained and improving.
+
+---
+
+📘 Full documentation and contributing guide: [https://github.com/eaccmk/pwvm](https://github.com/eaccmk/pwvm)

package/dist/commands/current.js

@@ -0,0 +1,42 @@
+import fs from "fs-extra";
+import { resolveRcPath } from "../core/paths.js";
+import { getResolvedActiveVersion, } from "../core/versions.js";
+import { createLogger, formatError } from "../utils/logger.js";
+export const runCurrentCommand = async (deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    const getActive = deps.getActive ?? getResolvedActiveVersion;
+    const resolveRc = deps.resolveRc ?? deps.activeOptions?.resolveRc ?? resolveRcPath;
+    const fsImpl = deps.fs ?? deps.activeOptions?.fs ?? fs;
+    try {
+        const currentVersion = await getActive(deps.activeOptions);
+        if (!currentVersion) {
+            logger.warn("No active Playwright version. Run `pwvm use <version>`.");
+            process.exitCode = 1;
+            return;
+        }
+        let suffix = "";
+        try {
+            const rcPath = resolveRc({
+                startDir: deps.activeOptions?.rcStartDir,
+                rcFileName: deps.activeOptions?.rcFileName,
+                fs: fsImpl,
+            });
+            if (rcPath) {
+                const contents = await fsImpl.readFile(rcPath, "utf8");
+                const trimmed = contents.trim();
+                if (trimmed.length > 0 && trimmed === currentVersion) {
+                    suffix = " (from .pwvmrc)";
+                }
+            }
+        }
+        catch {
+            suffix = "";
+        }
+        logger.info(`${currentVersion}${suffix}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(formatError(`Failed to read current version: ${message}`, "Run `pwvm use <version>` to set one."));
+        process.exitCode = 1;
+    }
+};

package/dist/commands/doctor.js

@@ -0,0 +1,95 @@
+import fs from "fs-extra";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { getPwvmDir, getShimsDir } from "../core/paths.js";
+import { createLogger } from "../utils/logger.js";
+const readVersion = () => {
+    try {
+        const entry = process.argv[1];
+        if (!entry) {
+            return "unknown";
+        }
+        const rootDir = path.resolve(path.dirname(entry), "..");
+        const pkgPath = path.join(rootDir, "package.json");
+        const contents = readFileSync(pkgPath, "utf8");
+        const parsed = JSON.parse(contents);
+        return typeof parsed.version === "string" ? parsed.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+};
+export const runDoctorCommand = async (deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    const fsImpl = deps.fs ?? fs;
+    const pwvmDir = getPwvmDir();
+    const shimsDir = deps.shimsDir ?? getShimsDir();
+    const envPath = deps.envPath ?? process.env.PATH ?? "";
+    const shimPath = path.join(shimsDir, "playwright");
+    const useColor = process.stdout.isTTY === true;
+    const withScope = (message) => message.startsWith(" ") ? `pwvm-doctor${message}` : `pwvm-doctor ${message}`;
+    const logInfo = (message) => logger.info(withScope(message));
+    const logWarn = (message) => logger.warn(withScope(message));
+    const colorize = (symbol) => {
+        const value = symbol === "check" ? "✔" : "✖";
+        if (!useColor) {
+            return value;
+        }
+        const color = symbol === "check" ? "\x1b[32m" : "\x1b[31m";
+        const reset = "\x1b[39m";
+        return `${color}${value}${reset}`;
+    };
+    let shimsDirExists = false;
+    let shimExists = false;
+    let pwvmDirExists = false;
+    try {
+        pwvmDirExists = await fsImpl.pathExists(pwvmDir);
+    }
+    catch {
+        pwvmDirExists = false;
+    }
+    try {
+        shimsDirExists = await fsImpl.pathExists(shimsDir);
+    }
+    catch {
+        shimsDirExists = false;
+    }
+    try {
+        shimExists = await fsImpl.pathExists(shimPath);
+    }
+    catch {
+        shimExists = false;
+    }
+    const pathEntries = envPath.split(path.delimiter).filter(Boolean);
+    const pathHasShims = pathEntries.includes(shimsDir);
+    logInfo(`pwvm Doctor v.${readVersion()}`);
+    logInfo("### Diagnostic for required components ###");
+    if (pwvmDirExists) {
+        logInfo(`  ${colorize("check")} pwvm home directory exists`);
+    }
+    else {
+        logWarn(`  ${colorize("cross")} pwvm home directory exists`);
+    }
+    if (shimsDirExists) {
+        logInfo(`  ${colorize("check")} shims directory exists`);
+    }
+    else {
+        logWarn(`  ${colorize("cross")} shims directory exists`);
+    }
+    if (shimExists) {
+        logInfo(`  ${colorize("check")} playwright shim found`);
+    }
+    else {
+        logWarn(`  ${colorize("cross")} playwright shim found`);
+    }
+    if (pathHasShims) {
+        logInfo(`  ${colorize("check")} shims directory is in PATH`);
+    }
+    else {
+        logWarn(`  ${colorize("cross")} shims directory is not in PATH`);
+    }
+    logInfo("### Suggested fixes ###");
+    if (!pathHasShims) {
+        logInfo('  export PATH="$HOME/.pwvm/shims:$PATH"');
+    }
+};

package/dist/commands/install.js

@@ -0,0 +1,121 @@
+import { installPlaywrightVersion, } from "../core/install.js";
+import { createLogger } from "../utils/logger.js";
+import { createProgress } from "../utils/progress.js";
+import { fetchPackageMetadata } from "../utils/registry.js";
+export const runInstallCommand = async (version, options = {}, deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    const install = deps.install ?? installPlaywrightVersion;
+    const progress = createProgress({ label: "Installing Playwright", logger });
+    const resolvedVersion = await resolveLatestVersion(version, logger);
+    if (!resolvedVersion) {
+        process.exitCode = 1;
+        return;
+    }
+    let withBrowsers = options.browsers !== false;
+    if (options.withBrowsers) {
+        withBrowsers = true;
+    }
+    try {
+        if (resolvedVersion !== version) {
+            logger.info(`Resolved latest Playwright version to ${resolvedVersion}`);
+        }
+        logger.info(`Installing Playwright ${resolvedVersion}`);
+        if (withBrowsers) {
+            logger.info("Installing Playwright browsers");
+        }
+        else {
+            logger.info("Skipping Playwright browser install");
+        }
+        progress.start();
+        const result = await install(resolvedVersion, {
+            ...deps.installOptions,
+            withBrowsers,
+        });
+        progress.succeed();
+        if (!result.packageInstalled && !result.browsersInstalled) {
+            if (result.packageAlreadyInstalled && result.browsersAlreadyInstalled) {
+                logger.info(`Playwright ${version} is already installed (browsers already installed)`);
+            }
+            else {
+                logger.info(`Playwright ${version} is already installed`);
+            }
+            return;
+        }
+        if (!result.packageInstalled && result.browsersInstalled) {
+            logger.info(`🎉 Installed Playwright browsers for ${resolvedVersion}`);
+            return;
+        }
+        const suffix = result.browsersInstalled ? " (browsers installed)" : "";
+        logger.info(`🎉 Installed Playwright ${resolvedVersion}${suffix}`);
+    }
+    catch (error) {
+        progress.fail();
+        const message = error instanceof Error ? error.message : String(error);
+        const code = getErrorCode(error);
+        if (isInvalidVersionError(code, message)) {
+            logger.error(`[ERROR]: Unable to install Playwright ${resolvedVersion}. The version does not exist.`);
+            logger.info("Available versions are published at https://github.com/microsoft/playwright/releases");
+        }
+        else if (isNetworkError(code, message)) {
+            logger.error("[ERROR]: Unable to install Playwright due to a network or registry issue.");
+            logger.info("Please check your internet connection and try again.");
+        }
+        else {
+            logger.error(`[ERROR]: Unable to install Playwright ${resolvedVersion}.`);
+            logger.info("Please try again or verify the version number.");
+        }
+        process.exitCode = 1;
+    }
+};
+const getErrorCode = (error) => {
+    if (typeof error !== "object" || error === null) {
+        return undefined;
+    }
+    if ("code" in error && typeof error.code === "string") {
+        return error.code;
+    }
+    return undefined;
+};
+const isInvalidVersionError = (code, message) => {
+    const text = message.toLowerCase();
+    if (code === "ETARGET" || code === "notarget") {
+        return true;
+    }
+    return (text.includes("etarget") ||
+        text.includes("notarget") ||
+        text.includes("no matching version") ||
+        text.includes("version not found"));
+};
+const isNetworkError = (code, message) => {
+    const text = message.toLowerCase();
+    if (code === "ECONNRESET" ||
+        code === "ENOTFOUND" ||
+        code === "ECONNREFUSED" ||
+        code === "ETIMEDOUT" ||
+        code === "EAI_AGAIN") {
+        return true;
+    }
+    return (text.includes("network") ||
+        text.includes("fetch failed") ||
+        text.includes("getaddrinfo") ||
+        text.includes("econnreset") ||
+        text.includes("enotfound"));
+};
+const resolveLatestVersion = async (version, logger) => {
+    if (version !== "latest") {
+        return version;
+    }
+    try {
+        const metadata = await fetchPackageMetadata("playwright");
+        const latest = metadata["dist-tags"]?.latest;
+        if (!latest) {
+            throw new Error("Missing latest tag.");
+        }
+        return latest;
+    }
+    catch {
+        logger.error("[ERROR]: Unable to reach npm registry.");
+        logger.info("Please check your internet connection and try again.");
+        return null;
+    }
+};

package/dist/commands/install.test.js

@@ -0,0 +1,106 @@
+import * as semver from "semver";
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+import { runInstallCommand } from "./install.js";
+import { fetchPackageMetadata } from "../utils/registry.js";
+import { createProgress } from "../utils/progress.js";
+vi.mock("../utils/registry.js", () => ({
+    fetchPackageMetadata: vi.fn(),
+}));
+vi.mock("../utils/progress.js", () => ({
+    createProgress: vi.fn(),
+}));
+describe("runInstallCommand", () => {
+    const originalExitCode = process.exitCode;
+    const originalIsTTY = process.stdout.isTTY;
+    let errorSpy;
+    let logSpy;
+    beforeEach(() => {
+        process.exitCode = 0;
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: false,
+            configurable: true,
+        });
+        errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        logSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        vi.mocked(createProgress).mockReturnValue({
+            start: vi.fn(),
+            succeed: vi.fn(),
+            fail: vi.fn(),
+        });
+    });
+    afterEach(() => {
+        process.exitCode = originalExitCode;
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: originalIsTTY,
+            configurable: true,
+        });
+        errorSpy.mockRestore();
+        logSpy.mockRestore();
+        vi.mocked(fetchPackageMetadata).mockReset();
+        vi.mocked(createProgress).mockReset();
+    });
+    it("resolves latest to a semver and installs with browsers by default", async () => {
+        const installMock = vi.fn(async () => ({
+            packageInstalled: true,
+            browsersInstalled: true,
+            packageAlreadyInstalled: false,
+            browsersAlreadyInstalled: false,
+        }));
+        vi.mocked(fetchPackageMetadata).mockResolvedValue({
+            "dist-tags": { latest: "1.42.0" },
+        });
+        await runInstallCommand("latest", {}, { install: installMock });
+        expect(installMock).toHaveBeenCalledTimes(1);
+        const [resolvedVersion, options] = installMock.mock.calls[0];
+        expect(semver.valid(resolvedVersion)).toBe(resolvedVersion);
+        expect(resolvedVersion).toBe("1.42.0");
+        expect(options).toEqual(expect.objectContaining({ withBrowsers: true }));
+    });
+    it("logs an error and exits when install fails for invalid version", async () => {
+        const installMock = vi.fn(async () => {
+            const error = Object.assign(new Error("npm ERR! code ETARGET"), {
+                code: "ETARGET",
+            });
+            throw error;
+        });
+        await runInstallCommand("1.9999.99999", {}, { install: installMock });
+        expect(process.exitCode).toBe(1);
+        expect(errorSpy).toHaveBeenCalled();
+        const combinedErrors = errorSpy.mock.calls
+            .map(([message]) => String(message))
+            .join("\n");
+        expect(combinedErrors).toContain("[ERROR]:");
+        expect(combinedErrors).toContain("Unable to install Playwright");
+        expect(combinedErrors).not.toContain("npm ERR");
+    });
+    it("installs browsers by default", async () => {
+        const installMock = vi.fn(async () => ({
+            packageInstalled: true,
+            browsersInstalled: true,
+            packageAlreadyInstalled: false,
+            browsersAlreadyInstalled: false,
+        }));
+        await runInstallCommand("1.2.3", {}, { install: installMock });
+        expect(installMock).toHaveBeenCalledWith("1.2.3", expect.objectContaining({ withBrowsers: true }));
+    });
+    it("respects --no-browsers", async () => {
+        const installMock = vi.fn(async () => ({
+            packageInstalled: true,
+            browsersInstalled: false,
+            packageAlreadyInstalled: false,
+            browsersAlreadyInstalled: false,
+        }));
+        await runInstallCommand("1.2.3", { browsers: false }, { install: installMock });
+        expect(installMock).toHaveBeenCalledWith("1.2.3", expect.objectContaining({ withBrowsers: false }));
+    });
+    it("accepts --with-browsers", async () => {
+        const installMock = vi.fn(async () => ({
+            packageInstalled: true,
+            browsersInstalled: true,
+            packageAlreadyInstalled: false,
+            browsersAlreadyInstalled: false,
+        }));
+        await runInstallCommand("1.2.3", { browsers: false, withBrowsers: true }, { install: installMock });
+        expect(installMock).toHaveBeenCalledWith("1.2.3", expect.objectContaining({ withBrowsers: true }));
+    });
+});

package/dist/commands/list.js

@@ -0,0 +1,30 @@
+import { getInstalledVersions, getResolvedActiveVersion, } from "../core/versions.js";
+import { createLogger, formatError } from "../utils/logger.js";
+export const runListCommand = async (deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    const getInstalled = deps.getInstalled ?? getInstalledVersions;
+    const getActive = deps.getActive ?? getResolvedActiveVersion;
+    try {
+        const [versions, currentVersion] = await Promise.all([
+            getInstalled(deps.installedOptions),
+            getActive(deps.activeOptions),
+        ]);
+        if (versions.length === 0) {
+            logger.info("No Playwright versions installed");
+            return;
+        }
+        for (const version of versions) {
+            if (version === currentVersion) {
+                logger.info(`* ${version}`);
+            }
+            else {
+                logger.info(`  ${version}`);
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(formatError(`Failed to list versions: ${message}`, "Try again or run `pwvm install <version>` to add one."));
+        process.exitCode = 1;
+    }
+};

package/dist/commands/listRemote.js

@@ -0,0 +1,20 @@
+import semver from "semver";
+import { createLogger } from "../utils/logger.js";
+import { fetchPackageMetadata } from "../utils/registry.js";
+export const runListRemoteCommand = async (deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    try {
+        const metadata = await fetchPackageMetadata("playwright");
+        const versions = Object.keys(metadata.versions ?? {}).filter((version) => semver.valid(version) !== null);
+        versions.sort((a, b) => semver.rcompare(a, b));
+        logger.info("Available Playwright versions:");
+        for (const version of versions) {
+            logger.info(version);
+        }
+    }
+    catch {
+        logger.error("[ERROR]: Unable to reach npm registry.");
+        logger.info("Please check your internet connection and try again.");
+        process.exitCode = 1;
+    }
+};

package/dist/commands/prune.js

@@ -0,0 +1,22 @@
+import { pruneVersions } from "../core/prune.js";
+import { createLogger, formatError } from "../utils/logger.js";
+export const runPruneCommand = async (deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    const prune = deps.prune ?? pruneVersions;
+    try {
+        const removed = await prune(deps.pruneOptions);
+        if (removed.length === 0) {
+            logger.info("Nothing to prune");
+            return;
+        }
+        logger.info("Removed Playwright versions:");
+        for (const version of removed) {
+            logger.info(`- ${version}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(formatError(`Failed to prune versions: ${message}`, "Run `pwvm list` to review installed versions."));
+        process.exitCode = 1;
+    }
+};

package/dist/commands/setup.js

@@ -0,0 +1,38 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { getPwvmDir, getShimsDir } from "../core/paths.js";
+import { unixShim, windowsShim } from "../core/shimTemplates.js";
+import { createLogger, formatError } from "../utils/logger.js";
+const buildPathInstructions = (shimsDir) => [
+    "",
+    "==> Next step:",
+    "- Run this command in your local terminal or add it to your CI pipeline:",
+    "",
+    `export PATH="${shimsDir}:$PATH"`,
+    ""
+];
+export const runSetupCommand = async (deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    const fsImpl = deps.fs ?? fs;
+    const pwvmDir = getPwvmDir();
+    const shimsDir = deps.shimsDir ?? getShimsDir();
+    const pwvmBinPath = deps.pwvmBinPath ?? process.argv[1];
+    try {
+        await fsImpl.ensureDir(shimsDir);
+        const unixShimPath = path.join(shimsDir, "playwright");
+        const windowsShimPath = path.join(shimsDir, "playwright.cmd");
+        await fsImpl.writeFile(unixShimPath, unixShim(pwvmBinPath), "utf8");
+        await fsImpl.writeFile(windowsShimPath, windowsShim(pwvmBinPath), "utf8");
+        await fsImpl.chmod(unixShimPath, 0o755);
+        await fsImpl.ensureDir(pwvmDir);
+        await fsImpl.writeFile(path.join(pwvmDir, "setup-complete"), "ok\n", "utf8");
+        for (const line of buildPathInstructions(shimsDir)) {
+            logger.info(line);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(formatError(`Setup failed: ${message}`, "Check filesystem permissions and try again."));
+        process.exitCode = 1;
+    }
+};

package/dist/commands/use.js

@@ -0,0 +1,31 @@
+import { setGlobalActiveVersion, } from "../core/versions.js";
+import fs from "fs-extra";
+import path from "node:path";
+import { getVersionsDir } from "../core/paths.js";
+import { createLogger, formatError } from "../utils/logger.js";
+export const runUseCommand = async (version, deps = {}) => {
+    const logger = deps.logger ?? createLogger();
+    const setActive = deps.setActive ?? setGlobalActiveVersion;
+    const fsImpl = deps.fs ?? deps.setOptions?.fs ?? fs;
+    const resolveVersionsDir = deps.getVersionsDir ?? getVersionsDir;
+    const versionsDir = deps.versionsDir ??
+        deps.setOptions?.versionsDir ??
+        resolveVersionsDir(deps.setOptions?.homeDir);
+    const versionDir = path.join(versionsDir, version);
+    try {
+        const exists = await fsImpl.pathExists(versionDir);
+        if (!exists) {
+            logger.error(`Playwright version "${version}" is not installed.`);
+            logger.info(`Run \`pwvm install ${version}\` first.`);
+            process.exitCode = 1;
+            return;
+        }
+        await setActive(version, deps.setOptions);
+        logger.info(`Using Playwright ${version}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(formatError(`Failed to set active version: ${message}`, `Run \`pwvm install ${version}\` first.`));
+        process.exitCode = 1;
+    }
+};

package/dist/commands/use.test.js

@@ -0,0 +1,41 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { runUseCommand } from "./use.js";
+describe("runUseCommand", () => {
+    const originalExitCode = process.exitCode;
+    const originalIsTTY = process.stdout.isTTY;
+    let errorSpy;
+    beforeEach(() => {
+        process.exitCode = 0;
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: false,
+            configurable: true,
+        });
+        errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+    });
+    afterEach(() => {
+        process.exitCode = originalExitCode;
+        Object.defineProperty(process.stdout, "isTTY", {
+            value: originalIsTTY,
+            configurable: true,
+        });
+        errorSpy.mockRestore();
+    });
+    it("logs an error and guidance when version is not installed", async () => {
+        const version = "1.9999.99999";
+        const setActive = vi.fn(async () => { });
+        const fsMock = {
+            pathExists: vi.fn(async () => false),
+        };
+        const versionsDir = "/mock/versions";
+        const infoSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        await runUseCommand(version, { setActive, fs: fsMock, versionsDir });
+        expect(process.exitCode).toBe(1);
+        expect(errorSpy).toHaveBeenCalled();
+        const message = String(errorSpy.mock.calls[0][0]);
+        expect(message).toContain("[ERROR]:");
+        const infoMessage = String(infoSpy.mock.calls[0][0]);
+        expect(infoMessage).toContain(`Run \`pwvm install ${version}\` first.`);
+        expect(setActive).not.toHaveBeenCalled();
+        infoSpy.mockRestore();
+    });
+});