playwright-slack-report-burak 3.0.112 → 3.1.0

package/dist/src/LayoutGenerator.js

@@ -8,24 +8,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  exports.generateAllRunSuites = 
  void 0;
 
-// Helper function to get build URL and CI platform name
-const getBuildInfo = () => {
-    if (process.env.GITHUB_ACTIONS || process.env.SAFETYWINGTEST_GITHUB_TOKEN) {
-        const repo = process.env.GITHUB_REPOSITORY;
-        const runId = process.env.GITHUB_RUN_ID;
-        const serverUrl = process.env.GITHUB_SERVER_URL || 'https://github.com';
-        const buildUrl = `${serverUrl}/${repo}/actions/runs/${runId}`;
-        return {
-            url: buildUrl,
-            platform: 'GitHub Actions'
-        };
-    }
-    return {
-        url: '#',
-        platform: 'CI'
-    };
-};
-
 const generateAllRunSuites = async (summaryResults) => {
     const suitesResults = [];
     const allSuites = [];
@@ -273,13 +255,12 @@ const generateProblemCaseList = async (summaryResults) => {
         let text = `${title}${list.map((value, index) => `*${index + 1}.* ${value}`).join('\n')}`;
         if (text.length > 2700) {
             text = text.substring(0, 2700) + '...';
-            const buildInfo = getBuildInfo();
             array.push({
                 type: 'section',
                 text: {
                     type: 'mrkdwn',
-                    text: text + '\n\n\n' + `⚠️ *There are too many items to display here. ` +
-                          `You can view more on ${buildInfo.platform}* ⚠️`,
+                    text: text + '\n\n\n' + '⚠️ *There are too many items to display here. ' +
+                          'You can view more on Github Actions* ⚠️',
                 },
             },
             {
@@ -290,7 +271,7 @@ const generateProblemCaseList = async (summaryResults) => {
                         type: 'plain_text',
                         text: 'Go to Build Details'
                     },
-                    url: buildInfo.url
+                    url: `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
                 }]
             });
         } else {
@@ -375,13 +356,12 @@ const generateFailuresReasons = async (summaryResults) => {
                 },
             });
             if (i === summaryResults.failures.length-1) {
-                const buildInfo = getBuildInfo();
                 failsList.push({
                     type: 'section',
                     text: {
                         type: 'mrkdwn',
                         text: '⚠️ *There are too many failures to display in full detail. '+
-                            `You can view more on ${buildInfo.platform}* ⚠️`,
+                            'You can view more on Github Actions* ⚠️',
                     },
                 },
                 {
@@ -393,7 +373,7 @@ const generateFailuresReasons = async (summaryResults) => {
                             type: 'plain_text',
                             text: 'Go to Build Details'
                         },
-                        url: buildInfo.url
+                        url: `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
                     }
                 ]
                 });
@@ -411,13 +391,12 @@ const generateFailuresReasons = async (summaryResults) => {
                 },
             });
             if (i > 23) {
-                const buildInfo = getBuildInfo();
                 failsList.push({
                     type: 'section',
                     text: {
                         type: 'mrkdwn',
                         text: '⚠️ *There are too many failures to display here '+
-                            `You can view more on ${buildInfo.platform}* ⚠️`,
+                            'You can view more on Github Actions* ⚠️',
                     },
                 },
                 {
@@ -428,7 +407,7 @@ const generateFailuresReasons = async (summaryResults) => {
                             type: 'plain_text',
                             text: 'Go to Build Details'
                         },
-                        url: buildInfo.url
+                        url: `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
                     }]
                 });
                 break;

package/dist/src/ResultsParser.js

@@ -18,29 +18,61 @@ try {
     AdmZip = null;
 }
 
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+// Directory paths
+const SUMMARIES_DIR = path.join('./', 'playwright-artifacts');
+const PLAYWRIGHT_REPORT_DIR = path.join('./', 'playwright-report');
+
+// Environment variables
+const IS_CI = !!process.env.CI;
+const GITHUB_TOKEN = process.env.SAFETYWINGTEST_GITHUB_TOKEN;
+const GITHUB_REPOSITORY = process.env.GITHUB_REPOSITORY;
+const GITHUB_RUN_ID = process.env.GITHUB_RUN_ID || 'local';
+const GITHUB_RUN_ATTEMPT = process.env.GITHUB_RUN_ATTEMPT || '1';
+
+// Google Cloud Storage configuration
+const GCS_BUCKET_NAME = 'sw-automation-tests';
+const GCS_SERVICE_ACCOUNT_KEY = process.env.GCS_SERVICE_ACCOUNT_KEY;
+const GCS_REPORTS_FOLDER_PREFIX = 'playwright-reports';
+const GCS_UPLOAD_API_BASE_URL = 'https://storage.googleapis.com/upload/storage/v1';
+
+// Artifact patterns
+const ARTIFACT_NAME_PATTERNS = [
+    'html-report',
+    'blob-report-node',
+    'test-results',
+];
+
+// GitHub API endpoints (for artifact fetching)
+const GITHUB_API_BASE_URL = 'https://api.github.com';
+const GITHUB_API_ARTIFACTS_ENDPOINT = '/actions/artifacts';
+
+// Helper functions for building GitHub API URLs and patterns
+const getGitHubArtifactsApiUrl = () => `${GITHUB_API_BASE_URL}/repos/${GITHUB_REPOSITORY}${GITHUB_API_ARTIFACTS_ENDPOINT}`;
+const getArtifactNamePatterns = (shardIndex) => ARTIFACT_NAME_PATTERNS.map(pattern => `${pattern}-${shardIndex}`);
+
+// Helper functions for report paths
+const getRunFolder = () => `${GCS_REPORTS_FOLDER_PREFIX}/${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}`;
+const getGcsObjectPath = (relativePath) => `${getRunFolder()}/${relativePath}`;
+
+// ============================================================================
+
 class ResultsParser {
     result;
     separateFlakyTests;
-    // Handle both 0-based and 1-based shard indexing
-    // If MATRIX_SHARD is not set, try to infer from workflow (1-based) or default to 0
-    totalShardCount = process.env.MATRIX_COUNT ? parseInt(process.env.MATRIX_COUNT, 10) : 1;
-    shardIndex = process.env.MATRIX_SHARD !== undefined 
-        ? parseInt(process.env.MATRIX_SHARD, 10) 
-        : (process.env.MATRIX_INDEX !== undefined ? parseInt(process.env.MATRIX_INDEX, 10) : 0);
+    totalShardCount = process.env.TOTAL_SHARDS 
+        ? parseInt(process.env.TOTAL_SHARDS, 10) 
+        : 1;
+    shardIndex = process.env.SHARD_INDEX !== undefined
+        ? parseInt(process.env.SHARD_INDEX, 10)
+        : 1;
     
-    // Determine if we're using 1-based indexing (workflow-style) or 0-based
-    // This is detected by checking if artifacts exist with 1-based naming
-    isOneBasedIndexing = false;
     constructor(options = { separateFlakyTests: false }) {
         this.result = [];
         this.separateFlakyTests = options.separateFlakyTests;
-        // Log shard detection in ResultsParser
-        console.log('🔍 [ResultsParser] Initialized with shard detection:');
-        console.log(`🔍   MATRIX_SHARD env: ${process.env.MATRIX_SHARD !== undefined ? `"${process.env.MATRIX_SHARD}"` : 'undefined'}`);
-        console.log(`🔍   MATRIX_INDEX env: ${process.env.MATRIX_INDEX !== undefined ? `"${process.env.MATRIX_INDEX}"` : 'undefined'}`);
-        console.log(`🔍   MATRIX_COUNT env: ${process.env.MATRIX_COUNT !== undefined ? `"${process.env.MATRIX_COUNT}"` : 'undefined'}`);
-        console.log(`🔍   Calculated shardIndex: ${this.shardIndex}`);
-        console.log(`🔍   Calculated totalShardCount: ${this.totalShardCount}`);
     }
     async getParsedResults() {
       const summary = {
@@ -60,17 +92,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(PLAYWRIGHT_REPORT_DIR)) {
+            fs.mkdirSync(PLAYWRIGHT_REPORT_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(PLAYWRIGHT_REPORT_DIR, `node_summary_${currentNodeIndex}.json`);
 
         const totalTestCasesForNode = this.result.reduce((acc, suite) => acc + suite.testSuite.tests.length, 0);
 
@@ -97,30 +127,22 @@ class ResultsParser {
         // Create the file
         fs.writeFileSync(nodeSummaryFile, JSON.stringify(nodeSummary, null, 2));
 
-        console.log(`🔍 [ResultsParser] Current shard: ${this.shardIndex}, Total shards: ${this.totalShardCount}`);
-        console.log(`🔍 [ResultsParser] Created node summary file: ${nodeSummaryFile}`);
-
-        if (this.shardIndex === 0 && this.totalShardCount > 1) {
-          console.log(`🔍 [ResultsParser] Shard 0 detected with ${this.totalShardCount} total shards - will fetch artifacts from other shards`);
-          if (process.env.CI) {
-            console.log('🔍 [ResultsParser] CI environment detected - fetching all artifacts from GitHub Actions...');
+        if (this.shardIndex === 1 && this.totalShardCount > 1) {
+          if (IS_CI) {
+            console.log('Fetching all artifacts...');
             await this.fetchAllArtifacts();
           } else {
-            console.log('🔍 [ResultsParser] Local environment - waiting for artifacts to appear...');
             while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
-              console.log('🔍 [ResultsParser] Waiting for all artifacts to exist...');
+              console.log('Waiting for all both to exist...');
               await new Promise(resolve => setTimeout(resolve, 1000)); // Wait for 1 second
             }
           }
-        } else {
-          console.log(`🔍 [ResultsParser] Not shard 0 (current: ${this.shardIndex}) or single shard (total: ${this.totalShardCount}) - skipping artifact fetch`);
         }
 
-        if (this.shardIndex === 0 && this.allNodeSummaryFilesExist() && this.allBlobZipsExist()) {
-            console.log(`🔍 [ResultsParser] Shard 0: All artifacts available, merging results from all shards...`);
+        if (this.shardIndex === 1 && this.allNodeSummaryFilesExist() && this.allBlobZipsExist()) {
             // Merge all node summaries into the final summary
-            for (let i = 0; i < this.totalShardCount; i++) {
-                const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+            for (let i = 1; i <= this.totalShardCount; i++) {
+                const nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${i}.json`);
                 const fileToRead = nodeSummaryFile;
 
                 if (fs.existsSync(fileToRead)) {
@@ -155,7 +177,8 @@ class ResultsParser {
                 }
             }
             
-            this.mergeReports();
+            await this.mergeReports();
+            await this.pushReportsToGCS();
         }
         return summary;
     }
