@probolabs/playwright 1.4.0-rc.6 → 1.4.0

package/dist/cli.js

@@ -1006,6 +1006,7 @@ class ProboCodeGenerator {
      */
     static async fetchScenarioData(scenarioId, apiToken, apiUrl) {
         const normalizedUrl = this.normalizeApiUrl(apiUrl);
+        // Scenario interactions endpoint is under /api/ (special endpoint)
         const url = `${normalizedUrl}/api/scenarios/${scenarioId}/interactions`;
         const response = await fetch(url, {
             method: 'GET',
@@ -1040,6 +1041,54 @@ class ProboCodeGenerator {
         }
         return response.json();
     }
+    /**
+     * Fetch project data from the backend API
+     */
+    static async fetchProjectData(projectId, apiToken, apiUrl) {
+        const normalizedUrl = this.normalizeApiUrl(apiUrl);
+        // Projects endpoint is at root level, not under /api/
+        const url = `${normalizedUrl}/projects/${projectId}/`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Token ${apiToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await this.readResponseErrorText(response);
+            throw new Error(`Failed to fetch project ${projectId}: ${response.status} ${errorText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Fetch all scenarios for a project from the backend API
+     */
+    static async fetchProjectScenarios(projectId, apiToken, apiUrl) {
+        const normalizedUrl = this.normalizeApiUrl(apiUrl);
+        // Scenarios endpoint is at root level, not under /api/
+        const url = `${normalizedUrl}/scenarios/?project_id=${projectId}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Token ${apiToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await this.readResponseErrorText(response);
+            throw new Error(`Failed to fetch scenarios for project ${projectId}: ${response.status} ${errorText}`);
+        }
+        const data = await response.json();
+        // Handle both array and paginated responses
+        if (Array.isArray(data)) {
+            return data;
+        }
+        if (data.results && Array.isArray(data.results)) {
+            return data.results;
+        }
+        return [];
+    }
     /**
      * Convert backend interaction format to Interaction[] format
      */
@@ -1190,6 +1239,48 @@ class ProboCodeGenerator {
             scenarios: scenarioResults,
         };
     }
+    /**
+     * Generate code for all scenarios in a project
+     * Returns map of scenario names to generated code
+     */
+    static async generateCodeForProject(projectId, apiToken, apiUrl, options) {
+        // Validate inputs
+        if (!apiToken) {
+            throw new Error('API token is required');
+        }
+        if (!apiUrl) {
+            throw new Error('API URL is required');
+        }
+        // Fetch project data and scenarios
+        const [projectData, scenarios] = await Promise.all([
+            this.fetchProjectData(projectId, apiToken, apiUrl),
+            this.fetchProjectScenarios(projectId, apiToken, apiUrl),
+        ]);
+        if (scenarios.length === 0) {
+            throw new Error(`No scenarios found in project "${projectData.name}" (ID: ${projectId})`);
+        }
+        // Generate code for each scenario
+        const scenarioResults = await Promise.all(scenarios.map(async (scenario) => {
+            try {
+                const code = await this.generateCodeForScenario(scenario.id, apiToken, apiUrl, options);
+                return {
+                    scenarioId: scenario.id,
+                    scenarioName: scenario.name,
+                    code: code,
+                };
+            }
+            catch (error) {
+                // Log error but continue with other scenarios
+                console.error(`Failed to generate code for scenario ${scenario.id}: ${error.message}`);
+                throw error; // Re-throw to fail fast for now
+            }
+        }));
+        return {
+            projectId: projectData.id,
+            projectName: projectData.name,
+            scenarios: scenarioResults,
+        };
+    }
 }
 
 const execAsync = promisify(exec);
@@ -1311,6 +1402,33 @@ async function updateRunStatus(runId, testSuiteId, updates, apiToken, apiUrl) {
  * TestSuiteRunner - Handles test suite file generation and execution
  */
 class TestSuiteRunner {
+    /**
+     * Lookup project ID by name
+     */
+    static async lookupProjectByName(projectName, apiToken, apiUrl) {
+        const baseUrl = apiUrl.endsWith('/') ? apiUrl.slice(0, -1) : apiUrl;
+        // Projects endpoint is at root level, not under /api/
+        const url = `${baseUrl}/projects/?name=${encodeURIComponent(projectName)}`;
+        const response = await fetch$1(url, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Token ${apiToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to lookup project: ${response.status} ${errorText}`);
+        }
+        const data = await response.json();
+        if (Array.isArray(data) && data.length > 0) {
+            return data[0].id;
+        }
+        if (data.results && Array.isArray(data.results) && data.results.length > 0) {
+            return data.results[0].id;
+        }
+        throw new Error(`Project "${projectName}" not found`);
+    }
     /**
      * Lookup test suite ID by name and project
      */
@@ -1446,7 +1564,10 @@ class TestSuiteRunner {
                 }
             }
         }
-        const sanitizedName = slugify(codeGenResult.testSuiteName);
+        // Type guard: check for projectId to distinguish ProjectCodeGenResult from TestSuiteCodeGenResult
+        const sanitizedName = 'projectId' in codeGenResult && 'projectName' in codeGenResult
+            ? slugify(codeGenResult.projectName)
+            : slugify(codeGenResult.testSuiteName);
         const packageJsonContent = generatePackageJson({
             name: sanitizedName,
             hasSecrets: hasSecrets,
@@ -1479,12 +1600,12 @@ class TestSuiteRunner {
      * Generates files, installs dependencies, and executes tests
      */
     static async runTestSuite(testSuiteId, apiToken, apiUrl, testSuiteName, runId, options = {}) {
-        const { outputDir, includeReporter = true, playwrightArgs = [], onStatusUpdate, onStdout, onStderr, onReporterEvent, } = options;
+        const { outputDir, includeReporter = true, playwrightArgs = [], skipRunCreation = false, onStatusUpdate, onStdout, onStderr, onReporterEvent, } = options;
         const testSuiteDir = outputDir || getDefaultTestSuiteDir(testSuiteId, testSuiteName);
         let currentRunId = runId;
         try {
-            // Create run record if not provided (needed for run-specific report directories)
-            if (!currentRunId) {
+            // Create run record if not provided and not skipping run creation
+            if (!currentRunId && !skipRunCreation) {
                 try {
                     const createResponse = await fetch$1(`${apiUrl}/test-suites/${testSuiteId}/runs/`, {
                         method: 'POST',
@@ -1909,6 +2030,233 @@ class TestSuiteRunner {
             };
         }
     }
+    /**
+     * Generate all files for a project (all scenarios)
+     */
+    static async generateProjectFiles(projectId, apiToken, apiUrl, outputDir, projectName, includeReporter = true) {
+        const projectDir = outputDir || getDefaultTestSuiteDir(projectId, projectName || `project-${projectId}`);
+        // Generate code for all scenarios
+        const codeGenResult = await ProboCodeGenerator.generateCodeForProject(projectId, apiToken, apiUrl);
+        if (codeGenResult.scenarios.length === 0) {
+            throw new Error(`No scenarios found in project "${codeGenResult.projectName}" (ID: ${projectId}). Cannot generate test files.`);
+        }
+        // Delete everything in the project directory except node_modules
+        if (fs.existsSync(projectDir)) {
+            try {
+                const nodeModulesPath = path.join(projectDir, 'node_modules');
+                const hasNodeModules = fs.existsSync(nodeModulesPath);
+                // Temporarily move node_modules out of the way if it exists
+                let tempNodeModulesPath = null;
+                if (hasNodeModules) {
+                    tempNodeModulesPath = path.join(projectDir, '..', `node_modules.temp.${projectId}`);
+                    // Remove temp directory if it exists from a previous failed run
+                    if (fs.existsSync(tempNodeModulesPath)) {
+                        fs.rmSync(tempNodeModulesPath, { recursive: true, force: true });
+                    }
+                    fs.renameSync(nodeModulesPath, tempNodeModulesPath);
+                    console.log(`📦 Preserved node_modules temporarily`);
+                }
+                // Delete everything in the directory
+                const entries = fs.readdirSync(projectDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const entryPath = path.join(projectDir, entry.name);
+                    try {
+                        if (entry.isDirectory()) {
+                            fs.rmSync(entryPath, { recursive: true, force: true });
+                        }
+                        else {
+                            fs.unlinkSync(entryPath);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`⚠️  Failed to delete ${entry.name}:`, error);
+                    }
+                }
+                console.log(`🗑️  Cleaned project directory (preserved node_modules)`);
+                // Move node_modules back
+                if (hasNodeModules && tempNodeModulesPath) {
+                    fs.renameSync(tempNodeModulesPath, nodeModulesPath);
+                    console.log(`📦 Restored node_modules`);
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Failed to clean project directory ${projectDir}:`, error);
+                // Continue anyway - we'll overwrite files as needed
+            }
+        }
+        // Ensure directories exist (will recreate after deletion)
+        ensureDirectoryExists(projectDir);
+        const testsDir = path.join(projectDir, 'tests');
+        ensureDirectoryExists(testsDir);
+        // Save each scenario's code to a .spec.ts file
+        for (const scenario of codeGenResult.scenarios) {
+            const fileName = `${slugify(scenario.scenarioName)}.spec.ts`;
+            const filePath = path.join(testsDir, fileName);
+            fs.writeFileSync(filePath, scenario.code, 'utf-8');
+            console.log(`✅ Generated test file: ${filePath}`);
+        }
+        // Generate package.json
+        await this.generatePackageJson(projectDir, codeGenResult);
+        // Generate playwright.config.ts (no runId for project runs)
+        await this.generatePlaywrightConfig(projectDir, includeReporter, undefined);
+        // Generate custom reporter file for live progress streaming (only if requested)
+        if (includeReporter) {
+            await this.generateProboReporter(projectDir);
+        }
+    }
+    /**
+     * Run all scenarios in a project
+     * Generates files, installs dependencies, and executes tests
+     * Does not create run records in the database (CLI mode)
+     */
+    static async runProjectScenarios(projectId, apiToken, apiUrl, projectName, options = {}) {
+        const { outputDir, includeReporter = false, // CLI mode - no custom reporter
+        playwrightArgs = [], onStdout, onStderr, } = options;
+        const projectDir = outputDir || getDefaultTestSuiteDir(projectId, projectName || `project-${projectId}`);
+        try {
+            // Generate all files
+            console.log(`📝 Generating test files for project ${projectId}...`);
+            await this.generateProjectFiles(projectId, apiToken, apiUrl, projectDir, projectName, includeReporter);
+            // Count total tests
+            const testsTotal = countTotalTests(projectDir);
+            if (testsTotal === 0) {
+                throw new Error(`No test files generated for project ${projectId}`);
+            }
+            // Install dependencies
+            console.log(`📦 Installing dependencies in ${projectDir}...`);
+            try {
+                const { stdout: installStdout, stderr: installStderr } = await execAsync('npm install', { cwd: projectDir, timeout: 300000 } // 5 minute timeout for install
+                );
+                console.log('✅ Dependencies installed successfully');
+                if (installStdout)
+                    console.log(installStdout);
+                if (installStderr)
+                    console.warn(installStderr);
+            }
+            catch (installError) {
+                console.error('❌ Failed to install dependencies:', installError);
+                const errorMsg = `Failed to install dependencies: ${installError.message}`;
+                return {
+                    success: false,
+                    exitCode: installError.code || 1,
+                    stdout: installError.stdout || '',
+                    stderr: installError.stderr || installError.message || '',
+                    error: errorMsg,
+                };
+            }
+            // Run Playwright tests with streaming output
+            console.log(`🚀 Running Playwright tests in ${projectDir}...`);
+            if (playwrightArgs.length > 0) {
+                console.log(`🧪 Playwright extra args: ${playwrightArgs.join(' ')}`);
+            }
+            return new Promise(async (resolve) => {
+                var _a, _b;
+                let stdout = '';
+                let stderr = '';
+                let hasResolved = false;
+                let stdoutLineBuffer = '';
+                // Use spawn for streaming output
+                const testProcess = spawn('npx', ['playwright', 'test', ...playwrightArgs], {
+                    cwd: projectDir,
+                    shell: true,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                // Stream stdout line by line
+                (_a = testProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', async (data) => {
+                    var _a;
+                    const chunk = data.toString();
+                    stdoutLineBuffer += chunk;
+                    // Process complete lines
+                    const parts = stdoutLineBuffer.split(/\n/);
+                    stdoutLineBuffer = (_a = parts.pop()) !== null && _a !== void 0 ? _a : '';
+                    for (const rawLine of parts) {
+                        const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+                        stdout += rawLine + '\n';
+                        // Call stdout callback if provided
+                        if (onStdout) {
+                            await onStdout(rawLine + '\n');
+                        }
+                    }
+                });
+                // Stream stderr line by line
+                (_b = testProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', async (data) => {
+                    const chunk = data.toString();
+                    stderr += chunk;
+                    // Call stderr callback if provided
+                    if (onStderr) {
+                        await onStderr(chunk);
+                    }
+                });
+                // Handle process completion
+                testProcess.on('close', async (code) => {
+                    if (hasResolved)
+                        return;
+                    hasResolved = true;
+                    // Flush any remaining buffered stdout
+                    if (stdoutLineBuffer) {
+                        stdout += stdoutLineBuffer;
+                        if (onStdout) {
+                            await onStdout(stdoutLineBuffer);
+                        }
+                    }
+                    const exitCode = code !== null && code !== void 0 ? code : 1;
+                    const success = exitCode === 0;
+                    const isTestFailure = exitCode === 1 && stdout.length > 0;
+                    console.log(success ? '✅ Tests completed successfully' : (isTestFailure ? '⚠️ Tests completed with failures' : '❌ Test execution failed'));
+                    resolve({
+                        success: success,
+                        exitCode: exitCode,
+                        stdout: stdout,
+                        stderr: stderr,
+                        error: success || isTestFailure ? undefined : `Test execution failed with exit code ${exitCode}`,
+                    });
+                });
+                // Handle process errors
+                testProcess.on('error', async (error) => {
+                    if (hasResolved)
+                        return;
+                    hasResolved = true;
+                    const errorMessage = error.message || String(error);
+                    stderr += errorMessage;
+                    console.error('❌ Test execution failed:', error);
+                    resolve({
+                        success: false,
+                        exitCode: 1,
+                        stdout: stdout,
+                        stderr: stderr,
+                        error: `Test execution failed: ${errorMessage}`,
+                    });
+                });
+                // Set timeout (1 hour)
+                setTimeout(async () => {
+                    if (!hasResolved) {
+                        hasResolved = true;
+                        testProcess.kill();
+                        const errorMessage = 'Test execution timed out after 1 hour';
+                        stderr += errorMessage;
+                        resolve({
+                            success: false,
+                            exitCode: 1,
+                            stdout: stdout,
+                            stderr: stderr,
+                            error: errorMessage,
+                        });
+                    }
+                }, 3600000); // 1 hour timeout
+            });
+        }
+        catch (error) {
+            console.error('❌ Error running project scenarios:', error);
+            const errorMsg = error.message || String(error);
+            return {
+                success: false,
+                exitCode: 1,
+                stdout: '',
+                stderr: errorMsg,
+                error: errorMsg,
+            };
+        }
+    }
     /**
      * Upload artifacts for a test suite run
      *
@@ -1929,6 +2277,59 @@ async function runCLI(options) {
         process.exit(1);
     }
     const apiUrl = options.apiEndpoint || process.env.PROBO_API_ENDPOINT || 'https://api.probolabs.ai';
+    // Check if running project-only mode (--project without test suite)
+    if (options.project && !options.testSuiteId && !options.testSuiteName) {
+        // Run all scenarios in the project
+        try {
+            console.log(`🔍 Looking up project "${options.project}"...`);
+            const projectId = await TestSuiteRunner.lookupProjectByName(options.project, apiToken, apiUrl);
+            console.log(`✅ Found project ID: ${projectId}`);
+            const result = await TestSuiteRunner.runProjectScenarios(projectId, apiToken, apiUrl, options.project, {
+                outputDir: options.outputDir,
+                includeReporter: false, // CI/CD mode - no custom reporter
+                playwrightArgs: options.playwrightArgs,
+                skipRunCreation: true, // CLI never creates run records
+                // Stream stdout/stderr to console in real-time
+                onStdout: (chunk) => {
+                    process.stdout.write(chunk);
+                },
+                onStderr: (chunk) => {
+                    process.stderr.write(chunk);
+                },
+            });
+            if (result.success) {
+                console.log('✅ Project scenarios completed successfully');
+                process.exit(0);
+            }
+            else {
+                console.error(`❌ Project scenarios failed with exit code ${result.exitCode}`);
+                if (result.error) {
+                    console.error(`Error: ${result.error}`);
+                }
+                // Print stdout/stderr to help debug failures
+                console.log(`\n--- STDOUT (${result.stdout.length} chars) ---`);
+                if (result.stdout.trim()) {
+                    console.log(result.stdout);
+                }
+                else {
+                    console.log('(empty)');
+                }
+                console.error(`\n--- STDERR (${result.stderr.length} chars) ---`);
+                if (result.stderr.trim()) {
+                    console.error(result.stderr);
+                }
+                else {
+                    console.error('(empty)');
+                }
+                process.exit(result.exitCode || 1);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error running project scenarios: ${error.message}`);
+            process.exit(1);
+        }
+        return; // Exit early for project-only mode
+    }
     let testSuiteId;
     // Resolve test suite ID
     if (options.testSuiteId) {
@@ -1950,16 +2351,17 @@ async function runCLI(options) {
         }
     }
     else {
-        console.error('❌ Error: Either --test-suite-id or --test-suite-name must be provided');
+        console.error('❌ Error: Either --test-suite-id, --test-suite-name, or --project must be provided');
         process.exit(1);
     }
     // Run the test suite
     try {
-        const result = await TestSuiteRunner.runTestSuite(testSuiteId, apiToken, apiUrl, options.testSuiteName, undefined, // runId - will be created automatically
+        const result = await TestSuiteRunner.runTestSuite(testSuiteId, apiToken, apiUrl, options.testSuiteName, undefined, // runId - will not be created (CLI mode)
         {
             outputDir: options.outputDir,
             includeReporter: false, // CI/CD mode - no custom reporter
             playwrightArgs: options.playwrightArgs,
+            skipRunCreation: true, // CLI never creates run records
             // Stream stdout/stderr to console in real-time
             onStdout: (chunk) => {
                 process.stdout.write(chunk);