rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20-test.20250929144616

package/dist/lib/constants.mjs

@@ -1,5 +1,4 @@
-import { resolve } from "node:path";
-import path from "node:path";
+import path, { resolve } from "node:path";
 const __dirname = new URL(".", import.meta.url).pathname;
 export const ROOT_DIR = resolve(__dirname, "..", "..");
 export const SRC_DIR = resolve(ROOT_DIR, "src");

package/dist/lib/e2e/browser.d.mts

@@ -0,0 +1,10 @@
+import type { Browser } from "puppeteer-core";
+import { SmokeTestOptions } from "./types.mjs";
+/**
+ * Launch a browser instance
+ */
+export declare function launchBrowser(browserPath?: string, headless?: boolean): Promise<Browser>;
+/**
+ * Get the browser executable path
+ */
+export declare function getBrowserPath(testOptions?: SmokeTestOptions): Promise<string>;

package/dist/lib/e2e/browser.mjs

@@ -0,0 +1,123 @@
+import { computeExecutablePath, detectBrowserPlatform, install, Browser as PuppeteerBrowser, resolveBuildId, } from "@puppeteer/browsers";
+import debug from "debug";
+import { mkdirp, pathExists } from "fs-extra";
+import * as os from "os";
+import { join } from "path";
+import puppeteer from "puppeteer-core";
+const log = debug("rwsdk:e2e:browser");
+/**
+ * Launch a browser instance
+ */
+export async function launchBrowser(browserPath, headless = true) {
+    // Get browser path if not provided
+    if (!browserPath) {
+        log("Getting browser executable path");
+        browserPath = await getBrowserPath({ headless });
+    }
+    console.log(`🚀 Launching browser from ${browserPath} (headless: ${headless})`);
+    log("Starting browser with puppeteer");
+    return await puppeteer.launch({
+        executablePath: browserPath,
+        headless,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"],
+    });
+}
+/**
+ * Get the browser executable path
+ */
+export async function getBrowserPath(testOptions) {
+    console.log("Finding Chrome executable...");
+    // First try using environment variable if set
+    if (process.env.CHROME_PATH) {
+        console.log(`Using Chrome from environment variable: ${process.env.CHROME_PATH}`);
+        return process.env.CHROME_PATH;
+    }
+    // Detect platform
+    log("Detecting platform");
+    const platform = detectBrowserPlatform();
+    if (!platform) {
+        log("ERROR: Failed to detect browser platform");
+        throw new Error("Failed to detect browser platform");
+    }
+    log("Detected platform: %s", platform);
+    // Define a consistent cache directory path in system temp folder
+    const rwCacheDir = join(os.tmpdir(), "redwoodjs-smoke-test-cache");
+    await mkdirp(rwCacheDir);
+    log("Using cache directory: %s", rwCacheDir);
+    // Determine browser type based on headless option
+    const browser = testOptions?.headless === false
+        ? PuppeteerBrowser.CHROME
+        : PuppeteerBrowser.CHROMEHEADLESSSHELL;
+    log(`Using browser type: ${browser}`);
+    // Resolve the buildId for the stable Chrome version - do this once
+    log("Resolving Chrome buildId for stable channel");
+    const buildId = await resolveBuildId(browser, platform, "stable");
+    log("Resolved buildId: %s", buildId);
+    // Create installation options - use them consistently
+    const installOptions = {
+        browser,
+        platform,
+        cacheDir: rwCacheDir,
+        buildId,
+        unpack: true,
+    };
+    try {
+        // Try to compute the path first (this will check if it's installed)
+        log("Attempting to find existing Chrome installation");
+        const path = computeExecutablePath(installOptions);
+        if (await pathExists(path)) {
+            console.log(`Found existing Chrome at: ${path}`);
+            return path;
+        }
+        else {
+            throw new Error("Chrome not found at: " + path);
+        }
+    }
+    catch (error) {
+        // If path computation fails, install Chrome
+        console.log("No Chrome installation found. Installing Chrome...");
+        // Add better error handling for the install step
+        try {
+            console.log("Downloading Chrome (this may take a few minutes)...");
+            const attempts = 10;
+            let installError;
+            for (let i = 0; i < attempts; i++) {
+                try {
+                    await install(installOptions);
+                    installError = null; // Reset error on success
+                    break; // Exit loop on success
+                }
+                catch (e) {
+                    installError = e;
+                    console.log(`Attempt ${i + 1}/${attempts} failed. Retrying in 1 second...`);
+                    // Wait for 1 second before retrying
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+            }
+            if (installError) {
+                throw installError;
+            }
+            console.log("✅ Chrome installation completed successfully");
+            // Now compute the path for the installed browser
+            const path = computeExecutablePath(installOptions);
+            console.log(`Installed and using Chrome at: ${path}`);
+            return path;
+        }
+        catch (installError) {
+            // Provide more detailed error about the browser download failure
+            log("ERROR: Failed to download/install Chrome: %O", installError);
+            console.error(`❌ Failed to download/install Chrome browser.`);
+            console.error(`This is likely a network issue or the browser download URL is unavailable.`);
+            console.error(`Error details: ${installError instanceof Error ? installError.message : String(installError)}`);
+            // For debug builds, show the full error stack if available
+            if (installError instanceof Error && installError.stack) {
+                log("Error stack: %s", installError.stack);
+            }
+            console.log("\nPossible solutions:");
+            console.log("1. Check your internet connection");
+            console.log("2. Set CHROME_PATH environment variable to an existing Chrome installation");
+            console.log("3. Install Chrome manually and run the tests again");
+            throw new Error(`Failed to install Chrome browser: ${installError instanceof Error ? installError.message : String(installError)}`);
+        }
+    }
+}

package/dist/lib/e2e/dev.d.mts

@@ -0,0 +1,8 @@
+import { PackageManager } from "./types.mjs";
+/**
+ * Run the local development server and return the URL
+ */
+export declare function runDevServer(packageManager?: PackageManager, cwd?: string): Promise<{
+    url: string;
+    stopDev: () => Promise<void>;
+}>;

package/dist/lib/e2e/dev.mjs

@@ -0,0 +1,242 @@
+import debug from "debug";
+import { setTimeout as sleep } from "node:timers/promises";
+import { $ } from "../../lib/$.mjs";
+import { poll } from "./poll.mjs";
+const DEV_SERVER_CHECK_TIMEOUT = process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT
+    ? parseInt(process.env.RWSDK_DEV_SERVER_CHECK_TIMEOUT, 10)
+    : 5 * 60 * 1000;
+const log = debug("rwsdk:e2e:dev");
+/**
+ * Run the local development server and return the URL
+ */
+export async function runDevServer(packageManager = "pnpm", cwd) {
+    console.log("🚀 Starting development server...");
+    // Function to stop the dev server - defined early so we can use it in error handling
+    let devProcess = null;
+    let isErrorExpected = false;
+    const stopDev = async () => {
+        isErrorExpected = true;
+        if (!devProcess || !devProcess.pid) {
+            log("No dev process to stop or PID is missing");
+            return;
+        }
+        console.log("Stopping development server...");
+        try {
+            // Send a regular termination signal to the entire process group first
+            process.kill(-devProcess.pid, "SIGTERM");
+        }
+        catch (e) {
+            log("Could not send SIGTERM to dev server process group: %O", e);
+        }
+        // Wait for the process to terminate with a timeout
+        const terminationTimeout = 5000; // 5 seconds
+        const processExitPromise = devProcess.catch(() => {
+            // We expect this promise to reject when the process is killed,
+            // so we catch and ignore the error.
+        });
+        const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(undefined), terminationTimeout));
+        await Promise.race([processExitPromise, timeoutPromise]);
+        // Check if the process is still alive. We can't reliably check exitCode
+        // on a detached process, so we try sending a signal 0, which errors
+        // if the process doesn't exist.
+        let isAlive = true;
+        try {
+            // Sending signal 0 doesn't kill the process, but checks if it exists
+            process.kill(-devProcess.pid, 0);
+        }
+        catch (e) {
+            isAlive = false;
+        }
+        // If not terminated within timeout, force kill the entire process group
+        if (isAlive) {
+            log("Dev server process did not terminate within timeout, force killing with SIGKILL");
+            console.log("⚠️ Development server not responding after 5 seconds timeout, force killing...");
+            try {
+                process.kill(-devProcess.pid, "SIGKILL");
+            }
+            catch (e) {
+                log("Could not send SIGKILL to dev server process group: %O", e);
+            }
+        }
+        console.log("Development server stopped");
+    };
+    try {
+        // Check if we're in CI mode
+        const inCIMode = process.env.CI === "true" || process.env.CI === "1";
+        // Start dev server with stdout pipe to capture URL
+        // Create environment variables object
+        const env = {
+            ...process.env,
+            NODE_ENV: "development",
+        };
+        // Disable colors when running in CI mode to make URL parsing more reliable
+        if (inCIMode) {
+            log("Running in CI mode, disabling colors for dev server output");
+            env.NO_COLOR = "1";
+            env.FORCE_COLOR = "0";
+        }
+        // Map package manager names to actual commands
+        const getPackageManagerCommand = (pm) => {
+            switch (pm) {
+                case "yarn-classic":
+                    return "yarn";
+                default:
+                    return pm;
+            }
+        };
+        const pm = getPackageManagerCommand(packageManager);
+        // Use the provided cwd if available
+        devProcess = $({
+            all: true,
+            detached: true, // Run in a new process group so we can kill the entire group
+            cleanup: false, // Don't auto-kill on exit
+            cwd: cwd || process.cwd(), // Use provided directory or current directory
+            env, // Pass the updated environment variables
+            stdio: "pipe", // Ensure streams are piped
+        }) `${pm} run dev`;
+        devProcess.catch((error) => {
+            if (!isErrorExpected) {
+                // Don't re-throw. The error will be handled gracefully by the polling
+                // logic in `waitForUrl`, which will detect that the process has exited.
+                // Re-throwing here would cause an unhandled promise rejection.
+                log("Dev server process exited unexpectedly:", error.shortMessage);
+            }
+        });
+        log("Development server process spawned in directory: %s", cwd || process.cwd());
+        // Store chunks to parse the URL
+        let url = "";
+        let allOutput = "";
+        // Listen for all output to get the URL
+        const handleOutput = (data, source) => {
+            const output = data.toString();
+            console.log(output);
+            allOutput += output; // Accumulate all output
+            log("Received output from %s: %s", source, output.replace(/\n/g, "\\n"));
+            if (!url) {
+                // Multiple patterns to catch different package manager outputs
+                const patterns = [
+                    // Standard Vite output: "Local:   http://localhost:5173/"
+                    /Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                    // Alternative Vite output: "➜  Local:   http://localhost:5173/"
+                    /[➜→]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                    // Unicode-safe arrow pattern
+                    /[\u27A1\u2192\u279C]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                    // Direct URL pattern: "http://localhost:5173"
+                    /(https?:\/\/localhost:\d+)/i,
+                    // Port-only pattern: "localhost:5173"
+                    /localhost:(\d+)/i,
+                    // Server ready messages
+                    /server.*ready.*localhost:(\d+)/i,
+                    /dev server.*localhost:(\d+)/i,
+                ];
+                for (const pattern of patterns) {
+                    const match = output.match(pattern);
+                    log("Testing pattern %s against output: %s", pattern.source, output.replace(/\n/g, "\\n"));
+                    if (match) {
+                        log("Pattern matched: %s, groups: %o", pattern.source, match);
+                        if (match[1] && match[1].startsWith("http")) {
+                            url = match[1];
+                            log("Found development server URL with pattern %s: %s", pattern.source, url);
+                            break;
+                        }
+                        else if (match[1] && /^\d+$/.test(match[1])) {
+                            url = `http://localhost:${match[1]}`;
+                            log("Found development server URL with port pattern %s: %s", pattern.source, url);
+                            break;
+                        }
+                    }
+                }
+                // Log potential matches for debugging
+                if (!url &&
+                    (output.includes("localhost") ||
+                        output.includes("Local") ||
+                        output.includes("server"))) {
+                    log("Potential URL pattern found but not matched: %s", output.trim());
+                }
+            }
+        };
+        // Listen to all possible output streams
+        log("Setting up stream listeners. Available streams: all=%s, stdout=%s, stderr=%s", !!devProcess.all, !!devProcess.stdout, !!devProcess.stderr);
+        devProcess.all?.on("data", (data) => handleOutput(data, "all"));
+        devProcess.stdout?.on("data", (data) => handleOutput(data, "stdout"));
+        devProcess.stderr?.on("data", (data) => handleOutput(data, "stderr"));
+        // Also try listening to the raw process output
+        if (devProcess.child) {
+            log("Setting up child process stream listeners");
+            devProcess.child.stdout?.on("data", (data) => handleOutput(data, "child.stdout"));
+            devProcess.child.stderr?.on("data", (data) => handleOutput(data, "child.stderr"));
+        }
+        // Wait for URL with timeout
+        const waitForUrl = async () => {
+            const start = Date.now();
+            const timeout = 60000; // 60 seconds
+            while (Date.now() - start < timeout) {
+                if (url) {
+                    return url;
+                }
+                // Fallback: check accumulated output if stream listeners aren't working
+                if (!url && allOutput) {
+                    log("Checking accumulated output for URL patterns: %s", allOutput.replace(/\n/g, "\\n"));
+                    const patterns = [
+                        /Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                        /[➜→]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                        /[\u27A1\u2192\u279C]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
+                        /(https?:\/\/localhost:\d+)/i,
+                        /localhost:(\d+)/i,
+                    ];
+                    for (const pattern of patterns) {
+                        const match = allOutput.match(pattern);
+                        if (match) {
+                            if (match[1] && match[1].startsWith("http")) {
+                                url = match[1];
+                                log("Found URL in accumulated output with pattern %s: %s", pattern.source, url);
+                                return url;
+                            }
+                            else if (match[1] && /^\d+$/.test(match[1])) {
+                                url = `http://localhost:${match[1]}`;
+                                log("Found URL in accumulated output with port pattern %s: %s", pattern.source, url);
+                                return url;
+                            }
+                        }
+                    }
+                }
+                // Check if the process is still running
+                if (devProcess.exitCode !== null) {
+                    log("ERROR: Development server process exited with code %d. Final output: %s", devProcess.exitCode, allOutput);
+                    throw new Error(`Development server process exited with code ${devProcess.exitCode}`);
+                }
+                await sleep(500); // Check every 500ms
+            }
+            log("ERROR: Timed out waiting for dev server URL. Final accumulated output: %s", allOutput);
+            throw new Error("Timed out waiting for dev server URL");
+        };
+        // Wait for the URL
+        const serverUrl = await waitForUrl();
+        console.log(`✅ Development server started at ${serverUrl}`);
+        // Poll the URL to ensure it's live before proceeding
+        await poll(async () => {
+            try {
+                const response = await fetch(serverUrl, {
+                    signal: AbortSignal.timeout(1000),
+                });
+                // We consider any response (even 4xx or 5xx) as success,
+                // as it means the worker is routable.
+                return response.status > 0;
+            }
+            catch (e) {
+                return false;
+            }
+        }, {
+            timeout: DEV_SERVER_CHECK_TIMEOUT,
+        });
+        return { url: serverUrl, stopDev };
+    }
+    catch (error) {
+        // Make sure to try to stop the server on error
+        log("Error during dev server startup: %O", error);
+        await stopDev().catch((e) => {
+            log("Failed to stop dev server during error handling: %O", e);
+        });
+        throw error;
+    }
+}

