rwsdk 1.0.0-alpha.5 → 1.0.0-alpha.7

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

@@ -0,0 +1,31 @@
+export type PackageManager = "pnpm" | "npm" | "yarn" | "yarn-classic";
+/**
+ * Options for smoke tests
+ */
+export interface SmokeTestOptions {
+    projectDir?: string;
+    artifactDir?: string;
+    headless?: boolean;
+    keep?: boolean;
+    sync?: boolean;
+    bail?: boolean;
+    skipDev?: boolean;
+    skipRelease?: boolean;
+    skipClient?: boolean;
+    packageManager?: PackageManager;
+    realtime?: boolean;
+    skipHmr?: boolean;
+    skipStyleTests?: boolean;
+}
+/**
+ * Resources created during a test run that need to be cleaned up
+ */
+export interface TestResources {
+    tempDirCleanup?: () => Promise<void>;
+    workerName?: string;
+    targetDir?: string;
+    originalCwd: string;
+    workerCreatedDuringTest: boolean;
+    stopDev?: () => Promise<void>;
+    resourceUniqueKey: string;
+}

package/dist/lib/e2e/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/smokeTests/browser.mjs

@@ -1,10 +1,5 @@
-import * as os from "os";
 import { join } from "path";
-import { pathExists } from "fs-extra";
 import { log } from "./constants.mjs";
-import { mkdirp } from "fs-extra";
-import { install, resolveBuildId, computeExecutablePath, detectBrowserPlatform, Browser as PuppeteerBrowser, } from "@puppeteer/browsers";
-import puppeteer from "puppeteer-core";
 import { takeScreenshot } from "./artifacts.mjs";
 import { RETRIES } from "./constants.mjs";
 import { $ } from "../$.mjs";
@@ -14,6 +9,7 @@ import { updateTestStatus } from "./state.mjs";
 import * as fs from "fs/promises";
 import { template as urlStylesTemplate } from "./templates/smokeTestUrlStyles.css.template";
 import { template as clientStylesTemplate } from "./templates/smokeTestClientStyles.module.css.template";
