pwvm 0.1.0

package/dist/core/browsers.js

@@ -0,0 +1,28 @@
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "node:path";
+import { getVersionsDir } from "./paths.js";
+export const installPlaywrightBrowsers = async (version, options = {}) => {
+    const fsImpl = options.fs ?? fs;
+    const execaImpl = options.execa ?? execa;
+    const resolveVersionsDir = options.getVersionsDir ?? getVersionsDir;
+    const versionsDir = options.versionsDir ?? resolveVersionsDir(options.homeDir);
+    const installDir = path.join(versionsDir, version);
+    const installDirExists = await fsImpl.pathExists(installDir);
+    if (!installDirExists) {
+        throw new Error(`Playwright ${version} is not installed.`);
+    }
+    const playwrightDir = path.join(installDir, "node_modules", "playwright");
+    const playwrightExists = await fsImpl.pathExists(playwrightDir);
+    if (!playwrightExists) {
+        throw new Error(`Playwright ${version} is not installed.`);
+    }
+    const browsersDir = path.join(installDir, "browsers");
+    await execaImpl("npx", ["playwright", "install"], {
+        cwd: installDir,
+        env: {
+            ...process.env,
+            PLAYWRIGHT_BROWSERS_PATH: browsersDir,
+        },
+    });
+};

package/dist/core/install.js

@@ -0,0 +1,82 @@
+import { execa } from "execa";
+import fs from "fs-extra";
+import semver from "semver";
+import path from "node:path";
+import { installPlaywrightBrowsers } from "./browsers.js";
+import { getVersionsDir } from "./paths.js";
+import { getInstalledVersions, } from "./versions.js";
+export const installPlaywrightVersion = async (version, options = {}) => {
+    if (!semver.valid(version)) {
+        throw new Error(`Invalid Playwright version "${version}".`);
+    }
+    const fsImpl = options.fs ?? fs;
+    const execaImpl = options.execa ?? execa;
+    const resolveVersionsDir = options.getVersionsDir ?? getVersionsDir;
+    const getInstalled = options.getInstalled ?? getInstalledVersions;
+    const installBrowsers = options.installBrowsers ?? installPlaywrightBrowsers;
+    const versionsDir = options.versionsDir ?? resolveVersionsDir(options.homeDir);
+    const targetDir = path.join(versionsDir, version);
+    const packageDir = path.join(targetDir, "node_modules", "playwright");
+    const browsersDir = path.join(targetDir, "browsers");
+    let packageExists = false;
+    let browsersExists = false;
+    let cleanupOnFailure = false;
+    const result = {
+        packageInstalled: false,
+        browsersInstalled: false,
+        packageAlreadyInstalled: false,
+        browsersAlreadyInstalled: false,
+    };
+    try {
+        packageExists = await fsImpl.pathExists(packageDir);
+        browsersExists = await fsImpl.pathExists(browsersDir);
+        cleanupOnFailure = !packageExists;
+        result.packageAlreadyInstalled = packageExists;
+        result.browsersAlreadyInstalled = browsersExists;
+        let isFirstInstall = false;
+        if (!packageExists && options.withBrowsers === undefined) {
+            const installedVersions = await getInstalled({
+                homeDir: options.homeDir,
+                versionsDir: options.versionsDir,
+                ...options.installedOptions,
+            });
+            isFirstInstall = installedVersions.length === 0;
+        }
+        if (!packageExists) {
+            await fsImpl.ensureDir(targetDir);
+            await execaImpl("npm", ["install", `playwright@${version}`, "--no-save"], {
+                cwd: targetDir,
+                env: {
+                    PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: "1",
+                },
+            });
+            result.packageInstalled = true;
+            result.packageAlreadyInstalled = false;
+        }
+        const shouldInstallBrowsers = (!browsersExists && options.withBrowsers === true) ||
+            (options.withBrowsers === undefined && !packageExists && isFirstInstall);
+        if (shouldInstallBrowsers) {
+            await installBrowsers(version, {
+                homeDir: options.homeDir,
+                versionsDir: options.versionsDir,
+                fs: options.fs,
+                execa: options.execa,
+                getVersionsDir: options.getVersionsDir,
+            });
+            result.browsersInstalled = true;
+            result.browsersAlreadyInstalled = false;
+        }
+        return result;
+    }
+    catch (error) {
+        if (cleanupOnFailure) {
+            try {
+                await fsImpl.remove(targetDir);
+            }
+            catch {
+                // Best-effort cleanup.
+            }
+        }
+        throw error;
+    }
+};

