playwright-slack-report-burak 3.0.32 → 3.0.34

package/dist/src/ResultsParser.js

@@ -9,9 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require('fs');
 const path = require('path');
 const axios = require('axios');
-const { exec, execSync } = require('child_process');
-const { promisify } = require('util');
-const execAsync = promisify(exec);
+const { exec } = require('child_process');
 let AdmZip;
 try {
     AdmZip = require('adm-zip');
@@ -20,17 +18,9 @@ try {
     AdmZip = null;
 }
 
-// Get package version
-let packageVersion = 'unknown';
-try {
-    const packageJsonPath = path.join(__dirname, '../../package.json');
-    if (fs.existsSync(packageJsonPath)) {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        packageVersion = packageJson.version || 'unknown';
-    }
-} catch (e) {
-    // Version detection failed, use default
-}
+const SUMMARIES_DIR = path.join('./', 'playwright-report');
+const NODE_ARTIFACTS_DIR = path.join(SUMMARIES_DIR, 'nodeArtifacts');
+const FINAL_OUTPUT_DIR = path.join(SUMMARIES_DIR, 'finalOutput');
 
 class ResultsParser {
     result;
@@ -45,77 +35,6 @@ class ResultsParser {
     constructor(options = { separateFlakyTests: false }) {
         this.result = [];
         this.separateFlakyTests = options.separateFlakyTests;
-        // Log package version
-        console.log(`📦 [ResultsParser] playwright-slack-report-burak v${packageVersion}`);
-    }
-    /**
-     * Recursively print directory tree structure
-     * @param {string} dirPath - Directory path to print
-     * @param {string} prefix - Prefix for tree visualization
-     * @param {number} maxDepth - Maximum depth to traverse (default: 5)
-     */
-    printDirectoryTree(dirPath, prefix = '', maxDepth = 5) {
-      if (maxDepth <= 0) return;
-      if (!fs.existsSync(dirPath)) {
-        console.log(`${prefix}${path.basename(dirPath)}/ (does not exist)`);
-        return;
-      }
-      
-      try {
-        const stats = fs.statSync(dirPath);
-        if (!stats.isDirectory()) {
-          const size = stats.size;
-          const sizeStr = size > 1024 ? `${(size / 1024).toFixed(2)}KB` : `${size}B`;
-          console.log(`${prefix}${path.basename(dirPath)} (${sizeStr})`);
-          return;
-        }
-        
-        const dirName = path.basename(dirPath) || dirPath;
-        console.log(`${prefix}${dirName}/`);
-        
-        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        entries.sort((a, b) => {
-          if (a.isDirectory() && !b.isDirectory()) return -1;
-          if (!a.isDirectory() && b.isDirectory()) return 1;
-          return a.name.localeCompare(b.name);
-        });
-        
-        entries.forEach((entry, index) => {
-          const isLast = index === entries.length - 1;
-          const newPrefix = prefix + (isLast ? '└── ' : '├── ');
-          const nextPrefix = prefix + (isLast ? '    ' : '│   ');
-          const fullPath = path.join(dirPath, entry.name);
-          
-          if (entry.isDirectory()) {
-            this.printDirectoryTree(fullPath, nextPrefix, maxDepth - 1);
-          } else {
-            try {
-              const fileStats = fs.statSync(fullPath);
-              const size = fileStats.size;
-              const sizeStr = size > 1024 * 1024 
-                ? `${(size / (1024 * 1024)).toFixed(2)}MB` 
-                : size > 1024 
-                  ? `${(size / 1024).toFixed(2)}KB` 
-                  : `${size}B`;
-              console.log(`${newPrefix}${entry.name} (${sizeStr})`);
-            } catch (err) {
-              console.log(`${newPrefix}${entry.name} (error reading)`);
-            }
-          }
-        });
-      } catch (error) {
-        console.log(`${prefix}${path.basename(dirPath)}/ (error: ${error.message})`);
-      }
-    }
-
-    /**
-     * Update shard information after detection (e.g., from GitHub API)
-     * @param {number} shardIndex - The current shard index (1-based, shard 1 is aggregator)
-     * @param {number} totalShardCount - The total number of shards
-     */
-    updateShardInfo(shardIndex, totalShardCount) {
-        this.shardIndex = shardIndex;
-        this.totalShardCount = totalShardCount;
     }
     async getParsedResults() {
       const summary = {
@@ -135,17 +54,15 @@ class ResultsParser {
         }*/
 
         // Define the directory to store node summaries
-        const summariesDir = path.join('./', 'playwright-report');
-        
-        if (!fs.existsSync(summariesDir)) {
-            fs.mkdirSync(summariesDir, { recursive: true });
+        if (!fs.existsSync(SUMMARIES_DIR)) {
+            fs.mkdirSync(SUMMARIES_DIR, { recursive: true });
         }
 
         // Determine the current node index
         const currentNodeIndex = this.shardIndex;
 
         // Define the file for the current node's summary
-        const nodeSummaryFile = path.join(summariesDir, `node_summary_${currentNodeIndex}.json`);
+        const nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${currentNodeIndex}.json`);
 
         const totalTestCasesForNode = this.result.reduce((acc, suite) => acc + suite.testSuite.tests.length, 0);
 
@@ -174,9 +91,11 @@ class ResultsParser {
 
         if (this.shardIndex === 1 && this.totalShardCount > 1) {
           if (process.env.CI) {
+            console.log('Fetching all artifacts...');
             await this.fetchAllArtifacts();
           } else {
             while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
+              console.log('Waiting for all both to exist...');
               await new Promise(resolve => setTimeout(resolve, 1000)); // Wait for 1 second
             }
           }
@@ -184,9 +103,8 @@ class ResultsParser {
 
         if (this.shardIndex === 1 && this.allNodeSummaryFilesExist() && this.allBlobZipsExist()) {
             // Merge all node summaries into the final summary
-            // Loop from 1 to totalShardCount (1-based indexing)
             for (let i = 1; i <= this.totalShardCount; i++) {
-                const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+                const nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${i}.json`);
                 const fileToRead = nodeSummaryFile;
 
                 if (fs.existsSync(fileToRead)) {
@@ -221,7 +139,7 @@ class ResultsParser {
                 }
             }
             
-            await this.mergeReports();
+            this.mergeReports();
         }
         return summary;
     }
@@ -398,11 +316,9 @@ class ResultsParser {
     }*/
     allNodeSummaryFilesExist() {
       console.log('Checking if all node summary files exist...');
-      const summariesDir = path.join('./', 'playwright-report');
       
-      // Check files from 1 to totalShardCount (1-based indexing)
       for (let i = 1; i <= this.totalShardCount; i++) {
-          const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+          const nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${i}.json`);
           if (!fs.existsSync(nodeSummaryFile)) {
               return false;
           }
@@ -412,11 +328,9 @@ class ResultsParser {
 
     allBlobZipsExist() {
       console.log('Checking if all blob zips exist...');
-      const summariesDir = path.join('./', 'playwright-report');
       
-        // Check files from 1 to totalShardCount (1-based indexing)
         for (let i = 1; i <= this.totalShardCount; i++) {
-            const blobZipFile = path.join(summariesDir, `blob-report-node-${i}.zip`);
+            const blobZipFile = path.join(NODE_ARTIFACTS_DIR, `blob-report-node-${i}.zip`);
             if (!fs.existsSync(blobZipFile)) {
                 return false;
             }
@@ -425,81 +339,63 @@ class ResultsParser {
     }
 
     async fetchAllArtifacts() {
-        const summariesDir = path.join('./', 'playwright-report');
-        if (!fs.existsSync(summariesDir)) {
-            fs.mkdirSync(summariesDir, { recursive: true });
+        // Ensure playwright-report directory exists
+        if (!fs.existsSync(SUMMARIES_DIR)) {
+            fs.mkdirSync(SUMMARIES_DIR, { recursive: true });
         }
         
-        console.log(`Shard 1: Waiting for artifacts from ${this.totalShardCount - 1} other shard(s)...`);
-        
-        // Fetch artifacts for all shards except shard 1 (since we're shard 1)
-        // We need to fetch from shards 2, 3, 4, ... (all except shard 1, using 1-based indexing)
-        for (let i = 1; i <= this.totalShardCount; i++) {
-            if (i === 1) continue; // Skip shard 1 (we are shard 1)
-            console.log(`Shard 1: Fetching artifacts from shard ${i}...`);
-            await this.fetchArtifact(i, `node_summary_${i}.json`, summariesDir);
-            await this.fetchArtifact(i, `blob-report-node-${i}.zip`, summariesDir);
+        // Create nodeArtifacts directory under playwright-report
+        if (!fs.existsSync(NODE_ARTIFACTS_DIR)) {
+            fs.mkdirSync(NODE_ARTIFACTS_DIR, { recursive: true });
         }
         
-        // After fetching, verify all files exist and wait if needed
-        let retryCount = 0;
-        const maxRetries = 60; // Wait up to 10 minutes (60 * 10 seconds)
+        // Copy artifacts from node 1 to nodeArtifacts
+        // Check multiple potential locations for node 1's blob file
+        const possibleNode1BlobSources = [
+            path.join(SUMMARIES_DIR, 'blob-report-node-1.zip'),
+            path.join('./', 'blob-report-node-1.zip'),
+            path.join(SUMMARIES_DIR, 'blob-report-1.zip'),
+        ];
         
-        while ((!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) && retryCount < maxRetries) {
-            console.log(`Shard 1: Waiting for all artifacts to be available (attempt ${retryCount + 1}/${maxRetries})...`);
-            
-            // Re-fetch any missing artifacts
-            for (let i = 1; i <= this.totalShardCount; i++) {
-                if (i === 1) continue; // Skip shard 1 (we are shard 1)
-                const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
-                const blobZipFile = path.join(summariesDir, `blob-report-node-${i}.zip`);
-                
-                if (!fs.existsSync(nodeSummaryFile)) {
-                    console.log(`Shard 1: Re-fetching missing node_summary_${i}.json...`);
-                    await this.fetchArtifact(i, `node_summary_${i}.json`, summariesDir);
-                }
-                
-                if (!fs.existsSync(blobZipFile)) {
-                    console.log(`Shard 1: Re-fetching missing blob-report-node-${i}.zip...`);
-                    await this.fetchArtifact(i, `blob-report-node-${i}.zip`, summariesDir);
-                }
-            }
-            
-            retryCount++;
-            if (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
-                await new Promise(resolve => setTimeout(resolve, 10000)); // Wait 10 seconds before retry
+        const node1BlobDest = path.join(NODE_ARTIFACTS_DIR, 'blob-report-node-1.zip');
+        let node1BlobCopied = false;
+        
+        for (const source of possibleNode1BlobSources) {
+            if (fs.existsSync(source)) {
+                fs.copyFileSync(source, node1BlobDest);
+                console.log(`Copied ${source} to nodeArtifacts`);
+                node1BlobCopied = true;
+                break;
             }
         }
         
-        if (this.allNodeSummaryFilesExist() && this.allBlobZipsExist()) {
-            console.log(`Shard 1: Successfully fetched all artifacts from ${this.totalShardCount - 1} other shard(s).`);
-        } else {
-            console.warn(`Shard 1: Warning - Some artifacts may still be missing after ${maxRetries} attempts.`);
+        if (!node1BlobCopied) {
+            console.warn('Warning: blob-report-node-1.zip not found in expected locations');
+        }
+        
+        while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
+          console.log('Waiting for all blob zips to exist...');
+          if (!fs.existsSync(SUMMARIES_DIR)) {
+              fs.mkdirSync(SUMMARIES_DIR, { recursive: true });
+          }
+          for (let i = 2; i <= this.totalShardCount; i++) {            
+              await this.fetchArtifact(i, `node_summary_${i}.json`, SUMMARIES_DIR);
+              await this.fetchArtifact(i, `blob-report-node-${i}.zip`, NODE_ARTIFACTS_DIR);
+          }
         }
     }
 
-    async fetchArtifact(i, file, summariesDir) {
-        const filePath = path.join(summariesDir, file);
+    async fetchArtifact(i, file, targetDir) {
+        const filePath = path.join(targetDir, file);
         await this.fetchArtifactFromGitHubActions(i, file, filePath);
     }
 
     async fetchArtifactFromGitHubActions(i, file, filePath) {
         const githubToken = process.env.SAFETYWINGTEST_GITHUB_TOKEN;
         const repo = process.env.GITHUB_REPOSITORY;
-        const runId = process.env.GITHUB_RUN_ID;
-        
-        if (!githubToken || !repo) {
-            console.error('GitHub Actions: Missing SAFETYWINGTEST_GITHUB_TOKEN or GITHUB_REPOSITORY');
-            return;
-        }
-
-        // GitHub Actions artifact API endpoint
         const githubApiUrl = `https://api.github.com/repos/${repo}/actions/artifacts`;
         
-        // Try multiple artifact naming patterns (all 1-based):
-        // 1. html-report-{i} (1-based workflow style)
-        // 2. blob-report-node-{i} (direct blob reports)
-        // 3. test-results-{i} (alternative naming)
+        // Try multiple artifact naming patterns
         const artifactNamePatterns = [
             `html-report-${i}`,
             `blob-report-node-${i}`,
@@ -527,10 +423,7 @@ class ResultsParser {
                                a.name.includes(`shard-${i}`) ||
                                a.name.includes(`node-${i}`)
                     );
-                    if (artifact) {
-                        console.log(`Found artifact: ${artifact.name} (matched pattern: ${pattern})`);
-                        break;
-                    }
+                    if (artifact) break;
                 }
                 
                 if (artifact && artifact.archive_download_url) {
@@ -550,69 +443,15 @@ class ResultsParser {
                     
                     // Extract ZIP and find the specific file
                     const zip = new AdmZip(downloadResponse.data);
-                    
-                    // Try direct file match first
-                    let zipEntry = zip.getEntry(file);
-                    
-                    // If not found, try common path variations
-                    if (!zipEntry) {
-                        const possiblePaths = [
-                            file,
-                            `playwright-report/${file}`,
-                            `html-report-${i}/${file}`,
-                            `html-report-${i}/playwright-report/${file}`,
-                        ];
-                        for (const possiblePath of possiblePaths) {
-                            zipEntry = zip.getEntry(possiblePath);
-                            if (zipEntry) break;
-                        }
-                    }
+                    const zipEntry = zip.getEntry(file) || zip.getEntry(`playwright-report/${file}`);
                     
                     if (zipEntry) {
                         fs.writeFileSync(filePath, zipEntry.getData());
-                        console.log(`Successfully fetched file ${file} from GitHub Actions shard ${i} (artifact: ${artifact.name})`);
+                        console.log(`Successfully fetched file ${file} from shard ${i}`);
                         break;
                     } else {
-                        // If file not found in ZIP root, extract and search recursively
-                        const extractPath = path.join(path.dirname(filePath), `temp-artifact-${i}`);
-                        zip.extractAllTo(extractPath, true);
-                        
-                        // Look for the file recursively
-                        const searchInDir = (dir, targetFile) => {
-                            const entries = fs.readdirSync(dir, { withFileTypes: true });
-                            for (const entry of entries) {
-                                const fullPath = path.join(dir, entry.name);
-                                if (entry.isDirectory()) {
-                                    const found = searchInDir(fullPath, targetFile);
-                                    if (found) return found;
-                                } else {
-                                    // Check exact match
-                                    if (entry.name === targetFile) {
-                                        return fullPath;
-                                    }
-                                    // Check if ends with target file
-                                    if (entry.name.endsWith(targetFile)) {
-                                        return fullPath;
-                                    }
-                                }
-                            }
-                            return null;
-                        };
-                        
-                        // Try to find the file recursively
-                        let foundPath = searchInDir(extractPath, file);
-                        
-                        if (foundPath) {
-                            fs.copyFileSync(foundPath, filePath);
-                            console.log(`Successfully fetched file ${file} from GitHub Actions shard ${i} (artifact: ${artifact.name})`);
-                            // Clean up temp directory
-                            fs.rmSync(extractPath, { recursive: true, force: true });
-                            break;
-                        } else {
-                            console.warn(`File ${file} not found in artifact ${artifact.name}. Retrying in 10 seconds...`);
-                            fs.rmSync(extractPath, { recursive: true, force: true });
-                            await new Promise(resolve => setTimeout(resolve, 10000));
-                        }
+                        console.warn(`File ${file} not found in artifact ${artifact.name}. Retrying in 10 seconds...`);
+                        await new Promise(resolve => setTimeout(resolve, 10000));
                     }
                 } else {
                     console.warn(`Artifact not found (tried: ${artifactNamePatterns.join(', ')}). Retrying in 10 seconds...`);
@@ -620,177 +459,125 @@ class ResultsParser {
                 }
             } catch (error) {
                 if (error.response && error.response.status === 404) {
-                    console.warn(`Artifact not found. Retrying in 10 seconds...`);
+                    console.warn(`File ${file} not found. Retrying in 10 seconds...`);
                     await new Promise(resolve => setTimeout(resolve, 10000));
                 } else {
-                    console.error(`Failed to fetch artifact from GitHub Actions shard ${i}!`, error.message);
-                    await new Promise(resolve => setTimeout(resolve, 10000));
+                    console.error(`Failed to fetch file ${file} from shard ${i}!`, error);
+                    break;
                 }
             }
         }
     }
-    async mergeReports() {
+    mergeReports() {
+      let breakMergeWaiter = false;
       try {
-        const summariesDir = path.join('./', 'playwright-report');
-        const blobReportsDir = path.join(summariesDir, 'blob-reports');
-        const mergedBlobsDir = path.join(summariesDir, 'mergedBlobsDir');
-        
-        console.log('\n=== Starting merge process ===');
-        console.log(`Summaries directory: ${path.resolve(summariesDir)}`);
-        console.log(`Blob reports directory: ${path.resolve(blobReportsDir)}`);
-        console.log(`Merged blobs directory: ${path.resolve(mergedBlobsDir)}`);
-        
-        // Show initial directory structure
-        console.log('\n📁 Initial playwright-report directory structure:');
-        if (fs.existsSync(summariesDir)) {
-          this.printDirectoryTree(summariesDir);
-        } else {
-          console.log('  (directory does not exist yet)');
+        // Ensure playwright-report directory exists
+        if (!fs.existsSync(SUMMARIES_DIR)) {
+            fs.mkdirSync(SUMMARIES_DIR, { recursive: true });
         }
         
-        // Create directory for extracted blob reports
-        if (!fs.existsSync(blobReportsDir)) {
-          fs.mkdirSync(blobReportsDir, { recursive: true });
+        // Create finalOutput directory under playwright-report
+        if (!fs.existsSync(FINAL_OUTPUT_DIR)) {
+            fs.mkdirSync(FINAL_OUTPUT_DIR, { recursive: true });
         }
         
-        // Create directory for merged blob reports output
-        if (!fs.existsSync(mergedBlobsDir)) {
-          fs.mkdirSync(mergedBlobsDir, { recursive: true });
+        // Extract blob files before merging (Playwright merge-reports expects extracted blob directories)
+        // We'll extract them temporarily for merging, then extract again for resource copying
+        const tempMergeDir = path.join(NODE_ARTIFACTS_DIR, 'temp-merge');
+        if (!fs.existsSync(tempMergeDir)) {
+            fs.mkdirSync(tempMergeDir, { recursive: true });
         }
         
-        // Extract all blob zips to preserve traces
-        console.log('\n📦 Extracting blob reports to preserve traces...');
-        let hasBlobReports = false;
-        for (let i = 1; i <= this.totalShardCount; i++) {
-          const blobZipFile = path.join(summariesDir, `blob-report-node-${i}.zip`);
-          if (fs.existsSync(blobZipFile)) {
-            if (!AdmZip) {
-              console.warn('adm-zip is required for blob extraction. Falling back to HTML report merge.');
-              break;
-            }
-            
-            const zip = new AdmZip(blobZipFile);
-            const extractPath = path.join(blobReportsDir, `node-${i}`);
-            zip.extractAllTo(extractPath, true);
-            console.log(`Extracted blob report from shard ${i}`);
-            hasBlobReports = true;
-          }
-        }
-        
-        // Show directory structure after extraction
-        if (hasBlobReports) {
-          console.log('\n📁 Directory structure after blob extraction:');
-          this.printDirectoryTree(summariesDir);
+        // Extract all blob zip files to temp directory for merging
+        if (!AdmZip) {
+            console.error('adm-zip is required for blob extraction. Please install it: npm install adm-zip');
+            return;
         }
         
-        // Merge blob reports instead of HTML reports to preserve traces
-        if (hasBlobReports && fs.existsSync(blobReportsDir) && fs.readdirSync(blobReportsDir).length > 0) {
-          console.log('\n🔄 Merging blob reports (preserves traces)...');
-          let tempConfigPath = null;
-          try {
-            // Merge blob reports - use config file to specify output directory
-            // This prevents wiping the playwright-report directory
-            const blobReportsRelativePath = path.relative(summariesDir, blobReportsDir);
-            const mergedBlobsAbsolutePath = path.resolve(mergedBlobsDir);
-            console.log(`Merging blob reports from: ${blobReportsRelativePath}`);
-            console.log(`Output directory: ${mergedBlobsAbsolutePath}`);
-            
-            // Create temporary config file to specify output folder
-            tempConfigPath = path.join(summariesDir, 'merge-config.js');
-            const tempConfigAbsolutePath = path.resolve(tempConfigPath);
-            // Escape backslashes and single quotes in path for JavaScript string
-            const escapedPath = mergedBlobsAbsolutePath.replace(/\\/g, '/').replace(/'/g, "\\'");
-            const configContent = `module.exports = {
-  reporter: [['html', { outputFolder: '${escapedPath}' }]]
-};`;
-            fs.writeFileSync(tempConfigPath, configContent);
-            console.log(`Created temporary config file: ${tempConfigAbsolutePath}`);
-            console.log(`Config content: ${configContent}`);
-            
-            // Use absolute path for config file to avoid path resolution issues
-            const mergeCommand = `npx playwright merge-reports --reporter html --config "${tempConfigAbsolutePath}" "${blobReportsRelativePath}"`;
-            console.log(`Executing: ${mergeCommand}`);
-            const mergeResult = await execAsync(mergeCommand, { cwd: summariesDir });
-            console.log('Merge command output:', mergeResult.stdout);
-            if (mergeResult.stderr) {
-              console.warn('Merge command stderr:', mergeResult.stderr);
-            }
-            console.log('Blob reports merged successfully with traces preserved.');
-            
-            // Show directory structure after merge
-            console.log('\n📁 Directory structure after merge:');
-            this.printDirectoryTree(summariesDir);
-            console.log('\n📁 Merged blobs directory contents:');
-            this.printDirectoryTree(mergedBlobsDir);
-          } catch (error) {
-            console.warn('Warning: Failed to merge blob reports. Falling back to HTML merge.', error.message);
-            if (error.stdout) console.log('Merge stdout:', error.stdout);
-            if (error.stderr) console.warn('Merge stderr:', error.stderr);
-            
-            // Show directory structure after failed merge
-            console.log('\n📁 Directory structure after failed merge:');
-            this.printDirectoryTree(summariesDir);
-            
-            // Fallback to HTML merge
-            execSync(`npx playwright merge-reports --reporter html -c ./playwright-report playwright-report`, { stdio: 'inherit' });
-          } finally {
-            // Clean up temporary config file
-            if (tempConfigPath) {
-              const configPathToDelete = fs.existsSync(tempConfigPath) ? tempConfigPath : path.resolve(tempConfigPath);
-              if (fs.existsSync(configPathToDelete)) {
+        for (let i = 1; i <= this.totalShardCount; i++) {
+            const blobZipFile = path.join(NODE_ARTIFACTS_DIR, `blob-report-node-${i}.zip`);
+            if (fs.existsSync(blobZipFile)) {
                 try {
-                  fs.unlinkSync(configPathToDelete);
-                  console.log(`Cleaned up temporary config file: ${configPathToDelete}`);
-                } catch (cleanupError) {
-                  console.warn(`Warning: Failed to clean up temp config file: ${cleanupError.message}`);
+                    const zip = new AdmZip(blobZipFile);
+                    zip.extractAllTo(tempMergeDir, true);
+                    console.log(`Extracted blob-report-node-${i}.zip for merging`);
+                } catch (error) {
+                    console.warn(`Failed to extract blob-report-node-${i}.zip for merging:`, error.message);
                 }
-              }
             }
-          }
-        } else {
-          // Fallback to HTML merge if no blob reports found
-          console.log('No blob reports found, falling back to HTML report merge...');
-          execSync(`npx playwright merge-reports --reporter html -c ./playwright-report playwright-report`, { stdio: 'inherit' });
         }
         
-        // Wait until index.html exists in mergedBlobsDir (with timeout)
-        const maxWaitTime = 60000; // 60 seconds max wait
-        const startWaitTime = new Date().getTime();
-        const indexHtmlPath = path.join(mergedBlobsDir, 'index.html');
+        // Execute the command to merge reports FROM tempMergeDir INTO finalOutput
+        exec(`npx playwright merge-reports --reporter html ${tempMergeDir} ${FINAL_OUTPUT_DIR}`);
         
-        console.log('\n⏳ Waiting for merged HTML report to be generated...');
-        while (!fs.existsSync(indexHtmlPath)) {
-          const elapsed = new Date().getTime() - startWaitTime;
-          if (elapsed > maxWaitTime) {
-            console.warn(`\n⏱️  Timeout: index.html not found in ${mergedBlobsDir} after ${maxWaitTime}ms`);
-            console.log(`Checking if directory exists: ${fs.existsSync(mergedBlobsDir)}`);
-            if (fs.existsSync(mergedBlobsDir)) {
-              console.log('\n📁 Full directory tree at timeout:');
-              this.printDirectoryTree(summariesDir);
-              console.log('\n📁 Merged blobs directory detailed contents:');
-              this.printDirectoryTree(mergedBlobsDir);
-            } else {
-              console.log('Merged blobs directory does not exist!');
+        // Wait until index.html exists in finalOutput
+        while (!fs.existsSync(path.join(FINAL_OUTPUT_DIR, 'index.html'))) {
+          console.log('Waiting 2 seconds for merged html report to be generated...');
+          const currentTime = new Date().getTime();
+          breakMergeWaiter = false;
+          while (!breakMergeWaiter) {
+            if(new Date().getTime() - currentTime > 2000) {
+              breakMergeWaiter = true;
             }
-            break;
           }
-          console.log(`Waiting for merged html report to be generated... (${Math.round(elapsed/1000)}s elapsed)`);
-          await new Promise(resolve => setTimeout(resolve, 2000));
         }
+        console.log('Reports merged successfully.');
         
-        if (fs.existsSync(indexHtmlPath)) {
-          console.log('\n✅ Reports merged successfully.');
-          console.log('\n📁 Final directory structure:');
-          this.printDirectoryTree(summariesDir);
-        } else {
-          console.warn('\n⚠️  Warning: Merged report index.html not found, but continuing...');
-          console.log('\n📁 Final directory structure:');
-          this.printDirectoryTree(summariesDir);
-        }
+        // Once merge is complete, unzip all blobs in nodeArtifacts into separate folders
+        this.unzipBlobsAndCopyResources(NODE_ARTIFACTS_DIR, FINAL_OUTPUT_DIR);
       } catch (error) {
           // Log a warning instead of throwing an error
           console.warn('Warning: Failed to merge reports. This may not affect the overall process.', error.message);
       }
     }
+    
+    unzipBlobsAndCopyResources(nodeArtifactsDir, finalOutputDir) {
+        if (!AdmZip) {
+            console.error('adm-zip is required for blob extraction. Please install it: npm install adm-zip');
+            return;
+        }
+        
+        // Unzip all blob files in nodeArtifacts into separate folders
+        for (let i = 1; i <= this.totalShardCount; i++) {
+            const blobZipFile = path.join(nodeArtifactsDir, `blob-report-node-${i}.zip`);
+            if (fs.existsSync(blobZipFile)) {
+                const extractDir = path.join(nodeArtifactsDir, `node-${i}`);
+                if (!fs.existsSync(extractDir)) {
+                    fs.mkdirSync(extractDir, { recursive: true });
+                }
+                
+                try {
+                    const zip = new AdmZip(blobZipFile);
+                    zip.extractAllTo(extractDir, true);
+                    console.log(`Extracted blob-report-node-${i}.zip to ${extractDir}`);
+                    
+                    // Check if this folder contains a "resources" folder with zip files
+                    const resourcesDir = path.join(extractDir, 'resources');
+                    if (fs.existsSync(resourcesDir) && fs.statSync(resourcesDir).isDirectory()) {
+                        const files = fs.readdirSync(resourcesDir);
+                        const zipFiles = files.filter(file => file.endsWith('.zip'));
+                        
+                        if (zipFiles.length > 0) {
+                            // Copy the resources folder to finalOutput
+                            const finalResourcesDir = path.join(finalOutputDir, 'resources');
+                            if (!fs.existsSync(finalResourcesDir)) {
+                                fs.mkdirSync(finalResourcesDir, { recursive: true });
+                            }
+                            
+                            // Copy each zip file to finalOutput/resources
+                            for (const zipFile of zipFiles) {
+                                const sourceFile = path.join(resourcesDir, zipFile);
+                                const destFile = path.join(finalResourcesDir, zipFile);
+                                fs.copyFileSync(sourceFile, destFile);
+                                console.log(`Copied ${zipFile} to finalOutput/resources`);
+                            }
+                        }
+                    }
+                } catch (error) {
+                    console.warn(`Failed to extract or process blob-report-node-${i}.zip:`, error.message);
+                }
+            }
+        }
+    }
 }
 exports.default = ResultsParser;

package/package.json

@@ -32,7 +32,7 @@
     "lint-fix": "npx eslint . --ext .ts --fix"
   },
   "name": "playwright-slack-report-burak",
-  "version": "3.0.32",
+  "version": "3.0.34",
   "main": "index.js",
   "types": "dist/index.d.ts",
   "author": "Burak B. <burak.boluk@hotmail.com>",