@@ -332,10 +355,9 @@ class ResultsParser {
     }*/
     allNodeSummaryFilesExist() {
       console.log('Checking if all node summary files exist...');
-      const summariesDir = path.join('./', 'playwright-report');
       
-      for (let i = 0; i < this.totalShardCount; i++) {
-          const nodeSummaryFile = path.join(summariesDir, `node_summary_${i}.json`);
+      for (let i = 1; i <= this.totalShardCount; i++) {
+          const nodeSummaryFile = path.join(SUMMARIES_DIR, `node_summary_${i}.json`);
           if (!fs.existsSync(nodeSummaryFile)) {
               return false;
           }
@@ -345,10 +367,9 @@ class ResultsParser {
 
     allBlobZipsExist() {
       console.log('Checking if all blob zips exist...');
-      const summariesDir = path.join('./', 'playwright-report');
       
-        for (let i = 0; i < this.totalShardCount; i++) {
-            const blobZipFile = path.join(summariesDir, `blob-report-node-${i}.zip`);
+        for (let i = 1; i <= this.totalShardCount; i++) {
+            const blobZipFile = path.join(SUMMARIES_DIR, `blob-report-node-${i}.zip`);
             if (!fs.existsSync(blobZipFile)) {
                 return false;
             }
@@ -357,109 +378,49 @@ class ResultsParser {
     }
 
     async fetchAllArtifacts() {
-        const summariesDir = path.join('./', 'playwright-report');
-        if (!fs.existsSync(summariesDir)) {
-            fs.mkdirSync(summariesDir, { recursive: true });
-        }
-        
-        console.log(`Shard 0: Waiting for artifacts from ${this.totalShardCount - 1} other shard(s)...`);
-        
-        // Fetch artifacts for shards 1 to totalShardCount-1 (since we're shard 0)
-        // We need to fetch from all other shards before proceeding
-        for (let i = 1; i < this.totalShardCount; i++) {
-            console.log(`Shard 0: Fetching artifacts from shard ${i}...`);
-            await this.fetchArtifact(i, `node_summary_${i}.json`, summariesDir);
-            await this.fetchArtifact(i, `blob-report-node-${i}.zip`, summariesDir);
+        // Ensure summaries directory exists
+        if (!fs.existsSync(SUMMARIES_DIR)) {
+            fs.mkdirSync(SUMMARIES_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)
-        
-        while ((!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) && retryCount < maxRetries) {
-            console.log(`Shard 0: Waiting for all artifacts to be available (attempt ${retryCount + 1}/${maxRetries})...`);
-            
-            // Re-fetch any missing artifacts
-            for (let i = 1; i < this.totalShardCount; i++) {
-                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 0: Re-fetching missing node_summary_${i}.json...`);
-                    await this.fetchArtifact(i, `node_summary_${i}.json`, summariesDir);
-                }
-                
-                if (!fs.existsSync(blobZipFile)) {
-                    console.log(`Shard 0: 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
-            }
+        // Copy entire contents of playwright-report to SUMMARIES_DIR
+        // This copies both blob-report-node-1.zip and node_summary_1.json to SUMMARIES_DIR
+        const playwrightReportDir = path.join('./', 'playwright-report');
+        if (fs.existsSync(playwrightReportDir)) {
+            this.copyDirectoryRecursive(playwrightReportDir, SUMMARIES_DIR);
+            console.log(`Copied entire contents of playwright-report to ${SUMMARIES_DIR}`);
+        } else {
+            console.warn('Warning: playwright-report directory not found');
         }
         
-        if (this.allNodeSummaryFilesExist() && this.allBlobZipsExist()) {
-            console.log(`Shard 0: Successfully fetched all artifacts from ${this.totalShardCount - 1} other shard(s).`);
-        } else {
-            console.warn(`Shard 0: Warning - Some artifacts may still be missing after ${maxRetries} attempts.`);
+        while (!this.allNodeSummaryFilesExist() || !this.allBlobZipsExist()) {
+          console.log('Checking if all node summary files exist...');
+          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`, SUMMARIES_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);
     }
 
-    // Helper to extract shard index from artifact name
-    extractShardIndexFromArtifactName(artifactName, i) {
-        // Try to extract number from artifact name (e.g., html-report-1 -> 1)
-        const match = artifactName.match(/-(\d+)$/);
-        if (match) {
-            const artifactShard = parseInt(match[1], 10);
-            // If artifact uses 1-based indexing, convert to 0-based for internal use
-            // html-report-1 (workflow) -> shard 0 (internal)
-            // html-report-2 (workflow) -> shard 1 (internal)
-            return artifactShard - 1;
-        }
-        // Fallback to the provided index
-        return i;
-    }
-
     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:
-        // 1. html-report-{i} (1-based workflow style)
-        // 2. blob-report-node-{i} (direct blob reports)
-        // 3. test-results-{i} (alternative naming)
-        // Note: i is 0-based internally, so for 1-based workflows we need i+1
-        const artifactNamePatterns = [
-            `html-report-${i + 1}`,  // 1-based workflow style (most common)
-            `blob-report-node-${i}`,  // 0-based direct blob
-            `blob-report-node-${i + 1}`, // 1-based direct blob
-            `html-report-${i}`,       // 0-based html-report
-            `test-results-${i + 1}`,  // Alternative naming
-        ];
+        const githubApiUrl = getGitHubArtifactsApiUrl();
+        const artifactNamePatterns = getArtifactNamePatterns(i);
         
         while (true) {
             try {
                 // List all artifacts to find the one we need
                 const listResponse = await axios.get(githubApiUrl, {
                     headers: {
-                        'Authorization': `token ${githubToken}`,
+                        'Authorization': `token ${GITHUB_TOKEN}`,
                         'Accept': 'application/vnd.github.v3+json'
                     },
                     params: {
@@ -472,22 +433,17 @@ class ResultsParser {
                 for (const pattern of artifactNamePatterns) {
                     artifact = listResponse.data.artifacts.find(
                         (a) => a.name === pattern || 
-                               a.name.includes(`shard-${i}`) || 
-                               a.name.includes(`shard-${i + 1}`) ||
-                               a.name.includes(`node-${i}`) ||
-                               a.name.includes(`node-${i + 1}`)
+                               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) {
                     // Download the artifact ZIP
                     const downloadResponse = await axios.get(artifact.archive_download_url, {
                         headers: {
-                            'Authorization': `token ${githubToken}`,
+                            'Authorization': `token ${GITHUB_TOKEN}`,
                             'Accept': 'application/vnd.github.v3+json'
                         },
                         responseType: 'arraybuffer'
@@ -500,113 +456,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}`,
-                            `playwright-report/${file}`,
-                            `html-report-${i + 1}/${file}`,
-                            `html-report-${i}/${file}`,
-                        ];
-                        for (const possiblePath of possiblePaths) {
-                            zipEntry = zip.getEntry(possiblePath);
-                            if (zipEntry) break;
-                        }
-                    }
+                    const zipEntry = zip.getEntry(file) || zip.getEntry(`playwright-artifacts/${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);
-                        
-                        // Extract shard index from artifact name to handle files named with index 0
-                        const artifactShardIndex = this.extractShardIndexFromArtifactName(artifact.name, i);
-                        
-                        // Look for the file recursively, also try with shard index from artifact name
-                        const searchInDir = (dir, targetFile, alternateTargetFile = null) => {
-                            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, alternateTargetFile);
-                                    if (found) return found;
-                                } else {
-                                    // Check exact match
-                                    if (entry.name === targetFile) {
-                                        return fullPath;
-                                    }
-                                    // Check alternate filename (e.g., node_summary_0.json when we need node_summary_1.json)
-                                    if (alternateTargetFile && entry.name === alternateTargetFile) {
-                                        return fullPath;
-                                    }
-                                    // Check if ends with target file
-                                    if (entry.name.endsWith(targetFile)) {
-                                        return fullPath;
-                                    }
-                                }
-                            }
-                            return null;
-                        };
-                        
-                        // Try to find the file, also try with shard index from artifact
-                        let foundPath = searchInDir(extractPath, file);
-                        
-                        // If file uses index 0 pattern (like node_summary_0.json or blob-report-node-0.zip)
-                        // but we need it for a different shard, try to find any matching pattern
-                        if (!foundPath && (file.includes('_0') || file.includes('-node-0'))) {
-                            // Recursively search for any node_summary or blob-report file
-                            const findAllFiles = (dir, pattern) => {
-                                const results = [];
-                                try {
-                                    const entries = fs.readdirSync(dir, { withFileTypes: true });
-                                    for (const entry of entries) {
-                                        const fullPath = path.join(dir, entry.name);
-                                        if (entry.isDirectory()) {
-                                            results.push(...findAllFiles(fullPath, pattern));
-                                        } else if (entry.name.includes(pattern)) {
-                                            results.push(fullPath);
-                                        }
-                                    }
-                                } catch (e) {
-                                    // Ignore errors
-                                }
-                                return results;
-                            };
-                            
-                            // Find any node_summary or blob-report files
-                            const matchingFiles = findAllFiles(extractPath, file.includes('node_summary') ? 'node_summary' : 'blob-report');
-                            
-                            if (matchingFiles.length > 0) {
-                                foundPath = matchingFiles[0];
-                                // Copy to the expected path with correct shard index
-                                fs.copyFileSync(foundPath, filePath);
-                                console.log(`Found and copied file ${path.basename(foundPath)} -> ${file} from artifact ${artifact.name}`);
-                                // Clean up temp directory
-                                fs.rmSync(extractPath, { recursive: true, force: true });
-                                break;
-                            }
-                        }
-                        
-                        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...`);
@@ -614,22 +472,39 @@ 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;
                 }
             }
         }
     }
-    mergeReports() {
+    async mergeReports() {
       let breakMergeWaiter = false;
       try {
-        // Execute the command to merge reports
-        exec(`npx playwright merge-reports --reporter html -c ./playwright-report playwright-report`);
-        // Wait until index.html exists
-        while (!fs.existsSync(path.join('./playwright-report', 'index.html'))) {
+        
+        // Copy all blob files to playwright-report before merging
+        for (let i = 1; i <= this.totalShardCount; i++) {
+            const blobZipFile = path.join(SUMMARIES_DIR, `blob-report-node-${i}.zip`);
+            if (fs.existsSync(blobZipFile)) {
+                try {
+                    const destFile = path.join(PLAYWRIGHT_REPORT_DIR, `blob-report-node-${i}.zip`);
+                    fs.copyFileSync(blobZipFile, destFile);
+                    console.log(`Copied blob-report-node-${i}.zip to playwright-report for merging`);
+                } catch (error) {
+                    console.warn(`Failed to copy blob-report-node-${i}.zip for merging:`, error.message);
+                }
+            }
+        }
+        
+        // Execute the command to merge reports FROM playwright-report
+        // Playwright will output to playwright-report directory
+        exec(`npx playwright merge-reports --reporter html ${PLAYWRIGHT_REPORT_DIR}`);
+        
+        // Wait until index.html exists in playwright-report
+        while (!fs.existsSync(path.join(PLAYWRIGHT_REPORT_DIR, 'index.html'))) {
           console.log('Waiting 2 seconds for merged html report to be generated...');
           const currentTime = new Date().getTime();
           breakMergeWaiter = false;
@@ -640,10 +515,209 @@ class ResultsParser {
           }
         }
         console.log('Reports merged successfully.');
+        
+        // After merge, extract all blobs from SUMMARIES_DIR to playwright-report
+        this.unzipBlobsAndCopyResources(SUMMARIES_DIR, PLAYWRIGHT_REPORT_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);
       }
     }
+    
+    copyDirectoryRecursive(srcDir, destDir) {
+        if (!fs.existsSync(destDir)) {
+            fs.mkdirSync(destDir, { recursive: true });
+        }
+        
+        const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+            const srcPath = path.join(srcDir, entry.name);
+            const destPath = path.join(destDir, entry.name);
+            
+            if (entry.isDirectory()) {
+                this.copyDirectoryRecursive(srcPath, destPath);
+            } else {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+    
+    unzipBlobsAndCopyResources(ARTIFACTS_DIR, FINAL_OUTPUT_DIR) {
+        if (!AdmZip) {
+            console.error('adm-zip is required for blob extraction. Please install it: npm install adm-zip');
+            return;
+        }
+        
+        // Unzip all blob files into separate folders
+        for (let i = 1; i <= this.totalShardCount; i++) {
+            const blobZipFile = path.join(ARTIFACTS_DIR, `blob-report-node-${i}.zip`);
+            if (fs.existsSync(blobZipFile)) {
+                const extractDir = path.join(ARTIFACTS_DIR, `${GITHUB_RUN_ID}-blob-contents-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(FINAL_OUTPUT_DIR, '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);
+                }
+            }
+        }
+    }
+    
+    async getGcsAccessToken() {
+        if (!GCS_SERVICE_ACCOUNT_KEY) {
+            throw new Error('GCS_SERVICE_ACCOUNT_KEY environment variable is required');
+        }
+        
+        let serviceAccount;
+        try {
+            serviceAccount = JSON.parse(GCS_SERVICE_ACCOUNT_KEY);
+        } catch (e) {
+            // Try reading from file path
+            if (fs.existsSync(GCS_SERVICE_ACCOUNT_KEY)) {
+                serviceAccount = JSON.parse(fs.readFileSync(GCS_SERVICE_ACCOUNT_KEY, 'utf-8'));
+            } else {
+                throw new Error('Invalid GCS_SERVICE_ACCOUNT_KEY: must be JSON string or file path');
+            }
+        }
+        
+        // Request OAuth2 token from Google
+        const jwt = require('jsonwebtoken');
+        const now = Math.floor(Date.now() / 1000);
+        const token = jwt.sign(
+            {
+                iss: serviceAccount.client_email,
+                scope: 'https://www.googleapis.com/auth/devstorage.full_control',
+                aud: 'https://oauth2.googleapis.com/token',
+                exp: now + 3600,
+                iat: now
+            },
+            serviceAccount.private_key,
+            { algorithm: 'RS256' }
+        );
+        
+        const tokenResponse = await axios.post('https://oauth2.googleapis.com/token', {
+            grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+            assertion: token
+        });
+        
+        return tokenResponse.data.access_token;
+    }
+    
+    async pushReportsToGCS() {
+        // Only push in CI environment with required configuration
+        if (!IS_CI || !GCS_SERVICE_ACCOUNT_KEY) {
+            console.log('Skipping GCS push: not in CI or missing GCS_SERVICE_ACCOUNT_KEY');
+            return;
+        }
+        
+        try {
+            console.log(`Uploading playwright-report files to GCS bucket: ${GCS_BUCKET_NAME} in folder: ${getRunFolder()}`);
+            
+            // Get access token
+            const accessToken = await this.getGcsAccessToken();
+            
+            // Collect all files from playwright-report directory
+            const files = this.getAllFilesRecursive(PLAYWRIGHT_REPORT_DIR);
+            
+            // Normalize the base directory path for path replacement
+            const baseDirPath = path.resolve(PLAYWRIGHT_REPORT_DIR);
+            
+            // Upload all files to GCS
+            for (const file of files) {
+                // Get relative path from playwright-report directory
+                const relativePath = path.relative(baseDirPath, file).replace(/\\/g, '/');
+                const objectPath = getGcsObjectPath(relativePath);
+                const content = fs.readFileSync(file);
+                
+                // Upload file to GCS
+                const uploadUrl = `${GCS_UPLOAD_API_BASE_URL}/b/${GCS_BUCKET_NAME}/o?uploadType=media&name=${encodeURIComponent(objectPath)}`;
+                
+                await axios.post(uploadUrl, content, {
+                    headers: {
+                        'Authorization': `Bearer ${accessToken}`,
+                        'Content-Type': this.getContentType(file)
+                    }
+                });
+                
+                console.log(`Uploaded ${objectPath} to GCS`);
+            }
+            
+            console.log(`Successfully uploaded ${files.length} files to GCS bucket: ${GCS_BUCKET_NAME} in folder: ${getRunFolder()}`);
+        } catch (error) {
+            console.warn('Warning: Failed to push reports to GCS. This may not affect the overall process.', error.message);
+            if (error.response) {
+                console.warn('GCS API error:', error.response.data);
+            }
+        }
+    }
+    
+    getContentType(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const contentTypes = {
+            '.html': 'text/html',
+            '.css': 'text/css',
+            '.js': 'application/javascript',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.gif': 'image/gif',
+            '.svg': 'image/svg+xml',
+            '.zip': 'application/zip',
+            '.txt': 'text/plain',
+            '.xml': 'application/xml'
+        };
+        return contentTypes[ext] || 'application/octet-stream';
+    }
+    
+    getAllFilesRecursive(dir, fileList = []) {
+        if (!fs.existsSync(dir)) {
+            return fileList;
+        }
+        
+        const files = fs.readdirSync(dir);
+        
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const stat = fs.statSync(filePath);
+            
+            if (stat.isDirectory()) {
+                this.getAllFilesRecursive(filePath, fileList);
+            } else {
+                fileList.push(filePath);
+            }
+        }
+        
+        return fileList;
+    }
 }
 exports.default = ResultsParser;

package/dist/src/SlackReporter.js

@@ -6,13 +6,7 @@ const webhook_1 = require("@slack/webhook");
 const ResultsParser_1 = require("./ResultsParser");
 const SlackClient_1 = require("./SlackClient");
 const SlackWebhookClient_1 = require("./SlackWebhookClient");
-let axios;
-try {
-    axios = require('axios');
-} catch (e) {
-    // axios optional for GitHub Actions API detection
-    axios = null;
-}
+
 class SlackReporter {
     customLayout;
     customLayoutAsync;
@@ -71,303 +65,18 @@ class SlackReporter {
     onTestEnd(test, result) {
         this.resultsParser.addTestResult(test.parent.title, test, this.browsers);
     }
-    /**
-     * Detect GitHub Actions shard information using GitHub API
-     * Returns { shardIndex: number, totalShards: number } or null if detection fails
-     */
-    async detectGitHubActionsShardInfo() {
-        // Check if we're in GitHub Actions
-        if (!process.env.GITHUB_ACTIONS || process.env.GITHUB_ACTIONS !== 'true') {
-            return null;
-        }
-        // Try GITHUB_TOKEN first (automatic), then fallback to custom token
-        const githubToken = process.env.GITHUB_TOKEN || process.env.SAFETYWINGTEST_GITHUB_TOKEN;
-        const repo = process.env.GITHUB_REPOSITORY;
-        const runId = process.env.GITHUB_RUN_ID;
-        const currentJobId = process.env.GITHUB_JOB;
-        if (!githubToken || !repo || !runId) {
-            this.log(`🔍 [GitHub Actions Detection] Missing required env vars: GITHUB_TOKEN=${!!process.env.GITHUB_TOKEN}, SAFETYWINGTEST_GITHUB_TOKEN=${!!process.env.SAFETYWINGTEST_GITHUB_TOKEN}, GITHUB_REPOSITORY=${!!repo}, GITHUB_RUN_ID=${!!runId}`);
-            return null;
-        }
-        this.log(`🔍 [GitHub Actions Detection] Using token: ${process.env.GITHUB_TOKEN ? 'GITHUB_TOKEN' : 'SAFETYWINGTEST_GITHUB_TOKEN'}`);
-        this.log(`🔍 [GitHub Actions Detection] Repository: ${repo}, Run ID: ${runId}`);
-        if (!axios) {
-            this.log(`🔍 [GitHub Actions Detection] axios not available, skipping API detection`);
-            return null;
-        }
-        try {
-            // Get workflow run details
-            const apiUrl = `https://api.github.com/repos/${repo}/actions/runs/${runId}/jobs`;
-            this.log(`🔍 [GitHub Actions Detection] API URL: ${apiUrl}`);
-            const response = await axios.get(apiUrl, {
-                headers: {
-                    'Accept': 'application/vnd.github+json',
-                    'Authorization': `Bearer ${githubToken}`,
-                    'X-GitHub-Api-Version': '2022-11-28'
-                },
-                params: {
-                    per_page: 100
-                }
-            });
-            const jobs = response.data.jobs || [];
-            if (jobs.length === 0) {
-                this.log(`🔍 [GitHub Actions Detection] No jobs found in workflow run`);
-                return null;
-            }
-            
-            this.log(`🔍 [GitHub Actions Detection] Found ${jobs.length} total jobs in workflow run`);
-            
-            // Helper function to normalize job names by removing shard indicators
-            // e.g., "Run tests (shard 3/4)" -> "Run tests"
-            const normalizeJobName = (name) => {
-                if (!name) return '';
-                // Remove common matrix patterns: (shard X/Y), (X, Y), [X], etc.
-                return name
-                    .replace(/\s*\(shard\s+\d+\/\d+\)/gi, '')
-                    .replace(/\s*\(\d+\/\d+\)/g, '')
-                    .replace(/\s*\(\d+,\s*\d+\)/g, '')
-                    .replace(/\s*\[\d+\]/g, '')
-                    .trim();
-            };
-            
-            // Group jobs by normalized name to find matrix jobs
-            const jobGroups = {};
-            for (const job of jobs) {
-                const jobName = job.name || '';
-                const normalizedName = normalizeJobName(jobName);
-                if (!jobGroups[normalizedName]) {
-                    jobGroups[normalizedName] = [];
-                }
-                jobGroups[normalizedName].push(job);
-            }
-            
-            this.log(`🔍 [GitHub Actions Detection] Grouped into ${Object.keys(jobGroups).length} job group(s)`);
-            for (const [groupName, groupJobs] of Object.entries(jobGroups)) {
-                this.log(`🔍   Group "${groupName}": ${groupJobs.length} job(s)`);
-            }
-            
-            // Find the job group that contains the current job
-            let currentJob = null;
-            let jobGroup = null;
-            
-            // First, try to find by job name match
-            for (const job of jobs) {
-                if (job.name && (job.name.includes(currentJobId) || currentJobId.includes(job.name))) {
-                    currentJob = job;
-                    const normalizedName = normalizeJobName(job.name);
-                    jobGroup = jobGroups[normalizedName];
-                    this.log(`🔍 [GitHub Actions Detection] Matched current job by name: "${job.name}"`);
-                    break;
-                }
-            }
-            
-            // If still no match, use all jobs as fallback
-            if (!jobGroup || jobGroup.length === 0) {
-                this.log(`🔍 [GitHub Actions Detection] Could not match job, using all jobs as group`);
-                jobGroup = jobs;
-                currentJob = jobs[0];
-            }
-            // Sort jobs by name or ID to get consistent ordering
-            jobGroup.sort((a, b) => {
-                if (a.name && b.name) {
-                    return a.name.localeCompare(b.name);
-                }
-                return a.id - b.id;
-            });
-            
-            // Find index of current job in the sorted group
-            const currentJobIndex = jobGroup.findIndex(j => j.id === currentJob?.id || j.name === currentJob?.name);
-            
-            // Try to extract shard number from job name (e.g., "shard 3/4" -> index 2)
-            let shardIndex = currentJobIndex >= 0 ? currentJobIndex : 0;
-            if (currentJob && currentJob.name) {
-                const shardMatch = currentJob.name.match(/shard\s+(\d+)\/(\d+)/i);
-                if (shardMatch) {
-                    const shardNum = parseInt(shardMatch[1], 10);
-                    const totalFromName = parseInt(shardMatch[2], 10);
-                    // Convert to 0-based index (shard 3/4 -> index 2)
-                    shardIndex = shardNum - 1;
-                    this.log(`🔍 [GitHub Actions Detection] Extracted shard info from name: ${shardNum}/${totalFromName} -> index ${shardIndex}`);
-                }
-            }
-            
-            const totalShards = jobGroup.length;
-            this.log(`🔍 [GitHub Actions Detection] Detected via API:`);
-            this.log(`🔍   Total jobs in group: ${totalShards}`);
-            this.log(`🔍   Current job index: ${shardIndex}`);
-            this.log(`🔍   Current job ID: ${currentJobId}`);
-            this.log(`🔍   Current job name: ${currentJob?.name || 'unknown'}`);
-            return {
-                shardIndex,
-                totalShards
-            };
-        } catch (error) {
-            const apiUrl = `https://api.github.com/repos/${repo}/actions/runs/${runId}/jobs`;
-            this.log(`🔍 [GitHub Actions Detection] Failed to detect via API: ${error.message}`);
-            if (error.response) {
-                const status = error.response.status;
-                const data = error.response.data;
-                this.log(`🔍   Status: ${status}, URL: ${apiUrl}`);
-                
-                if (status === 404) {
-                    this.log(`🔍   404 Error Details:`);
-                    this.log(`🔍     - Repository: ${repo}`);
-                    this.log(`🔍     - Run ID: ${runId}`);
-                    this.log(`🔍     - Possible causes:`);
-                    this.log(`🔍       1. Token lacks 'actions: read' permission`);
-                    this.log(`🔍       2. Workflow run doesn't exist or isn't accessible`);
-                    this.log(`🔍       3. Jobs not available yet (try accessing after workflow starts)`);
-                    this.log(`🔍     - Recommendation: Set MATRIX_SHARD and MATRIX_COUNT env vars as fallback`);
-                } else if (status === 401 || status === 403) {
-                    this.log(`🔍   Authentication/Authorization Error:`);
-                    this.log(`🔍     - Token may be invalid or lack required permissions`);
-                    this.log(`🔍     - Required permission: 'actions: read' or 'repo' scope`);
-                }
-                
-                if (data && data.message) {
-                    this.log(`🔍   Error message: ${data.message}`);
-                }
-            } else {
-                this.log(`🔍   Network error or no response received`);
-            }
-            return null;
-        }
-    }
     async onEnd() {
         const { okToProceed, message } = this.preChecks();
         if (!okToProceed) {
             this.log(message);
             return;
         }
-        // SHARDING SUPPORT - Stop slack messages for non-zero index shard(s)
-        // Only shard 0 (0-based) should post when aggregating results from multiple shards
-        
-        this.log('🔍 [Shard Detection] Starting shard detection logic...');
-        
-        // Log all relevant environment variables
-        this.log(`🔍 [Shard Detection] Environment variables:`);
-        this.log(`🔍   CI: ${process.env.CI !== undefined ? `"${process.env.CI}"` : 'undefined'}`);
-        this.log(`🔍   GITHUB_ACTIONS: ${process.env.GITHUB_ACTIONS !== undefined ? `"${process.env.GITHUB_ACTIONS}"` : 'undefined'}`);
-        this.log(`🔍   GITHUB_JOB: ${process.env.GITHUB_JOB !== undefined ? `"${process.env.GITHUB_JOB}"` : 'undefined'}`);
-        this.log(`🔍   MATRIX_SHARD: ${process.env.MATRIX_SHARD !== undefined ? `"${process.env.MATRIX_SHARD}"` : 'undefined'}`);
-        this.log(`🔍   MATRIX_INDEX: ${process.env.MATRIX_INDEX !== undefined ? `"${process.env.MATRIX_INDEX}"` : 'undefined'}`);
-        this.log(`🔍   MATRIX_COUNT: ${process.env.MATRIX_COUNT !== undefined ? `"${process.env.MATRIX_COUNT}"` : 'undefined'}`);
-        
-        // Step 1: Try GitHub Actions API detection (most robust for GitHub Actions)
-        let githubApiShardInfo = null;
-        if (process.env.GITHUB_ACTIONS === 'true') {
-            this.log(`🔍 [Shard Detection] Attempting GitHub Actions API detection...`);
-            githubApiShardInfo = await this.detectGitHubActionsShardInfo();
-        }
-        
-        // Step 2: Detect shard index from environment variables (priority)
-        let currentShardIndex = process.env.MATRIX_SHARD !== undefined 
-            ? process.env.MATRIX_SHARD 
-            : (process.env.MATRIX_INDEX !== undefined ? process.env.MATRIX_INDEX : undefined);
-        
-        // Step 3: Use GitHub API detection if env vars not set
-        if (currentShardIndex === undefined && githubApiShardInfo) {
-            currentShardIndex = githubApiShardInfo.shardIndex.toString();
-            this.log(`🔍 [Shard Detection] Using GitHub API detected shardIndex: "${currentShardIndex}"`);
-        }
-        
-        this.log(`🔍 [Shard Detection] Initial currentShardIndex: ${currentShardIndex !== undefined ? `"${currentShardIndex}"` : 'undefined'}`);
-        
-        // Step 4: Get shard count from multiple sources (priority order)
-        let totalShards;
-        if (process.env.MATRIX_COUNT !== undefined) {
-            totalShards = parseInt(process.env.MATRIX_COUNT, 10);
-            this.log(`🔍 [Shard Detection] Using MATRIX_COUNT env var: ${totalShards}`);
-        } else if (githubApiShardInfo && githubApiShardInfo.totalShards > 1) {
-            totalShards = githubApiShardInfo.totalShards;
-            this.log(`🔍 [Shard Detection] Using GitHub API detected totalShards: ${totalShards}`);
-        } else {
-            // Fallback to ResultsParser
-            const parserTotalShards = this.resultsParser.totalShardCount;
-            totalShards = parserTotalShards;
-            this.log(`🔍 [Shard Detection] Using ResultsParser totalShards: ${totalShards}`);
-        }
-        
-        // Get shard info from ResultsParser for fallback
-        const parserShardIndex = this.resultsParser.shardIndex;
-        const parserTotalShards = this.resultsParser.totalShardCount;
-        
-        this.log(`🔍 [Shard Detection] ResultsParser values:`);
-        this.log(`🔍   parserShardIndex: ${parserShardIndex !== undefined ? parserShardIndex : 'undefined'}`);
-        this.log(`🔍   parserTotalShards: ${parserTotalShards !== undefined ? parserTotalShards : 'undefined'}`);
-        
-        this.log(`🔍 [Shard Detection] Calculated totalShards: ${totalShards}`);
-        
-        // If we still don't have shard index, try to infer from parser or GitHub API
-        if (currentShardIndex === undefined) {
-            if (githubApiShardInfo && githubApiShardInfo.shardIndex !== undefined) {
-                currentShardIndex = githubApiShardInfo.shardIndex.toString();
-                this.log(`🔍 [Shard Detection] Using GitHub API shardIndex as fallback: "${currentShardIndex}"`);
-            } else if (parserShardIndex !== undefined) {
-                currentShardIndex = parserShardIndex.toString();
-                this.log(`🔍 [Shard Detection] Using parserShardIndex as fallback: "${currentShardIndex}"`);
-            }
-        }
-        
-        // CRITICAL: In CI (especially GitHub Actions), if we can't detect shard info, block posting
-        // This prevents duplicate messages when running with multiple shards
-        if (process.env.CI && currentShardIndex === undefined) {
-            if (process.env.GITHUB_ACTIONS === 'true') {
-                this.log(`❌ [Shard Detection] BLOCKING: GitHub Actions detected but shard index cannot be determined.`);
-                this.log(`❌   Attempted: GitHub API detection ${githubApiShardInfo ? 'succeeded' : 'failed'}, env vars not set`);
-                this.log(`❌   This prevents duplicate messages when running with multiple shards.`);
-            } else {
-                this.log(`❌ [Shard Detection] BLOCKING: CI environment detected but shard info not set.`);
-                this.log(`❌   MATRIX_COUNT: undefined, MATRIX_SHARD: undefined`);
-                this.log(`❌   This prevents duplicate messages when running with multiple shards.`);
-            }
-            this.log(`❌ Skipping Slack report to prevent duplicate messages from all shards.`);
-            this.log(`💡 Fix: Add these env vars to your workflow:`);
-            this.log(`💡   env:`);
-            this.log(`💡     MATRIX_SHARD: $\{\{ strategy.job-index \}\}  # 0-based (only shard 0 posts)`);
-            this.log(`💡     MATRIX_COUNT: $\{\{ strategy.job-total \}\}`);
-            this.log(`💡   OR ensure SAFETYWINGTEST_GITHUB_TOKEN has workflow permissions for API detection`);
-            return;
-        }
-        
-        // Convert to number for comparison (default to 0 if undefined)
-        const shardIndexNum = currentShardIndex !== undefined ? parseInt(currentShardIndex, 10) : 0;
-        
-        this.log(`🔍 [Shard Detection] Final values:`);
-        this.log(`🔍   currentShardIndex (string): ${currentShardIndex !== undefined ? `"${currentShardIndex}"` : 'undefined'}`);
-        this.log(`🔍   shardIndexNum (number): ${shardIndexNum}`);
-        this.log(`🔍   totalShards: ${totalShards}`);
-        
-        // CRITICAL: For GitHub Actions with multiple shards, only shard 0 should post
-        // If we're in CI with multiple shards and don't know which shard we are, block all posts
-        // This prevents duplicate messages when MATRIX_SHARD/MATRIX_INDEX is not set
-        if (process.env.CI && totalShards > 1 && currentShardIndex === undefined) {
-            this.log(`❌ [Shard Detection] BLOCKING: CI environment detected with ${totalShards} shards but shard index not set (MATRIX_SHARD/MATRIX_INDEX missing).`);
-            this.log(`❌ Skipping Slack report to prevent duplicate messages from all shards.`);
-            this.log(`💡 Fix: Add these env vars to your workflow:`);
-            this.log(`💡   env:`);
-            this.log(`💡     MATRIX_SHARD: $\{\{ strategy.job-index \}\}  # 0-based (only shard 0 posts)`);
-            this.log(`💡     MATRIX_COUNT: $\{\{ strategy.job-total \}\}`);
-            return;
-        }
-        
-        // Only allow shard 0 (0-based) to post when there are multiple shards
-        // This ensures only one shard posts the aggregated report
-        if (totalShards > 1 && shardIndexNum !== 0) {
-            this.log(`❌ [Shard Detection] BLOCKING: Non-zero shard detected (shard ${currentShardIndex} of ${totalShards})`);
-            this.log(`❌ Stopping reporter for non-zero index shard ${currentShardIndex} of ${totalShards}`);
-            this.log(`ℹ️ Only shard 0 will post the aggregated report.`);
-            return;
-        }
-        
-        // Single shard - always allow posting
-        if (totalShards === 1) {
-            this.log(`✅ [Shard Detection] ALLOWING: Single shard detected. Posting Slack report.`);
-        } else {
-            this.log(`✅ [Shard Detection] ALLOWING: Multiple shards detected (${totalShards}). Shard ${currentShardIndex} (index ${shardIndexNum}) will post aggregated report.`);
-        }
-        
         const resultSummary = await this.resultsParser.getParsedResults();
+        // SHARDING SUPPORT - Stop slack messages for non-shard-1 shard(s)
+        if (process.env.SHARD_INDEX && process.env.SHARD_INDEX !== '1') {
+          this.log(`❌ Stopping reporter for non-shard-1 index ${process.env.SHARD_INDEX} of ${process.env.TOTAL_SHARDS}`);
+          return;
+        }
         resultSummary.meta = this.meta;
         const maxRetry = Math.max(...resultSummary.tests.map((o) => o.retry));
         if (this.sendResults === 'on-failure'

package/package.json

@@ -4,7 +4,8 @@
     "@slack/webhook": "^6.1.0",
     "https-proxy-agent": "^7.0.1",
     "adm-zip": "^0.5.10",
-    "axios": "^1.0.0"
+    "axios": "^1.0.0",
+    "jsonwebtoken": "^9.0.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.23.3",
@@ -32,7 +33,7 @@
     "lint-fix": "npx eslint . --ext .ts --fix"
   },
   "name": "playwright-slack-report-burak",
-  "version": "3.0.112",
+  "version": "3.1.0",
   "main": "index.js",
   "types": "dist/index.d.ts",
   "author": "Burak B. <burak.boluk@hotmail.com>",