rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/lib/smokeTests/reporting.mjs

@@ -0,0 +1,355 @@
+import { join, basename } from "path";
+import { writeFile } from "fs/promises";
+import { mkdirp } from "fs-extra";
+import { log } from "./constants.mjs";
+import { state } from "./state.mjs";
+/**
+ * Maps a test status to a display string with emoji
+ */
+function formatTestStatus(status) {
+    switch (status) {
+        case "PASSED":
+            return "✅ PASSED";
+        case "FAILED":
+            return "❌ FAILED";
+        case "SKIPPED":
+            return "⏩ SKIPPED";
+        case "DID_NOT_RUN":
+            return "⚠️ DID NOT RUN";
+        default:
+            return "❓ UNKNOWN";
+    }
+}
+/**
+ * Generates the final test report without doing any resource cleanup.
+ */
+export async function generateFinalReport() {
+    try {
+        // Helper function to check if a failure matches the specified patterns
+        function failureMatches(failure, patterns, notPatterns = []) {
+            // Check if any of the patterns match in either step or error
+            const matchesPattern = patterns.some((pattern) => failure.step.includes(pattern) ||
+                (failure.error && failure.error.includes(pattern)));
+            // Check if any of the not-patterns match in either step or error
+            const matchesNotPattern = notPatterns.some((pattern) => failure.step.includes(pattern) ||
+                (failure.error && failure.error.includes(pattern)));
+            // Return true if it matches a pattern and doesn't match any not-pattern
+            return matchesPattern && !matchesNotPattern;
+        }
+        // Create a report object
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const report = {
+            timestamp,
+            success: state.exitCode === 0,
+            exitCode: state.exitCode,
+            workerName: (state.resources.workerName || null),
+            projectDir: state.options.artifactDir
+                ? join(state.options.artifactDir, "project")
+                : null,
+            logFiles: state.options.artifactDir
+                ? {
+                    stdout: join(state.options.artifactDir, "logs", `stdout-${timestamp}.log`),
+                    stderr: join(state.options.artifactDir, "logs", `stderr-${timestamp}.log`),
+                    combined: join(state.options.artifactDir, "logs", `combined-${timestamp}.log`),
+                }
+                : null,
+            failures: state.failures,
+            options: {
+                customPath: state.options.customPath,
+                skipDev: state.options.skipDev,
+                skipRelease: state.options.skipRelease,
+                skipClient: state.options.skipClient,
+            },
+            testStatus: state.testStatus,
+        };
+        // Always print the report to console in a pretty format
+        console.log("\n==================================================");
+        console.log("                📊 SMOKE TEST REPORT              ");
+        console.log("==================================================");
+        console.log("--------------------------------------------------");
+        console.log(`Timestamp: ${timestamp}`);
+        console.log(`Status: ${report.success ? "✅ PASSED" : "❌ FAILED"}`);
+        console.log(`Exit code: ${state.exitCode}`);
+        if (report.workerName) {
+            console.log(`Worker name: ${report.workerName}`);
+        }
+        console.log(`Test options:`);
+        console.log(`  - Custom path: ${report.options.customPath || "/"}`);
+        console.log(`  - Skip dev: ${report.options.skipDev ? "Yes" : "No"}`);
+        console.log(`  - Skip release: ${report.options.skipRelease ? "Yes" : "No"}`);
+        console.log(`  - Skip client: ${report.options.skipClient ? "Yes" : "No"}`);
+        // Add info about log files
+        if (report.logFiles) {
+            console.log(`Log files:`);
+            console.log(`  - stdout: ${basename(report.logFiles.stdout)}`);
+            console.log(`  - stderr: ${basename(report.logFiles.stderr)}`);
+            console.log(`  - combined: ${basename(report.logFiles.combined)}`);
+        }
+        console.log("--------------------------------------------------");
+        // Add summary of failures count
+        if (state.failures.length > 0) {
+            console.log(`\n❌ Failed tests: ${state.failures.length}`);
+        }
+        else if (report.success) {
+            console.log("\n✅ All smoke tests passed successfully!");
+        }
+        // Group failures by step to determine which stages had issues
+        const devFailures = state.failures.filter((f) => failureMatches(f, ["Development", "Development Server", "Development -"]));
+        const releaseFailures = state.failures.filter((f) => failureMatches(f, ["Production", "Release", "Production -"]));
+        // Add hierarchical test results overview
+        console.log("\n==================================================");
+        console.log("              🔍 TEST RESULTS SUMMARY              ");
+        console.log("==================================================");
+        // Dev tests summary using the new testStatus system
+        console.log(`● Development Tests: ${formatTestStatus(state.testStatus.dev.overall)}`);
+        // Only show details if the overall test status is not "SKIPPED" or "DID_NOT_RUN"
+        if (state.testStatus.dev.overall !== "SKIPPED" &&
+            state.testStatus.dev.overall !== "DID_NOT_RUN") {
+            console.log(`  ├─ Initial Tests:`);
+            console.log(`  │  ├─ Server-side: ${formatTestStatus(state.testStatus.dev.initialServerSide)}`);
+            console.log(`  │  ├─ Client-side: ${formatTestStatus(state.testStatus.dev.initialClientSide)}`);
+            console.log(`  │  ├─ Server Render Check: ${formatTestStatus(state.testStatus.dev.initialServerRenderCheck)}`);
+            console.log(`  │  ├─ Server HMR: ${formatTestStatus(state.testStatus.dev.initialServerHmr)}`);
+            console.log(`  │  └─ Client HMR: ${formatTestStatus(state.testStatus.dev.initialClientHmr)}`);
+            console.log(`  └─ Realtime Tests:`);
+            console.log(`     ├─ Upgrade: ${formatTestStatus(state.testStatus.dev.realtimeUpgrade)}`);
+            console.log(`     ├─ Server-side: ${formatTestStatus(state.testStatus.dev.realtimeServerSide)}`);
+            console.log(`     ├─ Client-side: ${formatTestStatus(state.testStatus.dev.realtimeClientSide)}`);
+            console.log(`     ├─ Server Render Check: ${formatTestStatus(state.testStatus.dev.realtimeServerRenderCheck)}`);
+            console.log(`     ├─ Server HMR: ${formatTestStatus(state.testStatus.dev.realtimeServerHmr)}`);
+            console.log(`     └─ Client HMR: ${formatTestStatus(state.testStatus.dev.realtimeClientHmr)}`);
+        }
+        // Production tests summary using the new testStatus system
+        console.log(`● Production Tests: ${formatTestStatus(state.testStatus.production.overall)}`);
+        // Only show details if the overall test status is not "SKIPPED" or "DID_NOT_RUN"
+        if (state.testStatus.production.overall !== "SKIPPED" &&
+            state.testStatus.production.overall !== "DID_NOT_RUN") {
+            console.log(`  ├─ Release Command: ${formatTestStatus(state.testStatus.production.releaseCommand)}`);
+            // Only show these if release command was either not run or passed
+            if (state.testStatus.production.releaseCommand !== "FAILED") {
+                console.log(`  ├─ Initial Tests:`);
+                console.log(`  │  ├─ Server-side: ${formatTestStatus(state.testStatus.production.initialServerSide)}`);
+                console.log(`  │  ├─ Client-side: ${formatTestStatus(state.testStatus.production.initialClientSide)}`);
+                console.log(`  │  └─ Server Render Check: ${formatTestStatus(state.testStatus.production.initialServerRenderCheck)}`);
+                console.log(`  └─ Realtime Tests:`);
+                console.log(`     ├─ Upgrade: ${formatTestStatus(state.testStatus.production.realtimeUpgrade)}`);
+                console.log(`     ├─ Server-side: ${formatTestStatus(state.testStatus.production.realtimeServerSide)}`);
+                console.log(`     ├─ Client-side: ${formatTestStatus(state.testStatus.production.realtimeClientSide)}`);
+                console.log(`     └─ Server Render Check: ${formatTestStatus(state.testStatus.production.realtimeServerRenderCheck)}`);
+            }
+            else {
+                console.log(`  └─ Tests: ⏩ SKIPPED (release command failed)`);
+            }
+        }
+        // Add failures to the report file if we have a valid artifactDir
+        if (state.options.artifactDir) {
+            try {
+                // Ensure the directory exists, even if it was not created earlier
+                await mkdirp(state.options.artifactDir);
+                // Use the standardized reports directory
+                const reportDir = join(state.options.artifactDir, "reports");
+                // Ensure the directory exists
+                await mkdirp(reportDir);
+                const reportPath = join(reportDir, `smoke-test-report-${timestamp}.json`);
+                await writeFile(reportPath, JSON.stringify(report, null, 2));
+                console.log(`\n📝 Report saved to ${reportPath}`);
+            }
+            catch (reportError) {
+                console.error(`⚠️ Could not save report to file: ${reportError instanceof Error ? reportError.message : String(reportError)}`);
+            }
+        }
+        else {
+            console.log("\n⚠️ No artifacts directory specified, report not saved to disk");
+        }
+        // Report failures with clear environment context
+        if (state.failures.length > 0) {
+            console.log("\n==================================================");
+            console.log("              🔍 FAILURE DETAILS                  ");
+            console.log("==================================================");
+            // Group failures by environment (Dev vs Release)
+            if (devFailures.length > 0) {
+                console.log("----------------- DEVELOPMENT ENVIRONMENT -----------------");
+                devFailures.forEach((failure, index) => {
+                    console.log(`Failure #${index + 1}: ${failure.step}`);
+                    // Split error message into lines if it's long
+                    const errorLines = failure.error.split("\n");
+                    console.log(`Error: ${errorLines[0]}`);
+                    for (let i = 1; i < errorLines.length; i++) {
+                        console.log(`       ${errorLines[i]}`);
+                    }
+                    console.log(``);
+                });
+                console.log(`--------------------------------------------------`);
+            }
+            if (releaseFailures.length > 0) {
+                console.log("----------------- PRODUCTION ENVIRONMENT -----------------");
+                releaseFailures.forEach((failure, index) => {
+                    console.log(`Failure #${index + 1}: ${failure.step}`);
+                    // Split error message into lines if it's long
+                    const errorLines = failure.error.split("\n");
+                    console.log(`Error: ${errorLines[0]}`);
+                    for (let i = 1; i < errorLines.length; i++) {
+                        console.log(`       ${errorLines[i]}`);
+                    }
+                    console.log(``);
+                });
+                console.log(`--------------------------------------------------`);
+            }
+            // Show other failures that don't fit into the above categories
+            const otherFailures = state.failures.filter((f) => !devFailures.includes(f) && !releaseFailures.includes(f));
+            if (otherFailures.length > 0) {
+                console.log("----------------- OTHER FAILURES -----------------");
+                otherFailures.forEach((failure, index) => {
+                    console.log(`Failure #${index + 1}: ${failure.step}`);
+                    // Split error message into lines if it's long
+                    const errorLines = failure.error.split("\n");
+                    console.log(`Error: ${errorLines[0]}`);
+                    for (let i = 1; i < errorLines.length; i++) {
+                        console.log(`       ${errorLines[i]}`);
+                    }
+                    console.log(``);
+                });
+                console.log(`--------------------------------------------------`);
+            }
+        }
+    }
+    catch (error) {
+        // Last resort error handling
+        console.error("❌ Failed to generate report:", error);
+    }
+}
+/**
+ * Updates the test status in the state object and reports the result.
+ */
+export function reportSmokeTestResult(result, type, phase = "", environment = "Development") {
+    const phasePrefix = phase ? `(${phase}) ` : "";
+    log("Reporting %s%s smoke test result: %O", phasePrefix, type, result);
+    if (result.verificationPassed) {
+        console.log(`✅ ${phasePrefix}${type} smoke test passed!`);
+        if (result.serverTimestamp) {
+            console.log(`✅ Server timestamp: ${result.serverTimestamp}`);
+        }
+        if (result.clientTimestamp) {
+            console.log(`✅ Client timestamp: ${result.clientTimestamp}`);
+        }
+    }
+    else {
+        log("ERROR: %s%s smoke test failed. Status: %s. Error: %s", phasePrefix, type, result.status, result.error || "unknown");
+        // The actual state update and error throwing is now handled by the caller functions
+        // We only need to report the result in the console
+        console.error(`❌ ${phasePrefix}${type} smoke test failed. Status: ${result.status}${result.error ? `. Error: ${result.error}` : ""}`);
+    }
+}
+/**
+ * Initialize test statuses based on test options
+ */
+export function initializeTestStatus() {
+    // Set default status for all tests as "DID_NOT_RUN"
+    // Dev tests
+    state.testStatus.dev.overall = "DID_NOT_RUN";
+    state.testStatus.dev.initialServerSide = "DID_NOT_RUN";
+    state.testStatus.dev.initialClientSide = "DID_NOT_RUN";
+    state.testStatus.dev.initialServerRenderCheck = "DID_NOT_RUN";
+    state.testStatus.dev.realtimeUpgrade = "DID_NOT_RUN";
+    state.testStatus.dev.realtimeServerSide = "DID_NOT_RUN";
+    state.testStatus.dev.realtimeClientSide = "DID_NOT_RUN";
+    state.testStatus.dev.realtimeServerRenderCheck = "DID_NOT_RUN";
+    state.testStatus.dev.initialServerHmr = "DID_NOT_RUN";
+    state.testStatus.dev.initialClientHmr = "DID_NOT_RUN";
+    state.testStatus.dev.realtimeServerHmr = "DID_NOT_RUN";
+    state.testStatus.dev.realtimeClientHmr = "DID_NOT_RUN";
+    // Production tests
+    state.testStatus.production.overall = "DID_NOT_RUN";
+    state.testStatus.production.releaseCommand = "DID_NOT_RUN";
+    state.testStatus.production.initialServerSide = "DID_NOT_RUN";
+    state.testStatus.production.initialClientSide = "DID_NOT_RUN";
+    state.testStatus.production.initialServerRenderCheck = "DID_NOT_RUN";
+    state.testStatus.production.realtimeUpgrade = "DID_NOT_RUN";
+    state.testStatus.production.realtimeServerSide = "DID_NOT_RUN";
+    state.testStatus.production.realtimeClientSide = "DID_NOT_RUN";
+    state.testStatus.production.realtimeServerRenderCheck = "DID_NOT_RUN";
+    state.testStatus.production.initialServerHmr = "DID_NOT_RUN";
+    state.testStatus.production.initialClientHmr = "DID_NOT_RUN";
+    state.testStatus.production.realtimeServerHmr = "DID_NOT_RUN";
+    state.testStatus.production.realtimeClientHmr = "DID_NOT_RUN";
+    // Now override with specific statuses based on options
+    // Mark skipped tests based on options
+    if (state.options.skipDev) {
+        state.testStatus.dev.overall = "SKIPPED";
+        state.testStatus.dev.initialServerSide = "SKIPPED";
+        state.testStatus.dev.initialClientSide = "SKIPPED";
+        state.testStatus.dev.initialServerRenderCheck = "SKIPPED";
+        state.testStatus.dev.realtimeUpgrade = "SKIPPED";
+        state.testStatus.dev.realtimeServerSide = "SKIPPED";
+        state.testStatus.dev.realtimeClientSide = "SKIPPED";
+        state.testStatus.dev.realtimeServerRenderCheck = "SKIPPED";
+        state.testStatus.dev.initialServerHmr = "SKIPPED";
+        state.testStatus.dev.initialClientHmr = "SKIPPED";
+        state.testStatus.dev.realtimeServerHmr = "SKIPPED";
+        state.testStatus.dev.realtimeClientHmr = "SKIPPED";
+    }
+    if (state.options.skipRelease) {
+        state.testStatus.production.overall = "SKIPPED";
+        state.testStatus.production.releaseCommand = "SKIPPED";
+        state.testStatus.production.initialServerSide = "SKIPPED";
+        state.testStatus.production.initialClientSide = "SKIPPED";
+        state.testStatus.production.initialServerRenderCheck = "SKIPPED";
+        state.testStatus.production.realtimeUpgrade = "SKIPPED";
+        state.testStatus.production.realtimeServerSide = "SKIPPED";
+        state.testStatus.production.realtimeClientSide = "SKIPPED";
+        state.testStatus.production.realtimeServerRenderCheck = "SKIPPED";
+        state.testStatus.production.initialServerHmr = "SKIPPED";
+        state.testStatus.production.initialClientHmr = "SKIPPED";
+        state.testStatus.production.realtimeServerHmr = "SKIPPED";
+        state.testStatus.production.realtimeClientHmr = "SKIPPED";
+    }
+    if (state.options.skipClient) {
+        state.testStatus.dev.initialClientSide = "SKIPPED";
+        state.testStatus.dev.realtimeClientSide = "SKIPPED";
+        state.testStatus.production.initialClientSide = "SKIPPED";
+        state.testStatus.production.realtimeClientSide = "SKIPPED";
+        state.testStatus.dev.initialServerRenderCheck = "SKIPPED";
+        state.testStatus.dev.realtimeServerRenderCheck = "SKIPPED";
+        state.testStatus.production.initialServerRenderCheck = "SKIPPED";
+        state.testStatus.production.realtimeServerRenderCheck = "SKIPPED";
+        state.testStatus.dev.initialClientHmr = "SKIPPED";
+        state.testStatus.dev.realtimeClientHmr = "SKIPPED";
+        state.testStatus.production.initialClientHmr = "SKIPPED";
+        state.testStatus.production.realtimeClientHmr = "SKIPPED";
+    }
+    // Skip HMR tests in production and when requested
+    state.testStatus.production.initialServerHmr = "SKIPPED";
+    state.testStatus.production.initialClientHmr = "SKIPPED";
+    state.testStatus.production.realtimeServerHmr = "SKIPPED";
+    state.testStatus.production.realtimeClientHmr = "SKIPPED";
+    if (state.options.skipHmr) {
+        state.testStatus.dev.initialServerHmr = "SKIPPED";
+        state.testStatus.dev.initialClientHmr = "SKIPPED";
+        state.testStatus.dev.realtimeServerHmr = "SKIPPED";
+        state.testStatus.dev.realtimeClientHmr = "SKIPPED";
+    }
+    // Handle realtime option which skips initial tests
+    if (state.options.realtime) {
+        // In realtime mode, initial tests are skipped
+        if (!state.options.skipDev) {
+            state.testStatus.dev.initialServerSide = "SKIPPED";
+            state.testStatus.dev.initialClientSide = "SKIPPED";
+            state.testStatus.dev.initialServerRenderCheck = "SKIPPED";
+            state.testStatus.dev.initialServerHmr = "SKIPPED";
+            state.testStatus.dev.initialClientHmr = "SKIPPED";
+            // Set the upgrade test to PASSED as it's implicitly run for realtime mode
+            state.testStatus.dev.realtimeUpgrade = "PASSED";
+        }
+        if (!state.options.skipRelease) {
+            state.testStatus.production.initialServerSide = "SKIPPED";
+            state.testStatus.production.initialClientSide = "SKIPPED";
+            state.testStatus.production.initialServerRenderCheck = "SKIPPED";
+            state.testStatus.production.initialServerHmr = "SKIPPED";
+            state.testStatus.production.initialClientHmr = "SKIPPED";
+            // Set release command to PASSED since it must have succeeded for realtime tests to run
+            state.testStatus.production.releaseCommand = "PASSED";
+            // Set the upgrade test to PASSED as it's implicitly run for realtime mode
+            state.testStatus.production.realtimeUpgrade = "PASSED";
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import { SmokeTestOptions } from "./types.mjs";
+/**
+ * Main function that orchestrates the smoke test flow
+ */
+export declare function runSmokeTests(options?: SmokeTestOptions): Promise<void>;

package/dist/lib/smokeTests/runSmokeTests.mjs

@@ -0,0 +1,144 @@
+import { join } from "path";
+import { getBrowserPath } from "./browser.mjs";
+import { setupArtifactsDirectory } from "./artifacts.mjs";
+import { setupTestEnvironment } from "./environment.mjs";
+import { runDevServer, runDevTest } from "./development.mjs";
+import { runReleaseTest } from "./release.mjs";
+import { fail, teardown, log } from "./utils.mjs";
+import { state, updateTestStatus } from "./state.mjs";
+import { initializeTestStatus } from "./reporting.mjs";
+/**
+ * Main function that orchestrates the smoke test flow
+ */
+export async function runSmokeTests(options = {}) {
+    log("Starting smoke test with options: %O", options);
+    // Store options in state immediately for force report generation if needed
+    state.options = options;
+    // Initialize test status based on options
+    initializeTestStatus();
+    // Set default artifacts directory if not specified
+    if (!options.artifactDir) {
+        options.artifactDir = join(process.cwd(), ".artifacts");
+        log("Using default artifacts directory: %s", options.artifactDir);
+        // Update state.options with the default value
+        state.options.artifactDir = options.artifactDir;
+    }
+    // Clean and recreate artifacts directory
+    await setupArtifactsDirectory(options.artifactDir, options);
+    log("Initialized log capturing to artifact files");
+    // Throw immediately if both tests would be skipped
+    if (options.skipDev && options.skipRelease) {
+        log("Error: Both dev and release tests are skipped");
+        await fail(new Error("Cannot skip both dev and release tests. At least one must run."), 1, "Configuration");
+    }
+    // Prepare browser early to avoid waiting later
+    console.log("🔍 Preparing browser for testing...");
+    let browserPath;
+    try {
+        browserPath = await getBrowserPath(options);
+        console.log(`✅ Browser ready at: ${browserPath}`);
+    }
+    catch (error) {
+        await fail(error, 1, "Browser Preparation");
+    }
+    log("Setting up test environment");
+    try {
+        const resources = await setupTestEnvironment(options);
+        // Store resources in module-level state
+        state.resources = resources;
+        // Track failures to determine final exit code
+        let hasFailures = false;
+        // Run the tests that weren't skipped
+        if (!options.skipDev) {
+            log("Starting development server");
+            try {
+                // Start the dev server first, store the stop function in resources
+                const { url, stopDev } = await runDevServer(resources.targetDir);
+                resources.stopDev = stopDev;
+                state.resources.stopDev = stopDev;
+                log("Running development server tests");
+                await runDevTest(url, options.artifactDir, options.customPath, browserPath, options.headless !== false, options.bail, options.skipClient, options.realtime, options.skipHmr);
+                // Mark that dev tests have run successfully
+                state.devTestsRan = true;
+                // Update the overall dev test status to PASSED
+                state.testStatus.dev.overall = "PASSED";
+            }
+            catch (error) {
+                hasFailures = true;
+                log("Error during development server testing: %O", error);
+                console.error(`❌ Development server test failed: ${error instanceof Error ? error.message : String(error)}`);
+                // Record the failure
+                state.failures.push({
+                    step: "Development Server Test",
+                    error: error instanceof Error ? error.message : String(error),
+                    details: error instanceof Error && error.stack ? error.stack : undefined,
+                });
+                // Mark overall dev test status as FAILED
+                state.testStatus.dev.overall = "FAILED";
+                // If bail option is true, stop the tests
+                if (options.bail) {
+                    await fail(error, 1, "Development Server Test");
+                }
+                // Otherwise, continue with the release test
+                console.log("Continuing with next tests since --bail is not enabled...");
+            }
+        }
+        else {
+            log("Skipping development server tests");
+        }
+        if (!options.skipRelease) {
+            if (options.realtime) {
+                // If --realtime flag is set, status is already set in initializeTestStatus
+                console.log("⏩ Using realtime mode for Production tests (--realtime option enabled)");
+            }
+            else {
+                // Update status when release command runs
+                try {
+                    console.log("\n🚀 Running release command smoke test");
+                    await runReleaseTest(options.customPath, options.artifactDir, resources, browserPath, options.headless !== false, options.bail, options.skipClient, options.projectDir, options.realtime, options.skipHmr);
+                    // Update release command status to PASSED
+                    updateTestStatus("production", "releaseCommand", "PASSED");
+                    // Mark that release tests have run successfully
+                    state.releaseTestsRan = true;
+                    // Update the overall production test status to PASSED
+                    state.testStatus.production.overall = "PASSED";
+                }
+                catch (error) {
+                    // Update release command status to FAILED
+                    updateTestStatus("production", "releaseCommand", "FAILED");
+                    hasFailures = true;
+                    log("Error during release testing: %O", error);
+                    console.error(`❌ Release test failed: ${error instanceof Error ? error.message : String(error)}`);
+                    // Record the failure
+                    state.failures.push({
+                        step: "Release Test",
+                        error: error instanceof Error ? error.message : String(error),
+                        details: error instanceof Error && error.stack ? error.stack : undefined,
+                    });
+                    // Mark overall production test status as FAILED
+                    state.testStatus.production.overall = "FAILED";
+                    // If bail option is true, stop the tests
+                    if (options.bail) {
+                        await fail(error, 1, "Release Test");
+                    }
+                }
+            }
+        }
+        else {
+            log("Skipping release/production tests");
+        }
+        // Set the exit code based on whether there were failures
+        if (hasFailures) {
+            state.exitCode = 1;
+            console.log("\n⚠️ Some smoke tests failed, but continued running since --bail was not enabled.");
+        }
+        else {
+            console.log("\n✅ All smoke tests passed!");
+        }
+        // Call teardown with the final exit code
+        await teardown();
+    }
+    catch (error) {
+        await fail(error, 1, "Test Environment Setup");
+    }
+}

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

@@ -0,0 +1,48 @@
+import { SmokeTestOptions, TestResources } from "./types.mjs";
+export type TestStatusValue = "SKIPPED" | "DID_NOT_RUN" | "PASSED" | "FAILED";
+export interface TestStatus {
+    dev: {
+        overall: TestStatusValue;
+        initialServerSide: TestStatusValue;
+        initialClientSide: TestStatusValue;
+        initialServerRenderCheck: TestStatusValue;
+        realtimeUpgrade: TestStatusValue;
+        realtimeServerSide: TestStatusValue;
+        realtimeClientSide: TestStatusValue;
+        realtimeServerRenderCheck: TestStatusValue;
+        initialServerHmr: TestStatusValue;
+        initialClientHmr: TestStatusValue;
+        realtimeServerHmr: TestStatusValue;
+        realtimeClientHmr: TestStatusValue;
+    };
+    production: {
+        overall: TestStatusValue;
+        releaseCommand: TestStatusValue;
+        initialServerSide: TestStatusValue;
+        initialClientSide: TestStatusValue;
+        initialServerRenderCheck: TestStatusValue;
+        realtimeUpgrade: TestStatusValue;
+        realtimeServerSide: TestStatusValue;
+        realtimeClientSide: TestStatusValue;
+        realtimeServerRenderCheck: TestStatusValue;
+        initialServerHmr: TestStatusValue;
+        initialClientHmr: TestStatusValue;
+        realtimeServerHmr: TestStatusValue;
+        realtimeClientHmr: TestStatusValue;
+    };
+}
+export declare const state: {
+    isTearingDown: boolean;
+    exitCode: number;
+    resources: TestResources;
+    options: SmokeTestOptions;
+    failures: {
+        step: string;
+        error: string;
+        details?: string;
+    }[];
+    devTestsRan: boolean;
+    releaseTestsRan: boolean;
+    testStatus: TestStatus;
+};
+export declare function updateTestStatus(env: "dev" | "production", test: keyof TestStatus["dev"] | keyof TestStatus["production"], status: TestStatusValue): void;

package/dist/lib/smokeTests/state.mjs

@@ -0,0 +1,57 @@
+// Module-level state to track resources and teardown status
+export const state = {
+    isTearingDown: false,
+    exitCode: 0,
+    resources: {
+        tempDirCleanup: undefined,
+        workerName: undefined,
+        originalCwd: process.cwd(),
+        targetDir: undefined,
+        workerCreatedDuringTest: false,
+        stopDev: undefined,
+    },
+    options: {},
+    // Add a new failures array to track all failures
+    failures: [],
+    // Track whether tests have actually run
+    devTestsRan: false,
+    releaseTestsRan: false,
+    // New detailed test status tracking
+    testStatus: {
+        dev: {
+            overall: "DID_NOT_RUN",
+            initialServerSide: "DID_NOT_RUN",
+            initialClientSide: "DID_NOT_RUN",
+            initialServerRenderCheck: "DID_NOT_RUN",
+            realtimeUpgrade: "DID_NOT_RUN",
+            realtimeServerSide: "DID_NOT_RUN",
+            realtimeClientSide: "DID_NOT_RUN",
+            realtimeServerRenderCheck: "DID_NOT_RUN",
+            // HMR test statuses
+            initialServerHmr: "DID_NOT_RUN",
+            initialClientHmr: "DID_NOT_RUN",
+            realtimeServerHmr: "DID_NOT_RUN",
+            realtimeClientHmr: "DID_NOT_RUN",
+        },
+        production: {
+            overall: "DID_NOT_RUN",
+            releaseCommand: "DID_NOT_RUN",
+            initialServerSide: "DID_NOT_RUN",
+            initialClientSide: "DID_NOT_RUN",
+            initialServerRenderCheck: "DID_NOT_RUN",
+            realtimeUpgrade: "DID_NOT_RUN",
+            realtimeServerSide: "DID_NOT_RUN",
+            realtimeClientSide: "DID_NOT_RUN",
+            realtimeServerRenderCheck: "DID_NOT_RUN",
+            // HMR test statuses
+            initialServerHmr: "DID_NOT_RUN",
+            initialClientHmr: "DID_NOT_RUN",
+            realtimeServerHmr: "DID_NOT_RUN",
+            realtimeClientHmr: "DID_NOT_RUN",
+        },
+    },
+};
+// Helper function to update test status
+export function updateTestStatus(env, test, status) {
+    state.testStatus[env][test] = status;
+}

package/dist/lib/smokeTests/templates/SmokeTest.template.d.ts

@@ -0,0 +1 @@
+export declare function getSmokeTestTemplate(skipClient?: boolean): string;