rwsdk 1.0.0-alpha.8 → 1.0.0-alpha.9

package/dist/lib/e2e/browser.mjs

@@ -80,7 +80,24 @@ export async function getBrowserPath(testOptions) {
         // Add better error handling for the install step
         try {
             console.log("Downloading Chrome (this may take a few minutes)...");
-            await install(installOptions);
+            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);

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

@@ -7,7 +7,7 @@ export declare function setupTestEnvironment(options?: SmokeTestOptions): Promis
 /**
  * Copy project to a temporary directory with a unique name
  */
-export declare function copyProjectToTempDir(projectDir: string, sync: boolean | undefined, resourceUniqueKey: string, packageManager?: PackageManager): Promise<{
+export declare function copyProjectToTempDir(projectDir: string, resourceUniqueKey: string, packageManager?: PackageManager): Promise<{
     tempDir: tmp.DirectoryResult;
     targetDir: string;
     workerName: string;

package/dist/lib/e2e/environment.mjs

@@ -1,15 +1,36 @@
 import { join } from "path";
 import debug from "debug";
 import { pathExists, copy } from "fs-extra";
-import * as fs from "fs/promises";
+import * as fs from "node:fs";
 import tmp from "tmp-promise";
 import ignore from "ignore";
 import { relative, basename, resolve } from "path";
 import { uniqueNamesGenerator, adjectives, animals, } from "unique-names-generator";
-import { $ } from "../../lib/$.mjs";
-import { debugSync } from "../../scripts/debug-sync.mjs";
 import { createHash } from "crypto";
+import { $ } from "../../lib/$.mjs";
+import { ROOT_DIR } from "../constants.mjs";
+import path from "node:path";
 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, tarballPath) => {
+    const filePath = join(targetDir, "package.json");
+    const packageJson = await fs.promises.readFile(filePath, "utf-8");
+    const packageJsonContent = JSON.parse(packageJson);
+    packageJsonContent.dependencies.rwsdk = `file:${tarballPath}`;
+    await fs.promises.writeFile(filePath, JSON.stringify(packageJsonContent, null, 2));
+};
 /**
  * Sets up the test environment, preparing any resources needed for testing
  */
@@ -43,8 +64,7 @@ export async function setupTestEnvironment(options = {}) {
         // If a project dir is specified, copy it to a temp dir with a unique name
         if (options.projectDir) {
             log("Project directory specified: %s", options.projectDir);
-            const { tempDir, targetDir, workerName } = await copyProjectToTempDir(options.projectDir, options.sync !== false, // default to true if undefined
-            resourceUniqueKey, // Pass in the existing resourceUniqueKey
+            const { tempDir, targetDir, workerName } = await copyProjectToTempDir(options.projectDir, resourceUniqueKey, // Pass in the existing resourceUniqueKey
             options.packageManager);
             // Store cleanup function
             resources.tempDirCleanup = tempDir.cleanup;
@@ -67,118 +87,117 @@ export async function setupTestEnvironment(options = {}) {
 /**
  * Copy project to a temporary directory with a unique name
  */
-export async function copyProjectToTempDir(projectDir, sync = true, resourceUniqueKey, packageManager) {
-    log("Creating temporary directory for project");
-    // Create a temporary directory
-    const tempDir = await tmp.dir({ unsafeCleanup: true });
-    // Create unique project directory name
-    const originalDirName = basename(projectDir);
-    const workerName = `${originalDirName}-smoke-test-${resourceUniqueKey}`;
-    const targetDir = resolve(tempDir.path, workerName);
-    console.log(`Copying project from ${projectDir} to ${targetDir}`);
-    // Read project's .gitignore if it exists
-    let ig = ignore();
-    const gitignorePath = join(projectDir, ".gitignore");
-    if (await pathExists(gitignorePath)) {
-        log("Found .gitignore file at %s", gitignorePath);
-        const gitignoreContent = await fs.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(projectDir, targetDir, {
-        filter: (src) => {
-            // Get path relative to project directory
-            const relativePath = relative(projectDir, 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");
-    // For yarn, create .yarnrc.yml to disable PnP and use node_modules
-    if (packageManager === "yarn" || packageManager === "yarn-classic") {
-        const yarnrcPath = join(targetDir, ".yarnrc.yml");
-        await fs.writeFile(yarnrcPath, "nodeLinker: node-modules\n");
-        log("Created .yarnrc.yml to disable PnP for yarn");
-    }
-    // Replace workspace:* dependencies with a placeholder before installing
-    await replaceWorkspaceDependencies(targetDir);
-    // Install dependencies in the target directory
-    await installDependencies(targetDir, packageManager);
-    // Sync SDK to the temp dir if requested
-    if (sync) {
-        console.log(`🔄 Syncing SDK to ${targetDir} after installing dependencies...`);
-        await debugSync({ targetDir });
-    }
-    return { tempDir, targetDir, workerName };
-}
-/**
- * Replace workspace:* dependencies with a placeholder version to allow installation
- */
-async function replaceWorkspaceDependencies(targetDir) {
-    const packageJsonPath = join(targetDir, "package.json");
+export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager) {
+    const { tarballPath, cleanupTarball } = await createSdkTarball();
     try {
-        const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
-        const packageJson = JSON.parse(packageJsonContent);
-        let modified = false;
-        // Replace workspace:* dependencies with a placeholder version
-        if (packageJson.dependencies) {
-            for (const [name, version] of Object.entries(packageJson.dependencies)) {
-                if (version === "workspace:*") {
-                    packageJson.dependencies[name] = "0.0.80"; // Use latest published version as placeholder
-                    modified = true;
-                    log(`Replaced workspace dependency ${name} with placeholder version`);
-                }
-            }
+        log("Creating temporary directory for project");
+        // Create a temporary directory
+        const tempDir = await tmp.dir({ unsafeCleanup: true });
+        // Create unique project directory name
+        const originalDirName = basename(projectDir);
+        const workerName = `${originalDirName}-test-${resourceUniqueKey}`;
+        const targetDir = resolve(tempDir.path, workerName);
+        console.log(`Copying project from ${projectDir} to ${targetDir}`);
+        // Read project's .gitignore if it exists
+        let ig = ignore();
+        const gitignorePath = join(projectDir, ".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);
         }
-        if (packageJson.devDependencies) {
-            for (const [name, version] of Object.entries(packageJson.devDependencies)) {
-                if (version === "workspace:*") {
-                    packageJson.devDependencies[name] = "0.0.80"; // Use latest published version as placeholder
-                    modified = true;
-                    log(`Replaced workspace devDependency ${name} with placeholder version`);
-                }
-            }
+        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"));
         }
-        if (modified) {
-            await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-            log("Updated package.json with placeholder versions for workspace dependencies");
+        // Copy the project directory, respecting .gitignore
+        log("Starting copy process with ignored patterns");
+        await copy(projectDir, targetDir, {
+            filter: (src) => {
+                // Get path relative to project directory
+                const relativePath = relative(projectDir, 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");
+        // 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 yarnConfig = [
+                // todo(justinvdm, 23-09-23): Support yarn pnpm
+                "nodeLinker: node-modules",
+                "enableImmutableInstalls: false",
+            ].join("\n");
+            await fs.promises.writeFile(yarnrcPath, yarnConfig);
+            log("Created .yarnrc.yml to allow lockfile changes for yarn");
         }
+        await setTarballDependency(targetDir, tarballPath);
+        // Install dependencies in the target directory
+        await installDependencies(targetDir, packageManager);
+        // Return the environment details
+        return { tempDir, targetDir, workerName };
     }
-    catch (error) {
-        log("Error replacing workspace dependencies: %O", error);
-        throw new Error(`Failed to replace workspace dependencies: ${error}`);
+    finally {
+        await cleanupTarball();
     }
 }
-/**
- * Install project dependencies using pnpm
- */
 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 installCommand = {
             pnpm: ["pnpm", "install"],
             npm: ["npm", "install"],
-            yarn: ["yarn", "install", "--immutable"],
-            "yarn-classic": ["yarn", "install", "--immutable"],
+            yarn: ["yarn", "install"],
+            "yarn-classic": ["yarn"],
         }[packageManager];
         // Run install command in the target directory
         log(`Running ${installCommand.join(" ")}`);
@@ -186,6 +205,9 @@ async function installDependencies(targetDir, packageManager = "pnpm") {
         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

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

@@ -44,7 +44,7 @@ export declare function isRelatedToTest(resourceName: string, resourceUniqueKey:
 /**
  * Delete the worker using wrangler
  */
-export declare function deleteWorker(name: string, cwd: string, resourceUniqueKey: string): Promise<void>;
+export declare function deleteWorker(workerName: string, projectDir: string, resourceUniqueKey: string): Promise<void>;
 /**
  * List D1 databases using wrangler
  */

package/dist/lib/e2e/release.mjs

@@ -412,44 +412,53 @@ export function isRelatedToTest(resourceName, resourceUniqueKey) {
 /**
  * Delete the worker using wrangler
  */
-export async function deleteWorker(name, cwd, resourceUniqueKey) {
-    console.log(`Cleaning up: Deleting worker ${name}...`);
-    // Safety check: if we have a resourceUniqueKey, verify this worker name contains it
-    if (resourceUniqueKey && !isRelatedToTest(name, resourceUniqueKey)) {
-        log(`Worker ${name} does not contain unique key ${resourceUniqueKey}, not deleting for safety`);
-        console.log(`⚠️ Worker ${name} does not seem to be created by this test, skipping deletion for safety`);
+export async function deleteWorker(workerName, projectDir, resourceUniqueKey) {
+    console.log(`Cleaning up: Deleting worker ${workerName}...`);
+    // We are extra careful here to not delete workers that are not related to
+    // the current test run. We check if the worker name contains the resource
+    // unique key, and if the project directory also contains the resource unique
+    // key.
+    if (!isRelatedToTest(workerName, resourceUniqueKey)) {
+        console.warn(`⚠️ Worker name "${workerName}" does not contain resource unique key "${resourceUniqueKey}". Skipping delete.`);
         return;
     }
+    if (!isRelatedToTest(projectDir, resourceUniqueKey)) {
+        console.warn(`⚠️ Project dir "${projectDir}" does not contain resource unique key "${resourceUniqueKey}". Skipping delete.`);
+        return;
+    }
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+    const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+    if (!accountId || !apiToken) {
+        console.error("❌ CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN env vars must be set to delete worker");
+        return;
+    }
+    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/workers/scripts/${workerName}`;
+    console.log(`Running API call: DELETE ${url}`);
     try {
-        // Use our $expect utility to handle any confirmation prompts
-        log("Running wrangler delete command with interactive prompts");
-        await $expect(`npx wrangler delete ${name}`, [
-            {
-                expect: "Are you sure you want to delete",
-                send: "y\r",
+        const response = await fetch(url, {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${apiToken}`,
+                "Content-Type": "application/json",
             },
-        ], {
-            cwd,
         });
-        console.log(`✅ Worker ${name} deleted successfully`);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Cloudflare API request failed with status ${response.status}: ${errorText}`);
+        }
+        const responseData = (await response.json());
+        if (!responseData.success) {
+            throw new Error(`Cloudflare API returned an error: ${JSON.stringify(responseData.errors)}`);
+        }
+        console.log(`✅ Successfully deleted worker "${workerName}"`);
     }
     catch (error) {
-        console.error(`Failed to delete worker ${name}: ${error}`);
-        // Retry with force flag if the first attempt failed
-        try {
-            console.log("Retrying with force flag...");
-            await $expect(`npx wrangler delete ${name} --yes --force`, [
-                {
-                    expect: "Are you sure you want to delete",
-                    send: "y\r",
-                },
-            ], {
-                cwd,
-            });
-            console.log(`✅ Worker ${name} force deleted successfully`);
+        console.error(`❌ Failed to delete worker "${workerName}"`);
+        if (error instanceof Error) {
+            console.error(`Error message: ${error.message}`);
         }
-        catch (retryError) {
-            console.error(`Failed to force delete worker ${name}: ${retryError}`);
+        else {
+            console.error("An unknown error occurred:", error);
         }
     }
 }
@@ -487,6 +496,19 @@ export async function listD1Databases(cwd) {
  * Delete a D1 database using wrangler
  */
 export async function deleteD1Database(name, cwd, resourceUniqueKey) {
+    // Check wrangler.jsonc to see if a database is configured
+    const wranglerConfigPath = resolve(cwd, "wrangler.jsonc");
+    try {
+        const configContent = await fs.readFile(wranglerConfigPath, "utf-8");
+        const config = parseJsonc(configContent);
+        if (!config.d1_databases || config.d1_databases.length === 0) {
+            log("No D1 databases configured in wrangler.jsonc, skipping deletion.");
+            return;
+        }
+    }
+    catch (error) {
+        log(`Could not read or parse wrangler.jsonc at ${wranglerConfigPath}, proceeding with deletion attempt anyway.`, error);
+    }
     console.log(`Cleaning up: Deleting D1 database ${name}...`);
     try {
         // First check if the database exists

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

@@ -5,7 +5,6 @@ interface SetupTarballOptions {
 interface TarballEnvironment {
     targetDir: string;
     cleanup: () => Promise<void>;
-    tarballPath: string;
 }
 /**
  * Creates a tarball-based test environment similar to the release script approach

package/dist/lib/e2e/tarball.mjs

@@ -1,8 +1,10 @@
 import { $ } from "execa";
 import fs from "node:fs";
 import path from "node:path";
-import os from "node:os";
-import crypto from "node:crypto";
+import { copyProjectToTempDir } from "./environment.mjs";
+import { uniqueNamesGenerator, adjectives, animals, } from "unique-names-generator";
+import { createHash } from "crypto";
+import { ROOT_DIR } from "../constants.mjs";
 const log = (message) => console.log(message);
 /**
  * Copies wrangler cache from monorepo to temp directory for deployment tests
@@ -62,128 +64,36 @@ async function copyWranglerCache(targetDir, sdkRoot) {
  * Creates a tarball-based test environment similar to the release script approach
  */
 export async function setupTarballEnvironment({ projectDir, packageManager = "pnpm", }) {
-    // Generate unique temp directory name
-    const randomId = crypto.randomBytes(4).toString("hex");
-    const projectName = path.basename(projectDir);
-    const tempDirName = `${projectName}-e2e-test-${randomId}`;
-    const targetDir = path.join(os.tmpdir(), tempDirName);
-    log(`📁 Creating temp directory: ${targetDir}`);
-    // Create temp directory
-    await fs.promises.mkdir(targetDir, { recursive: true });
+    log(`🚀 Setting up tarball environment for ${projectDir}`);
+    // Generate a resource unique key for this test run
+    const uniqueNameSuffix = uniqueNamesGenerator({
+        dictionaries: [adjectives, animals],
+        separator: "-",
+        length: 2,
+        style: "lowerCase",
+    });
+    // Create a short unique hash based on the timestamp
+    const hash = createHash("md5")
+        .update(Date.now().toString())
+        .digest("hex")
+        .substring(0, 8);
+    const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
     try {
-        // Copy project to temp directory
-        log(`📋 Copying project from ${projectDir} to ${targetDir}`);
-        await $ `cp -a ${projectDir}/. ${targetDir}/`;
-        // Configure temp project to not use frozen lockfile
-        log(`⚙️  Configuring temp project to not use frozen lockfile...`);
-        const npmrcPath = path.join(targetDir, ".npmrc");
-        await fs.promises.writeFile(npmrcPath, "frozen-lockfile=false\n");
-        // Replace workspace:* dependencies with placeholder versions
-        log(`🔄 Replacing workspace dependencies...`);
-        const packageJsonPath = path.join(targetDir, "package.json");
-        const packageJsonContent = await fs.promises.readFile(packageJsonPath, "utf8");
-        const packageJson = JSON.parse(packageJsonContent);
-        // Replace workspace:* dependencies with a placeholder version
-        const replaceWorkspaceDeps = (deps) => {
-            if (!deps)
-                return;
-            for (const [name, version] of Object.entries(deps)) {
-                if (version === "workspace:*") {
-                    deps[name] = "0.0.80"; // Use a placeholder version that exists on npm
-                }
-            }
-        };
-        replaceWorkspaceDeps(packageJson.dependencies);
-        replaceWorkspaceDeps(packageJson.devDependencies);
-        replaceWorkspaceDeps(packageJson.peerDependencies);
-        await fs.promises.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-        // Find SDK root directory (relative to current working directory)
-        const currentDir = process.cwd();
-        const sdkRoot = currentDir.includes("/playground")
-            ? path.join(currentDir, "../sdk")
-            : currentDir;
-        // Pack the SDK
-        log(`📦 Packing SDK from ${sdkRoot}...`);
-        const packResult = await $({ cwd: sdkRoot }) `npm pack`;
-        const tarballName = packResult.stdout.trim();
-        const tarballPath = path.join(sdkRoot, tarballName);
-        // Install the tarball in the temp project
-        log(`💿 Installing tarball ${tarballName} in ${targetDir}...`);
-        if (packageManager === "pnpm") {
-            await $({ cwd: targetDir }) `pnpm add ${tarballPath}`;
-        }
-        else if (packageManager === "npm") {
-            await $({ cwd: targetDir }) `npm install ${tarballPath}`;
-        }
-        else if (packageManager === "yarn") {
-            await $({ cwd: targetDir }) `yarn add ${tarballPath}`;
-        }
-        else {
-            throw new Error(`Unsupported package manager: ${packageManager}`);
-        }
-        // Verify installation
-        const sdkPackageJson = JSON.parse(await fs.promises.readFile(path.join(sdkRoot, "package.json"), "utf8"));
-        const packageName = sdkPackageJson.name;
-        const installedDistPath = path.join(targetDir, "node_modules", packageName, "dist");
-        log(`🔍 Verifying installed package contents...`);
-        if (!fs.existsSync(installedDistPath)) {
-            throw new Error(`dist/ directory not found in installed package at ${installedDistPath}`);
-        }
-        // Compare checksums like the release script does
-        const originalDistPath = path.join(sdkRoot, "dist");
-        if (fs.existsSync(originalDistPath)) {
-            const getDistChecksum = async (distPath) => {
-                const findResult = await $({ cwd: distPath }) `find . -type f`;
-                const sortedFiles = findResult.stdout
-                    .trim()
-                    .split("\n")
-                    .sort()
-                    .join("\n");
-                return crypto.createHash("md5").update(sortedFiles).digest("hex");
-            };
-            const originalChecksum = await getDistChecksum(originalDistPath);
-            const installedChecksum = await getDistChecksum(installedDistPath);
-            log(`  - Original dist checksum: ${originalChecksum}`);
-            log(`  - Installed dist checksum: ${installedChecksum}`);
-            if (originalChecksum !== installedChecksum) {
-                throw new Error("File list in installed dist/ does not match original dist/");
-            }
-            log(`  ✅ Installed package contents match the local build`);
-        }
-        // Copy wrangler cache from monorepo to temp directory for deployment tests
+        const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager);
+        // Copy wrangler cache to improve deployment performance
+        const sdkRoot = ROOT_DIR;
         await copyWranglerCache(targetDir, sdkRoot);
-        // Cleanup function
-        const cleanup = async () => {
-            try {
-                // Remove tarball
-                if (fs.existsSync(tarballPath)) {
-                    await fs.promises.unlink(tarballPath);
-                }
-                // Remove temp directory
-                if (fs.existsSync(targetDir)) {
-                    await fs.promises.rm(targetDir, { recursive: true, force: true });
-                }
-            }
-            catch (error) {
-                console.warn(`Warning: Failed to cleanup temp files: ${error.message}`);
-            }
-        };
+        log(`✅ Tarball environment setup complete`);
         return {
             targetDir,
-            cleanup,
-            tarballPath,
+            cleanup: async () => {
+                log(`🧹 Cleaning up tarball environment: ${tempDir.path}`);
+                await tempDir.cleanup();
+            },
         };
     }
     catch (error) {
-        // Cleanup on error
-        try {
-            if (fs.existsSync(targetDir)) {
-                await fs.promises.rm(targetDir, { recursive: true, force: true });
-            }
-        }
-        catch (cleanupError) {
-            console.warn(`Warning: Failed to cleanup after error: ${cleanupError.message}`);
-        }
+        // Cleanup tarball on error
         throw error;
     }
 }

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

@@ -11,6 +11,7 @@ interface DeploymentInstance {
     url: string;
     workerName: string;
     resourceUniqueKey: string;
+    projectDir: string;
 }
 /**
  * Sets up a playground environment for the entire test suite.
@@ -44,6 +45,17 @@ export declare function cleanupDeployment(deployment: DeploymentInstance): Promi
  * Automatically registers cleanup to run after the test.
  */
 export declare function createBrowser(): Promise<Browser>;
+/**
+ * Executes a test function with a retry mechanism for specific error codes.
+ * @param name - The name of the test, used for logging.
+ * @param attemptFn - A function that executes one attempt of the test.
+ *                     It should set up resources, run the test logic, and
+ *                     return a cleanup function. The cleanup function will be
+ *                     called automatically on failure.
+ */
+export declare function runTestWithRetries(name: string, attemptFn: () => Promise<{
+    cleanup: () => Promise<void>;
+}>): Promise<void>;
 /**
  * High-level test wrapper for dev server tests.
  * Automatically skips if RWSDK_SKIP_DEV=1
@@ -56,6 +68,12 @@ export declare function testDev(name: string, testFn: (context: {
 }) => Promise<void>): void;
 export declare namespace testDev {
     var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testFn: (context: {
+        devServer: DevServerInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
 }
 /**
  * High-level test wrapper for deployment tests.
@@ -69,6 +87,12 @@ export declare function testDeploy(name: string, testFn: (context: {
 }) => Promise<void>): void;
 export declare namespace testDeploy {
     var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testFn: (context: {
+        deployment: DeploymentInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
 }
 /**
  * Unified test function that runs the same test against both dev server and deployment.
@@ -94,5 +118,6 @@ export declare namespace testDevAndDeploy {
 /**
  * Utility function for polling/retrying assertions
  */
-export declare function poll(fn: () => Promise<boolean>, timeout?: number, interval?: number): Promise<void>;
+export declare function poll(fn: () => Promise<boolean>, timeout?: number, // 2 minutes
+interval?: number): Promise<void>;
 export {};