+import { launchBrowser as launchE2EBrowser, getBrowserPath as getE2EBrowserPath, } from "../../lib/e2e/browser.mjs";
 export async function checkUrlStyles(page, expectedColor) {
     const selector = '[data-testid="smoke-test-url-styles"]';
     log(`Checking for element with selector: ${selector}`);
@@ -86,100 +82,13 @@ export async function checkClientModuleStyles(page, expectedColor) {
  * 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();
-    }
-    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"],
-    });
+    return launchE2EBrowser(browserPath, headless);
 }
 /**
  * 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)...");
-            await install(installOptions);
-            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)}`);
-        }
-    }
+    return getE2EBrowserPath(testOptions);
 }
 /**
  * Check a URL by performing smoke tests and realtime upgrade

package/dist/lib/smokeTests/development.mjs

@@ -1,233 +1,12 @@
-import { setTimeout } from "node:timers/promises";
 import { log, RETRIES } from "./constants.mjs";
-import { $ } from "../$.mjs";
 import { checkUrl, checkServerUp, launchBrowser } from "./browser.mjs";
-import { fail } from "./utils.mjs";
 import { state } from "./state.mjs";
+import { runDevServer as runE2EDevServer } from "../../lib/e2e/dev.mjs";
 /**
  * Run the local development server and return the URL
  */
 export async function runDevServer(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) {
-            log("No dev process to stop");
-            return;
-        }
-        console.log("Stopping development server...");
-        try {
-            // Send a regular termination signal first
-            devProcess.kill();
-            // Wait for the process to terminate with a timeout
-            const terminationTimeout = 5000; // 5 seconds timeout
-            const terminationPromise = Promise.race([
-                // Wait for natural process termination
-                (async () => {
-                    try {
-                        await devProcess;
-                        log("Dev server process was terminated normally");
-                        return true;
-                    }
-                    catch (e) {
-                        // Expected error when the process is killed
-                        log("Dev server process was terminated");
-                        return true;
-                    }
-                })(),
-                // Or timeout
-                (async () => {
-                    await setTimeout(terminationTimeout);
-                    return false;
-                })(),
-            ]);
-            // Check if process terminated within timeout
-            const terminated = await terminationPromise;
-            // If not terminated within timeout, force kill
-            if (!terminated) {
-                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 to kill with SIGKILL if the process still has a pid
-                if (devProcess.pid) {
-                    try {
-                        // Use process.kill with SIGKILL for a stronger termination
-                        process.kill(devProcess.pid, "SIGKILL");
-                        log("Sent SIGKILL to process %d", devProcess.pid);
-                    }
-                    catch (killError) {
-                        log("Error sending SIGKILL to process: %O", killError);
-                        // Non-fatal, as the process might already be gone
-                    }
-                }
-            }
-        }
-        catch (e) {
-            // Process might already have exited
-            log("Could not kill dev server process: %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 };
-        // 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(state.options.packageManager || "npm");
-        // Use the provided cwd if available
-        devProcess = $({
-            all: true,
-            detached: false, // Keep attached so we can access streams
-            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) {
-                // Use fail() directly here to properly handle errors from the dev process
-                fail(error, 1, "Development Server Process");
-            }
-        });
-        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 setTimeout(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}`);
-        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;
-    }
+    return runE2EDevServer(state.options.packageManager, cwd);
 }
 /**
  * Runs tests against the development server

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

@@ -1,14 +1,7 @@
-import tmp from "tmp-promise";
-import { SmokeTestOptions, TestResources, PackageManager } from "./types.mjs";
+import { copyProjectToTempDir } from "../../lib/e2e/environment.mjs";
+import { SmokeTestOptions, TestResources } from "../../lib/e2e/types.mjs";
 /**
- * Sets up the test environment, preparing any resources needed for testing
+ * Sets up the test environment for smoke tests, preparing any resources needed for testing
  */
 export declare function setupTestEnvironment(options?: SmokeTestOptions): Promise<TestResources>;
-/**
- * Copy project to a temporary directory with a unique name
- */
-export declare function copyProjectToTempDir(projectDir: string, sync: boolean | undefined, resourceUniqueKey: string, packageManager?: PackageManager): Promise<{
-    tempDir: tmp.DirectoryResult;
-    targetDir: string;
-    workerName: string;
-}>;
+export { copyProjectToTempDir };

package/dist/lib/smokeTests/environment.mjs

@@ -1,164 +1,16 @@
-import { join } from "path";
-import { pathExists, copy } from "fs-extra";
-import * as fs from "fs/promises";
-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 { log } from "./constants.mjs";
-import { debugSync } from "../../scripts/debug-sync.mjs";
+import { setupTestEnvironment as setupE2ETestEnvironment, copyProjectToTempDir, } from "../../lib/e2e/environment.mjs";
 import { createSmokeTestComponents } from "./codeUpdates.mjs";
-import { createHash } from "crypto";
+import { log } from "./constants.mjs";
 /**
- * Sets up the test environment, preparing any resources needed for testing
+ * Sets up the test environment for smoke tests, preparing any resources needed for testing
  */
 export async function setupTestEnvironment(options = {}) {
-    log("Setting up test environment with options: %O", options);
-    // Generate a resource unique key for this test run right at the start
-    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);
-    // Create a resource unique key even if we're not copying a project
-    const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
-    const resources = {
-        tempDirCleanup: undefined,
-        workerName: undefined,
-        originalCwd: process.cwd(),
-        targetDir: undefined,
-        workerCreatedDuringTest: false,
-        stopDev: undefined,
-        resourceUniqueKey, // Set at initialization
-    };
-    log("Current working directory: %s", resources.originalCwd);
-    try {
-        // 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
-            options.packageManager);
-            // Store cleanup function
-            resources.tempDirCleanup = tempDir.cleanup;
-            resources.workerName = workerName;
-            resources.targetDir = targetDir;
-            log("Target directory: %s", targetDir);
-            // Create the smoke test components in the user's project
-            log("Creating smoke test components");
-            await createSmokeTestComponents(targetDir, options.skipClient);
-        }
-        else {
-            log("No project directory specified, using current directory");
-            // When no project dir is specified, we'll use the current directory
-            resources.targetDir = resources.originalCwd;
-        }
-        return resources;
-    }
-    catch (error) {
-        log("Error during test environment setup: %O", error);
-        throw error;
-    }
-}
-/**
- * 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");
-    }
-    // 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 };
-}
-/**
- * Install project dependencies using pnpm
- */
-async function installDependencies(targetDir, packageManager = "pnpm") {
-    console.log(`📦 Installing project dependencies in ${targetDir} using ${packageManager}...`);
-    try {
-        const installCommand = {
-            pnpm: ["pnpm", "install"],
-            npm: ["npm", "install"],
-            yarn: ["yarn", "install", "--immutable"],
-            "yarn-classic": ["yarn", "install", "--immutable"],
-        }[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
-        });
-        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}.`);
+    const resources = await setupE2ETestEnvironment(options);
+    if (resources.targetDir) {
+        // Create the smoke test components in the user's project
+        log("Creating smoke test components");
+        await createSmokeTestComponents(resources.targetDir, options.skipClient);
     }