package/dist/core/install.test.js

@@ -0,0 +1,97 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { installPlaywrightVersion } from "./install.js";
+import { createFsMock, createTempPwvmHome } from "../test/utils.js";
+const createExecaMock = () => vi.fn((_file, _args, _options) => Promise.resolve({ exitCode: 0 }));
+describe("installPlaywrightVersion", () => {
+    it("installs package when version is not installed", async () => {
+        const { homeDir, cleanup } = await createTempPwvmHome();
+        try {
+            const version = "1.2.3";
+            const versionsDir = path.join(homeDir, ".pwvm", "versions");
+            const targetDir = path.join(versionsDir, version);
+            const execaMock = createExecaMock();
+            const fsMock = createFsMock(homeDir);
+            await installPlaywrightVersion(version, {
+                fs: fsMock,
+                execa: execaMock,
+                versionsDir,
+                withBrowsers: false,
+            });
+            expect(execaMock).toHaveBeenCalledWith("npm", ["install", `playwright@${version}`, "--no-save"], expect.objectContaining({ cwd: targetDir }));
+            expect(await fs.pathExists(targetDir)).toBe(true);
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it("errors on invalid version", async () => {
+        const { homeDir, cleanup } = await createTempPwvmHome();
+        const execaMock = createExecaMock();
+        try {
+            await expect(installPlaywrightVersion("not-a-version", {
+                homeDir,
+                execa: execaMock,
+            })).rejects.toThrow('Invalid Playwright version "not-a-version".');
+            expect(execaMock).not.toHaveBeenCalled();
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it("allows browser installation on existing package", async () => {
+        const { homeDir, cleanup } = await createTempPwvmHome();
+        try {
+            const version = "2.0.0";
+            const versionsDir = path.join(homeDir, ".pwvm", "versions");
+            const targetDir = path.join(versionsDir, version);
+            const packageDir = path.join(targetDir, "node_modules", "playwright");
+            const execaMock = createExecaMock();
+            const installBrowsers = vi.fn(async () => { });
+            const fsMock = createFsMock(homeDir);
+            await fs.ensureDir(packageDir);
+            await installPlaywrightVersion(version, {
+                fs: fsMock,
+                execa: execaMock,
+                versionsDir,
+                withBrowsers: true,
+                installBrowsers,
+            });
+            expect(installBrowsers).toHaveBeenCalledWith(version, expect.objectContaining({ versionsDir }));
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it("does not reinstall package twice", async () => {
+        const { homeDir, cleanup } = await createTempPwvmHome();
+        try {
+            const version = "3.1.4";
+            const versionsDir = path.join(homeDir, ".pwvm", "versions");
+            const targetDir = path.join(versionsDir, version);
+            const packageDir = path.join(targetDir, "node_modules", "playwright");
+            const browsersDir = path.join(targetDir, "browsers");
+            const execaMock = createExecaMock();
+            const fsMock = createFsMock(homeDir);
+            await installPlaywrightVersion(version, {
+                fs: fsMock,
+                execa: execaMock,
+                versionsDir,
+                withBrowsers: false,
+            });
+            await fs.ensureDir(packageDir);
+            await fs.ensureDir(browsersDir);
+            await installPlaywrightVersion(version, {
+                fs: fsMock,
+                execa: execaMock,
+                versionsDir,
+                withBrowsers: false,
+            });
+            expect(execaMock).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            await cleanup();
+        }
+    });
+});

package/dist/core/paths.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const PWVM_DIR_NAME = ".pwvm";
+export const PWVM_RC_NAME = ".pwvmrc";
+export const getPwvmDir = (homeDir = os.homedir()) => path.join(homeDir, PWVM_DIR_NAME);
+export const getVersionsDir = (homeDir = os.homedir()) => path.join(getPwvmDir(homeDir), "versions");
+export const getShimsDir = (homeDir = os.homedir()) => path.join(getPwvmDir(homeDir), "shims");
+export const getActiveVersionFile = (homeDir = os.homedir()) => path.join(getPwvmDir(homeDir), "version");
+export const createPaths = (homeDir = os.homedir()) => ({
+    homeDir,
+    pwvmDir: getPwvmDir(homeDir),
+    versionsDir: getVersionsDir(homeDir),
+    shimsDir: getShimsDir(homeDir),
+    activeVersionFile: getActiveVersionFile(homeDir),
+});
+export const resolveRcPath = (options = {}) => {
+    const startDir = options.startDir ?? process.cwd();
+    const rcFileName = options.rcFileName ?? PWVM_RC_NAME;
+    const fsImpl = options.fs ?? fs;
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(currentDir, rcFileName);
+        if (fsImpl.existsSync(candidate)) {
+            const stat = fsImpl.statSync(candidate);
+            if (stat.isFile()) {
+                return candidate;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    return null;
+};

package/dist/core/prune.js

@@ -0,0 +1,71 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { getVersionsDir, resolveRcPath } from "./paths.js";
+import { getGlobalActiveVersion, getInstalledVersions, } from "./versions.js";
+const readRcVersion = async (options, fsImpl, resolveRc) => {
+    try {
+        const rcPath = resolveRc({
+            startDir: options.rcStartDir,
+            rcFileName: options.rcFileName,
+            fs: fsImpl,
+        });
+        if (!rcPath) {
+            return null;
+        }
+        const contents = await fsImpl.readFile(rcPath, "utf8");
+        const trimmed = contents.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const pruneVersions = async (options = {}) => {
+    const fsImpl = (options.fs ?? fs);
+    const getInstalled = options.getInstalled ?? getInstalledVersions;
+    const getGlobalActive = options.getGlobalActive ?? getGlobalActiveVersion;
+    const resolveRc = options.resolveRc ?? resolveRcPath;
+    const resolveVersionsDir = options.getVersionsDir ?? getVersionsDir;
+    const [installedVersions, globalVersion, rcVersion] = await Promise.all([
+        getInstalled({
+            homeDir: options.homeDir,
+            versionsDir: options.versionsDir,
+            fs: fsImpl,
+            ...options.installedOptions,
+        }),
+        getGlobalActive({
+            homeDir: options.homeDir,
+            activeVersionFile: options.activeVersionFile,
+            fs: fsImpl,
+            ...options.globalOptions,
+        }),
+        readRcVersion(options, fsImpl, resolveRc),
+    ]);
+    const keep = new Set();
+    if (globalVersion) {
+        keep.add(globalVersion);
+    }
+    if (rcVersion) {
+        keep.add(rcVersion);
+    }
+    const versionsDir = options.versionsDir ?? resolveVersionsDir(options.homeDir);
+    const removed = [];
+    for (const version of installedVersions) {
+        if (keep.has(version)) {
+            continue;
+        }
+        const targetDir = path.join(versionsDir, version);
+        try {
+            const exists = await fsImpl.pathExists(targetDir);
+            if (!exists) {
+                continue;
+            }
+            await fsImpl.remove(targetDir);
+            removed.push(version);
+        }
+        catch {
+            continue;
+        }
+    }
+    return removed;
+};

package/dist/core/shim.js

@@ -0,0 +1,32 @@
+import { execa } from "execa";
+import fs from "fs-extra";
+import path from "node:path";
+import { getVersionsDir } from "./paths.js";
+import { getResolvedActiveVersion, } from "./versions.js";
+export const runPlaywrightShim = async (args, options = {}) => {
+    const resolveVersionsDir = options.getVersionsDir ?? getVersionsDir;
+    const execaImpl = options.execa ?? execa;
+    const fsImpl = options.fs ?? fs;
+    const resolveActive = options.getResolvedActiveVersion ?? getResolvedActiveVersion;
+    const activeVersion = await resolveActive(options.activeOptions);
+    if (!activeVersion) {
+        throw new Error("No active Playwright version. Run `pwvm use <version>`.");
+    }
+    const versionsDir = options.versionsDir ?? resolveVersionsDir(options.homeDir);
+    const versionDir = path.join(versionsDir, activeVersion);
+    const binaryPath = path.join(versionDir, "node_modules", ".bin", "playwright");
+    const binaryExists = await fsImpl.pathExists(binaryPath);
+    if (!binaryExists) {
+        throw new Error(`Playwright ${activeVersion} is not installed.`);
+    }
+    const browsersDir = path.join(versionDir, "browsers");
+    const result = await execaImpl(binaryPath, args, {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            PLAYWRIGHT_BROWSERS_PATH: browsersDir,
+        },
+        reject: false,
+    });
+    process.exitCode = result.exitCode ?? 1;
+};

package/dist/core/shim.test.js

@@ -0,0 +1,73 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { runPlaywrightShim } from "./shim.js";
+import { createFsMock, createTempPwvmHome } from "../test/utils.js";
+const createExecaMock = () => vi.fn((_file, _args, _options) => Promise.resolve({ exitCode: 0 }));
+afterEach(() => {
+    process.exitCode = undefined;
+});
+describe("runPlaywrightShim", () => {
+    it("errors when no active version", async () => {
+        const { homeDir, cleanup } = await createTempPwvmHome();
+        const execaMock = createExecaMock();
+        try {
+            await expect(runPlaywrightShim(["install"], {
+                fs: createFsMock(homeDir),
+                execa: execaMock,
+                getResolvedActiveVersion: async () => null,
+            })).rejects.toThrow("No active Playwright version. Run `pwvm use <version>`.");
+            expect(execaMock).not.toHaveBeenCalled();
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it("resolves correct Playwright binary", async () => {
+        const { homeDir, cleanup } = await createTempPwvmHome();
+        try {
+            const version = "1.42.0";
+            const versionsDir = path.join(homeDir, ".pwvm", "versions");
+            const expectedBinary = path.join(versionsDir, version, "node_modules", ".bin", "playwright");
+            const execaMock = createExecaMock();
+            await fs.ensureDir(path.dirname(expectedBinary));
+            await fs.writeFile(expectedBinary, "");
+            await runPlaywrightShim(["install"], {
+                fs: createFsMock(homeDir),
+                execa: execaMock,
+                versionsDir,
+                getResolvedActiveVersion: async () => version,
+            });
+            expect(execaMock).toHaveBeenCalledWith(expectedBinary, ["install"], expect.any(Object));
+        }
+        finally {
+            await cleanup();
+        }
+    });
+    it("injects PLAYWRIGHT_BROWSERS_PATH", async () => {
+        const { homeDir, cleanup } = await createTempPwvmHome();
+        try {
+            const version = "1.42.0";
+            const versionsDir = path.join(homeDir, ".pwvm", "versions");
+            const expectedBinary = path.join(versionsDir, version, "node_modules", ".bin", "playwright");
+            const expectedBrowsers = path.join(versionsDir, version, "browsers");
+            const execaMock = createExecaMock();
+            await fs.ensureDir(path.dirname(expectedBinary));
+            await fs.writeFile(expectedBinary, "");
+            await runPlaywrightShim(["install"], {
+                fs: createFsMock(homeDir),
+                execa: execaMock,
+                versionsDir,
+                getResolvedActiveVersion: async () => version,
+            });
+            expect(execaMock).toHaveBeenCalledWith(expectedBinary, ["install"], expect.objectContaining({
+                env: expect.objectContaining({
+                    PLAYWRIGHT_BROWSERS_PATH: expectedBrowsers,
+                }),
+            }));
+        }
+        finally {
+            await cleanup();
+        }
+    });
+});

package/dist/core/shimTemplates.js

@@ -0,0 +1,6 @@
+export const unixShim = (pwvmBinPath) => `#!/usr/bin/env bash
+node "${pwvmBinPath}" _shim "$@"
+`;
+export const windowsShim = (pwvmBinPath) => `@echo off
+"${pwvmBinPath}" _shim %*
+`;

package/dist/core/versions.js

@@ -0,0 +1,72 @@
+import fs from "fs-extra";
+import semver from "semver";
+import { getActiveVersionFile, getPwvmDir, getVersionsDir, resolveRcPath, } from "./paths.js";
+const resolvePwvmDir = (options) => options.pwvmDir ?? getPwvmDir(options.homeDir);
+const resolveVersionsDir = (options) => options.versionsDir ?? getVersionsDir(options.homeDir);
+const resolveActiveVersionFile = (options) => options.activeVersionFile ?? getActiveVersionFile(options.homeDir);
+export const getInstalledVersions = async (options = {}) => {
+    const fsImpl = options.fs ?? fs;
+    const versionsDir = resolveVersionsDir(options);
+    try {
+        const exists = await fsImpl.pathExists(versionsDir);
+        if (!exists) {
+            return [];
+        }
+        const entries = await fsImpl.readdir(versionsDir, { withFileTypes: true });
+        const versions = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .filter((version) => semver.valid(version) !== null);
+        return versions.sort((a, b) => semver.compare(a, b));
+    }
+    catch {
+        return [];
+    }
+};
+export const getGlobalActiveVersion = async (options = {}) => {
+    const fsImpl = options.fs ?? fs;
+    const activeVersionFile = resolveActiveVersionFile(options);
+    try {
+        const exists = await fsImpl.pathExists(activeVersionFile);
+        if (!exists) {
+            return null;
+        }
+        const contents = await fsImpl.readFile(activeVersionFile, "utf8");
+        const trimmed = contents.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const getResolvedActiveVersion = async (options = {}) => {
+    const fsImpl = options.fs ?? fs;
+    const resolveRc = options.resolveRc ?? resolveRcPath;
+    try {
+        const rcPath = resolveRc({
+            startDir: options.rcStartDir,
+            rcFileName: options.rcFileName,
+            fs: fsImpl,
+        });
+        if (rcPath) {
+            const contents = await fsImpl.readFile(rcPath, "utf8");
+            const trimmed = contents.trim();
+            return trimmed.length > 0 ? trimmed : null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return getGlobalActiveVersion(options);
+};
+export const setGlobalActiveVersion = async (version, options = {}) => {
+    const fsImpl = options.fs ?? fs;
+    const installedVersions = await getInstalledVersions(options);
+    if (!installedVersions.includes(version)) {
+        throw new Error(`Playwright version "${version}" is not installed.`);
+    }
+    const pwvmDir = resolvePwvmDir(options);
+    const activeVersionFile = resolveActiveVersionFile(options);
+    await fsImpl.ensureDir(pwvmDir);
+    await fsImpl.writeFile(activeVersionFile, `${version}\n`, "utf8");
+};

package/dist/core/versions.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { getInstalledVersions, getResolvedActiveVersion, } from "./versions.js";
+const dirent = (name, isDirectory) => ({
+    name,
+    isDirectory: () => isDirectory,
+});
+const makeFs = (overrides = {}) => ({
+    pathExists: async (_path) => false,
+    readdir: async (_path, _options) => [],
+    readFile: async (_path) => "",
+    writeFile: async () => { },
+    ensureDir: async () => { },
+    existsSync: () => false,
+    statSync: (_path) => ({ isFile: () => false }),
+    ...overrides,
+});
+describe("getInstalledVersions", () => {
+    it("returns empty list when no versions exist", async () => {
+        const fs = makeFs({ pathExists: async (_path) => false });
+        await expect(getInstalledVersions({ fs, versionsDir: "/versions" })).resolves.toEqual([]);
+    });
+    it("reads installed versions correctly", async () => {
+        const fs = makeFs({
+            pathExists: async (_path) => true,
+            readdir: async (_path) => [
+                dirent("1.0.0", true),
+                dirent("2.0.0", false),
+                dirent("not-a-version", true),
+                dirent("1.2.3", true),
+            ],
+        });
+        const versions = await getInstalledVersions({
+            fs,
+            versionsDir: "/versions",
+        });
+        expect(versions).toEqual(["1.0.0", "1.2.3"]);
+    });
+    it("sorts versions with semver", async () => {
+        const fs = makeFs({
+            pathExists: async (_path) => true,
+            readdir: async (_path) => [
+                dirent("1.10.0", true),
+                dirent("0.9.0", true),
+                dirent("1.2.0", true),
+            ],
+        });
+        const versions = await getInstalledVersions({
+            fs,
+            versionsDir: "/versions",
+        });
+        expect(versions).toEqual(["0.9.0", "1.2.0", "1.10.0"]);
+    });
+});
+describe("getResolvedActiveVersion", () => {
+    it("respects .pwvmrc override", async () => {
+        const rcPath = "/repo/.pwvmrc";
+        const globalPath = "/home/.pwvm/version";
+        const fs = makeFs({
+            pathExists: async (path) => String(path) === globalPath,
+            readFile: async (path) => {
+                if (String(path) === rcPath) {
+                    return "1.9.0\n";
+                }
+                if (String(path) === globalPath) {
+                    return "2.0.0\n";
+                }
+                return "";
+            },
+        });
+        const resolveRc = () => rcPath;
+        const version = await getResolvedActiveVersion({
+            fs,
+            resolveRc,
+            activeVersionFile: globalPath,
+        });
+        expect(version).toBe("1.9.0");
+    });
+    it("falls back to global version", async () => {
+        const globalPath = "/home/.pwvm/version";
+        const fs = makeFs({
+            pathExists: async (path) => String(path) === globalPath,
+            readFile: async (path) => String(path) === globalPath ? "2.4.0\n" : "",
+        });
+        const resolveRc = () => null;
+        const version = await getResolvedActiveVersion({
+            fs,
+            resolveRc,
+            activeVersionFile: globalPath,
+        });
+        expect(version).toBe("2.4.0");
+    });
+});