package/dist/lib/e2e/environment.d.mts

@@ -0,0 +1,10 @@
+import tmp from "tmp-promise";
+import { PackageManager } from "./types.mjs";
+/**
+ * Copy project to a temporary directory with a unique name
+ */
+export declare function copyProjectToTempDir(projectDir: string, resourceUniqueKey: string, packageManager?: PackageManager, monorepoRoot?: string): Promise<{
+    tempDir: tmp.DirectoryResult;
+    targetDir: string;
+    workerName: string;
+}>;

package/dist/lib/e2e/environment.mjs

@@ -0,0 +1,210 @@
+import debug from "debug";
+import { copy, pathExists } from "fs-extra";
+import ignore from "ignore";
+import * as fs from "node:fs";
+import path from "node:path";
+import os from "os";
+import { basename, join, relative, resolve } from "path";
+import tmp from "tmp-promise";
+import { $ } from "../../lib/$.mjs";
+import { ROOT_DIR } from "../constants.mjs";
+import { retry } from "./retry.mjs";
+const log = debug("rwsdk:e2e:environment");
+const createSdkTarball = async () => {
+    const packResult = await $({ cwd: ROOT_DIR, stdio: "pipe" }) `npm pack`;
+    const tarballName = packResult.stdout?.trim();
+    const tarballPath = path.join(ROOT_DIR, tarballName);
+    log(`📦 Created tarball: ${tarballPath}`);
+    const cleanupTarball = async () => {
+        if (fs.existsSync(tarballPath)) {
+            log(`🧹 Cleaning up tarball: ${tarballPath}`);
+            await fs.promises.rm(tarballPath, { force: true });
+        }
+    };
+    return { tarballPath, cleanupTarball };
+};
+const setTarballDependency = async (targetDir, tarballName) => {
+    const filePath = join(targetDir, "package.json");
+    const packageJson = await fs.promises.readFile(filePath, "utf-8");
+    const packageJsonContent = JSON.parse(packageJson);
+    packageJsonContent.dependencies.rwsdk = `file:${tarballName}`;
+    await fs.promises.writeFile(filePath, JSON.stringify(packageJsonContent, null, 2));
+};
+/**
+ * Copy project to a temporary directory with a unique name
+ */
+export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot) {
+    const { tarballPath, cleanupTarball } = await createSdkTarball();
+    try {
+        log("Creating temporary directory for project");
+        // Create a temporary directory
+        const tempDir = await tmp.dir({ unsafeCleanup: true });
+        // Determine the source directory to copy from
+        const sourceDir = monorepoRoot || projectDir;
+        // Create unique project directory name
+        const originalDirName = basename(sourceDir);
+        const workerName = `${originalDirName}-test-${resourceUniqueKey}`;
+        const tempCopyRoot = resolve(tempDir.path, workerName);
+        // If it's a monorepo, the targetDir for commands is a subdirectory
+        const targetDir = monorepoRoot
+            ? resolve(tempCopyRoot, relative(monorepoRoot, projectDir))
+            : tempCopyRoot;
+        console.log(`Copying project from ${sourceDir} to ${tempCopyRoot}`);
+        // Read project's .gitignore if it exists
+        let ig = ignore();
+        const gitignorePath = join(sourceDir, ".gitignore");
+        if (await pathExists(gitignorePath)) {
+            log("Found .gitignore file at %s", gitignorePath);
+            const gitignoreContent = await fs.promises.readFile(gitignorePath, "utf-8");
+            ig = ig.add(gitignoreContent);
+        }
+        else {
+            log("No .gitignore found, using default ignore patterns");
+            // Add default ignores if no .gitignore exists
+            ig = ig.add([
+                "node_modules",
+                ".git",
+                "dist",
+                "build",
+                ".DS_Store",
+                "coverage",
+                ".cache",
+                ".wrangler",
+                ".env",
+            ].join("\n"));
+        }
+        // Copy the project directory, respecting .gitignore
+        log("Starting copy process with ignored patterns");
+        await copy(sourceDir, tempCopyRoot, {
+            filter: (src) => {
+                // Get path relative to project directory
+                const relativePath = relative(sourceDir, src);
+                if (!relativePath)
+                    return true; // Include the root directory
+                // Check against ignore patterns
+                const result = !ig.ignores(relativePath);
+                return result;
+            },
+        });
+        log("Project copy completed successfully");
+        // Copy the SDK tarball into the target directory
+        const tarballFilename = basename(tarballPath);
+        const tempTarballPath = join(targetDir, tarballFilename);
+        await fs.promises.copyFile(tarballPath, tempTarballPath);
+        if (monorepoRoot) {
+            log("⚙️  Configuring monorepo workspace...");
+            const rwsdkWsPath = join(tempCopyRoot, "rwsdk-workspace.json");
+            if (await pathExists(rwsdkWsPath)) {
+                const rwsdkWs = JSON.parse(await fs.promises.readFile(rwsdkWsPath, "utf-8"));
+                const workspaces = rwsdkWs.workspaces;
+                if (packageManager === "pnpm") {
+                    const pnpmWsPath = join(tempCopyRoot, "pnpm-workspace.yaml");
+                    const pnpmWsConfig = `packages:\n${workspaces.map((w) => `  - '${w}'`).join("\n")}\n`;
+                    await fs.promises.writeFile(pnpmWsPath, pnpmWsConfig);
+                    log("Created pnpm-workspace.yaml");
+                }
+                else {
+                    // For npm and yarn, add a workspaces property to package.json
+                    const pkgJsonPath = join(tempCopyRoot, "package.json");
+                    const pkgJson = JSON.parse(await fs.promises.readFile(pkgJsonPath, "utf-8"));
+                    pkgJson.workspaces = workspaces;
+                    await fs.promises.writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+                    log("Added workspaces to package.json");
+                }
+            }
+        }
+        // Configure temp project to not use frozen lockfile
+        log("⚙️  Configuring temp project to not use frozen lockfile...");
+        const npmrcPath = join(targetDir, ".npmrc");
+        await fs.promises.writeFile(npmrcPath, "frozen-lockfile=false\n");
+        // For yarn, create .yarnrc.yml to disable PnP and allow lockfile changes
+        if (packageManager === "yarn") {
+            const yarnrcPath = join(targetDir, ".yarnrc.yml");
+            const yarnCacheDir = path.join(os.tmpdir(), "yarn-cache");
+            await fs.promises.mkdir(yarnCacheDir, { recursive: true });
+            const yarnConfig = [
+                // todo(justinvdm, 23-09-23): Support yarn pnpm
+                "nodeLinker: node-modules",
+                "enableImmutableInstalls: false",
+                `cacheFolder: "${yarnCacheDir}"`,
+            ].join("\n");
+            await fs.promises.writeFile(yarnrcPath, yarnConfig);
+            log("Created .yarnrc.yml to allow lockfile changes for yarn");
+        }
+        await setTarballDependency(targetDir, tarballFilename);
+        // Install dependencies in the target directory
+        const installDir = monorepoRoot ? tempCopyRoot : targetDir;
+        await retry(() => installDependencies(installDir, packageManager), {
+            retries: 3,
+            delay: 1000,
+        });
+        // Return the environment details
+        return { tempDir, targetDir, workerName };
+    }
+    finally {
+        await cleanupTarball();
+    }
+}
+async function installDependencies(targetDir, packageManager = "pnpm") {
+    console.log(`📦 Installing project dependencies in ${targetDir} using ${packageManager}...`);
+    try {
+        // Clean up any pre-existing node_modules and lockfiles
+        log("Cleaning up pre-existing node_modules and lockfiles...");
+        await Promise.all([
+            fs.promises.rm(join(targetDir, "node_modules"), {
+                recursive: true,
+                force: true,
+            }),
+            fs.promises.rm(join(targetDir, "pnpm-lock.yaml"), { force: true }),
+            fs.promises.rm(join(targetDir, "yarn.lock"), { force: true }),
+            fs.promises.rm(join(targetDir, "package-lock.json"), { force: true }),
+        ]);
+        log("Cleanup complete.");
+        if (packageManager.startsWith("yarn")) {
+            log(`Enabling corepack...`);
+            await $("corepack", ["enable"], { cwd: targetDir, stdio: "pipe" });
+            if (packageManager === "yarn") {
+                log(`Preparing yarn@stable with corepack...`);
+                await $("corepack", ["prepare", "yarn@stable", "--activate"], {
+                    cwd: targetDir,
+                    stdio: "pipe",
+                });
+            }
+            else if (packageManager === "yarn-classic") {
+                log(`Preparing yarn@1.22.19 with corepack...`);
+                await $("corepack", ["prepare", "yarn@1.22.19", "--activate"], {
+                    cwd: targetDir,
+                    stdio: "pipe",
+                });
+            }
+        }
+        const npmCacheDir = path.join(os.tmpdir(), "npm-cache");
+        await fs.promises.mkdir(npmCacheDir, { recursive: true });
+        const installCommand = {
+            pnpm: ["pnpm", "install"],
+            npm: ["npm", "install", "--cache", npmCacheDir],
+            yarn: ["yarn", "install"],
+            "yarn-classic": ["yarn"],
+        }[packageManager];
+        // Run install command in the target directory
+        log(`Running ${installCommand.join(" ")}`);
+        const [command, ...args] = installCommand;
+        const result = await $(command, args, {
+            cwd: targetDir,
+            stdio: "pipe", // Capture output
+            env: {
+                YARN_ENABLE_HARDENED_MODE: "0",
+            },
+        });
+        console.log("✅ Dependencies installed successfully");
+        // Log installation details at debug level
+        if (result.stdout) {
+            log(`${packageManager} install output: %s`, result.stdout);
+        }
+    }
+    catch (error) {
+        log("ERROR: Failed to install dependencies: %O", error);
+        console.error(`❌ Failed to install dependencies: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to install project dependencies. Please ensure the project can be installed with ${packageManager}.`);
+    }
+}

package/dist/lib/e2e/index.d.mts

@@ -0,0 +1,8 @@
+export * from "./browser.mjs";
+export * from "./dev.mjs";
+export * from "./environment.mjs";
+export * from "./poll.mjs";
+export * from "./release.mjs";
+export * from "./tarball.mjs";
+export * from "./testHarness.mjs";
+export * from "./types.mjs";

package/dist/lib/e2e/index.mjs

@@ -0,0 +1,8 @@
+export * from "./browser.mjs";
+export * from "./dev.mjs";
+export * from "./environment.mjs";
+export * from "./poll.mjs";
+export * from "./release.mjs";
+export * from "./tarball.mjs";
+export * from "./testHarness.mjs";
+export * from "./types.mjs";

package/dist/lib/e2e/poll.d.mts

@@ -0,0 +1,8 @@
+export interface PollOptions {
+    timeout: number;
+    interval: number;
+    minTries: number;
+    onRetry?: (error: unknown, tries: number) => void;
+}
+export declare function poll(fn: () => Promise<boolean>, options?: Partial<PollOptions>): Promise<void>;
+export declare function pollValue<T>(fn: () => Promise<T>, options?: Partial<PollOptions>): Promise<T>;