+    return resources;
 }
+export { copyProjectToTempDir };

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

@@ -1,35 +1,6 @@
 import { TestResources } from "./types.mjs";
-interface ExpectOptions {
-    expect: string | RegExp;
-    send?: string;
-}
-interface ExpectResult {
-    stdout: string;
-    stderr: string;
-    code: number | null;
-}
-interface D1Database {
-    name: string;
-    uuid: string;
-    [key: string]: any;
-}
-/**
- * A mini expect-like utility for handling interactive CLI prompts and verifying output
- * @param command The command to execute
- * @param expectations Array of {expect, send} objects for interactive responses and verification
- * @param options Additional options for command execution including working directory and environment
- * @returns Promise that resolves when the command completes
- */
-export declare function $expect(command: string, expectations: Array<ExpectOptions>, options?: {
-    reject?: boolean;
-    env?: NodeJS.ProcessEnv;
-    cwd?: string;
-}): Promise<ExpectResult>;
-/**
- * Ensures Cloudflare account ID is set in environment
- * First checks wrangler cache, then environment variables, and finally guides the user
- */
-export declare function ensureCloudflareAccountId(cwd?: string, projectDir?: string): Promise<void>;
+import { deleteWorker, deleteD1Database, isRelatedToTest, $expect, listD1Databases } from "../../lib/e2e/release.mjs";
+export { deleteWorker, deleteD1Database, isRelatedToTest, $expect, listD1Databases, };
 /**
  * Run the release command to deploy to Cloudflare
  */
@@ -41,21 +12,3 @@ export declare function runRelease(cwd: string, projectDir: string, resourceUniq
  * Runs tests against the production deployment
  */
 export declare function runReleaseTest(artifactDir: string, resources: TestResources, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, projectDir?: string, realtime?: boolean, skipHmr?: boolean, skipStyleTests?: boolean): Promise<void>;
-/**
- * Check if a resource name includes a specific resource unique key
- * This is used to identify resources created during our tests
- */
-export declare function isRelatedToTest(resourceName: string, resourceUniqueKey: string): boolean;
-/**
- * Delete the worker using wrangler
- */
-export declare function deleteWorker(name: string, cwd: string, resourceUniqueKey: string): Promise<void>;
-/**
- * List D1 databases using wrangler
- */
-export declare function listD1Databases(cwd?: string): Promise<Array<D1Database>>;
-/**
- * Delete a D1 database using wrangler
- */
-export declare function deleteD1Database(name: string, cwd: string, resourceUniqueKey: string): Promise<void>;
-export {};