playwright-slack-report-burak 3.0.20 → 3.0.22

package/dist/src/ResultsParser.js

@@ -33,16 +33,12 @@ try {
 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.TOTAL_SHARDS 
         ? parseInt(process.env.TOTAL_SHARDS, 10) 
-        : (process.env.MATRIX_COUNT ? parseInt(process.env.MATRIX_COUNT, 10) : 1);
+        : 1;
     shardIndex = process.env.SHARD_INDEX !== undefined
         ? parseInt(process.env.SHARD_INDEX, 10)
-        : (process.env.MATRIX_SHARD !== undefined 
-            ? parseInt(process.env.MATRIX_SHARD, 10) 
-            : (process.env.MATRIX_INDEX !== undefined ? parseInt(process.env.MATRIX_INDEX, 10) : 0));
+        : 1;
     
     constructor(options = { separateFlakyTests: false }) {
         this.result = [];
@@ -438,17 +434,14 @@ class ResultsParser {
         // 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, i is already 1-based)
-        // 2. blob-report-node-{i} (direct blob reports, i is 1-based)
-        // 3. test-results-{i} (alternative naming, i is 1-based)
-        // Note: i is 1-based internally now, so we use it directly for GitHub 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)
         const artifactNamePatterns = [
-            `html-report-${i}`,  // 1-based workflow style (i is already 1-based)
-            `blob-report-node-${i}`,  // 1-based direct blob
-            `html-report-${i - 1}`,       // 0-based html-report (fallback)
-            `blob-report-node-${i - 1}`,  // 0-based direct blob (fallback)
-            `test-results-${i}`,  // Alternative naming
+            `html-report-${i}`,
+            `blob-report-node-${i}`,
+            `test-results-${i}`,
         ];
         
         while (true) {
@@ -469,10 +462,8 @@ 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})`);
@@ -506,9 +497,8 @@ class ResultsParser {
                         const possiblePaths = [
                             file,
                             `playwright-report/${file}`,
-                            `playwright-report/${file}`,
                             `html-report-${i}/${file}`,
-                            `html-report-${i - 1}/${file}`,
+                            `html-report-${i}/playwright-report/${file}`,
                         ];
                         for (const possiblePath of possiblePaths) {
                             zipEntry = zip.getEntry(possiblePath);
@@ -526,22 +516,18 @@ class ResultsParser {
                         zip.extractAllTo(extractPath, true);
                         
                         // Look for the file recursively
-                        const searchInDir = (dir, targetFile, alternateTargetFile = null) => {
+                        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, alternateTargetFile);
+                                    const found = searchInDir(fullPath, targetFile);
                                     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;
@@ -551,45 +537,9 @@ class ResultsParser {
                             return null;
                         };
                         
-                        // Try to find the file, also try with shard index from artifact
+                        // Try to find the file recursively
                         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})`);

package/dist/src/SlackReporter.js

@@ -90,240 +90,6 @@ 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;
-            
-            // Strategy 1: Find the currently running job (status: in_progress or completed recently)
-            const runningJobs = jobs.filter(j => j.status === 'in_progress' || j.status === 'queued');
-            this.log(`🔍 [GitHub Actions Detection] Found ${runningJobs.length} running/queued job(s)`);
-            
-            if (runningJobs.length === 1) {
-                // Perfect - only one job is running, must be us
-                currentJob = runningJobs[0];
-                const normalizedName = normalizeJobName(currentJob.name);
-                jobGroup = jobGroups[normalizedName];
-                this.log(`🔍 [GitHub Actions Detection] Matched by running status: "${currentJob.name}"`);
-            } else if (runningJobs.length > 1) {
-                // Multiple running jobs - try to match by job ID or name
-                for (const job of runningJobs) {
-                    // Check if this job's name contains the GITHUB_JOB id
-                    // But be more specific - avoid matching "Generate test matrix" when looking for "test"
-                    const jobIdLower = currentJobId.toLowerCase();
-                    const jobNameLower = (job.name || '').toLowerCase();
-                    
-                    // Match if job name starts with or equals the job ID (more specific)
-                    if (jobNameLower.startsWith(jobIdLower) || 
-                        jobNameLower.includes(`${jobIdLower} `) ||
-                        jobNameLower.includes(`${jobIdLower}(`) ||
-                        jobNameLower === jobIdLower) {
-                        currentJob = job;
-                        const normalizedName = normalizeJobName(job.name);
-                        jobGroup = jobGroups[normalizedName];
-                        this.log(`🔍 [GitHub Actions Detection] Matched running job by ID match: "${job.name}"`);
-                        break;
-                    }
-                }
-                
-                // Still no match? Take the first running job that looks like a test job
-                if (!currentJob) {
-                    for (const job of runningJobs) {
-                        if (job.name && (job.name.includes('shard') || job.name.includes('test') || job.name.includes('matrix'))) {
-                            currentJob = job;
-                            const normalizedName = normalizeJobName(job.name);
-                            jobGroup = jobGroups[normalizedName];
-                            this.log(`🔍 [GitHub Actions Detection] Matched by test-like name: "${job.name}"`);
-                            break;
-                        }
-                    }
-                }
-            }
-            
-            // Strategy 2: If no running job found, look at all jobs
-            if (!currentJob) {
-                this.log(`🔍 [GitHub Actions Detection] No running job matched, checking all jobs`);
-                for (const job of jobs) {
-                    const jobIdLower = currentJobId.toLowerCase();
-                    const jobNameLower = (job.name || '').toLowerCase();
-                    
-                    if (jobNameLower.startsWith(jobIdLower) || 
-                        jobNameLower.includes(`${jobIdLower} `) ||
-                        jobNameLower.includes(`${jobIdLower}(`)) {
-                        currentJob = job;
-                        const normalizedName = normalizeJobName(job.name);
-                        jobGroup = jobGroups[normalizedName];
-                        this.log(`🔍 [GitHub Actions Detection] Matched job by name: "${job.name}"`);
-                        break;
-                    }
-                }
-            }
-            
-            // Fallback: Use the largest job group (likely the matrix jobs)
-            if (!jobGroup || jobGroup.length === 0) {
-                this.log(`🔍 [GitHub Actions Detection] Could not match job, using largest job group`);
-                let largestGroup = [];
-                let largestGroupName = '';
-                for (const [groupName, groupJobs] of Object.entries(jobGroups)) {
-                    if (groupJobs.length > largestGroup.length) {
-                        largestGroup = groupJobs;
-                        largestGroupName = groupName;
-                    }
-                }
-                jobGroup = largestGroup;
-                currentJob = jobGroup[0];
-                this.log(`🔍 [GitHub Actions Detection] Using largest group "${largestGroupName}" with ${jobGroup.length} job(s)`);
-            }
-            // 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 3)
-            // GitHub Actions uses 1-based indexing (shard 1, 2, 3, 4), we keep it 1-based internally for shard 1 logic
-            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); // 1-based from GitHub Actions (1, 2, 3, 4)
-                    const totalFromName = parseInt(shardMatch[2], 10);
-                    // Keep GitHub Actions 1-based indexing (shard 1 -> index 1, shard 2 -> index 2, etc.)
-                    // This allows shard 1 to be the aggregator
-                    shardIndex = shardNum;
-                    this.log(`🔍 [GitHub Actions Detection] Extracted shard info from name: ${shardNum}/${totalFromName} (GitHub Actions 1-based) -> index ${shardIndex} (internal 1-based)`);
-                }
-            }
-            
-            // If we couldn't extract from name but have job index, convert from 0-based array index to 1-based
-            // GitHub Actions jobs are numbered starting from 1, so array index 0 = shard 1, index 1 = shard 2, etc.
-            // We need to convert: array index 0 -> shard 1, array index 1 -> shard 2, etc.
-            if (shardIndex === currentJobIndex && currentJobIndex >= 0) {
-                shardIndex = currentJobIndex + 1; // Convert 0-based array index to 1-based shard index
-                this.log(`🔍 [GitHub Actions Detection] Using array index ${currentJobIndex} -> shard ${shardIndex} (1-based)`);
-            }
-            
-            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) {
@@ -333,209 +99,35 @@ class SlackReporter {
         // SHARDING SUPPORT - Stop slack messages for non-shard-1 shard(s)
         // Only shard 1 should post when aggregating results from multiple shards
         
-        this.log('🔍 [Shard Detection] Starting shard detection logic...');
-        
-        // Check if we're actually running in GitHub Actions (not just env vars set locally)
-        const isActuallyInGitHubActions = process.env.GITHUB_ACTIONS === 'true' && 
-                                          process.env.GITHUB_RUN_ID !== undefined &&
-                                          process.env.GITHUB_RUNNER_NAME !== undefined;
+        // Get shard info from environment variables
+        const currentShardIndex = process.env.SHARD_INDEX;
+        const totalShards = process.env.TOTAL_SHARDS ? parseInt(process.env.TOTAL_SHARDS, 10) : 1;
         
-        // 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(`🔍   GITHUB_RUN_ID: ${process.env.GITHUB_RUN_ID !== undefined ? `"${process.env.GITHUB_RUN_ID}"` : 'undefined'}`);
-        this.log(`🔍   GITHUB_RUNNER_NAME: ${process.env.GITHUB_RUNNER_NAME !== undefined ? `"${process.env.GITHUB_RUNNER_NAME}"` : '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'}`);
-        
-        // Check for Playwright shard environment variables (Playwright may set these)
-        this.log(`🔍   PLAYWRIGHT_SHARD: ${process.env.PLAYWRIGHT_SHARD !== undefined ? `"${process.env.PLAYWRIGHT_SHARD}"` : 'undefined'}`);
-        this.log(`🔍   SHARD_INDEX: ${process.env.SHARD_INDEX !== undefined ? `"${process.env.SHARD_INDEX}"` : 'undefined'}`);
-        this.log(`🔍   TOTAL_SHARDS: ${process.env.TOTAL_SHARDS !== undefined ? `"${process.env.TOTAL_SHARDS}"` : 'undefined'}`);
-        
-        // Check Playwright's shard config (highest priority for local runs)
-        let playwrightShardInfo = null;
-        if (this.fullConfig) {
-            // Debug: log config structure
-            this.log(`🔍 [Shard Detection] Checking Playwright config for shard info...`);
-            this.log(`🔍   fullConfig.shard: ${this.fullConfig.shard ? JSON.stringify(this.fullConfig.shard) : 'undefined'}`);
-            
-            if (this.fullConfig.shard) {
-                // Playwright shard can be either { current, total } or undefined
-                if (this.fullConfig.shard.current !== undefined && this.fullConfig.shard.total !== undefined) {
-                    playwrightShardInfo = {
-                        current: this.fullConfig.shard.current,
-                        total: this.fullConfig.shard.total
-                    };
-                    this.log(`🔍 [Shard Detection] Found Playwright shard config: ${playwrightShardInfo.current}/${playwrightShardInfo.total}`);
-                } else {
-                    this.log(`🔍 [Shard Detection] Playwright shard config exists but missing current/total properties`);
-                }
-            } else {
-                this.log(`🔍 [Shard Detection] No Playwright shard config found in fullConfig`);
-            }
-        } else {
-            this.log(`🔍 [Shard Detection] fullConfig not available`);
-        }
-        
-        // Also check if shard info is in process.argv (command line)
-        // This is a fallback if config doesn't have it but --shard was passed
-        if (!playwrightShardInfo && process.argv) {
-            const shardArg = process.argv.find(arg => arg && arg.includes('--shard'));
-            if (shardArg) {
-                const shardMatch = shardArg.match(/--shard[=:]?(\d+)\/(\d+)/);
-                if (shardMatch) {
-                    playwrightShardInfo = {
-                        current: parseInt(shardMatch[1], 10),
-                        total: parseInt(shardMatch[2], 10)
-                    };
-                    this.log(`🔍 [Shard Detection] Found shard in command line args: ${playwrightShardInfo.current}/${playwrightShardInfo.total} (1-based)`);
-                }
-            }
-        }
-        
-        // Step 1: Try GitHub Actions API detection (only if actually in GitHub Actions)
-        let githubApiShardInfo = null;
-        if (isActuallyInGitHubActions) {
-            this.log(`🔍 [Shard Detection] Actually running in GitHub Actions - attempting API detection...`);
-            githubApiShardInfo = await this.detectGitHubActionsShardInfo();
-        } else if (process.env.GITHUB_ACTIONS === 'true') {
-            this.log(`🔍 [Shard Detection] GitHub Actions env vars set but not actually in runner - skipping API detection`);
-        }
-        
-        // Step 2: Detect shard index (priority order: Playwright config > env vars > GitHub API)
-        let currentShardIndex;
-        if (playwrightShardInfo) {
-            // Playwright uses 1-based indexing, keep it 1-based for shard 1 logic
-            currentShardIndex = playwrightShardInfo.current.toString();
-            this.log(`🔍 [Shard Detection] Using Playwright shard config (1-based): "${currentShardIndex}"`);
-        } else if (process.env.SHARD_INDEX !== undefined) {
-            currentShardIndex = process.env.SHARD_INDEX;
-            this.log(`🔍 [Shard Detection] Using SHARD_INDEX env var: "${currentShardIndex}"`);
-        } else if (process.env.MATRIX_SHARD !== undefined) {
-            currentShardIndex = process.env.MATRIX_SHARD;
-            this.log(`🔍 [Shard Detection] Using MATRIX_SHARD env var: "${currentShardIndex}"`);
-        } else if (process.env.MATRIX_INDEX !== undefined) {
-            currentShardIndex = process.env.MATRIX_INDEX;
-            this.log(`🔍 [Shard Detection] Using MATRIX_INDEX env var: "${currentShardIndex}"`);
-        } else if (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 3: Get shard count from multiple sources (priority order)
-        let totalShards;
-        if (playwrightShardInfo) {
-            totalShards = playwrightShardInfo.total;
-            this.log(`🔍 [Shard Detection] Using Playwright shard config totalShards: ${totalShards}`);
-        } else if (process.env.TOTAL_SHARDS !== undefined) {
-            totalShards = parseInt(process.env.TOTAL_SHARDS, 10);
-            this.log(`🔍 [Shard Detection] Using TOTAL_SHARDS env var: ${totalShards}`);
-        } else 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
+        // CRITICAL: In CI, if we can't detect shard info, block posting
         // This prevents duplicate messages when running with multiple shards
-        // BUT: Don't block if we're running locally (even if CI env vars are set)
-        // Note: GitHub Actions uses 1-based indexing (shard 1, 2, 3, 4), but we use 0-based internally
-        if (isActuallyInGitHubActions && 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.`);
-            }
+        if (process.env.CI && currentShardIndex === undefined && totalShards > 1) {
+            this.log(`❌ [Shard Detection] BLOCKING: CI environment detected but SHARD_INDEX not set.`);
+            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(`💡 Fix: Add SHARD_INDEX env var to your workflow:`);
             this.log(`💡   env:`);
-            this.log(`💡     MATRIX_SHARD: $\{\{ strategy.job-index \}\}  # GitHub Actions uses 1-based, convert to 0-based (only shard 1/internal index 1 posts)`);
-            this.log(`💡     MATRIX_COUNT: $\{\{ strategy.job-total \}\}`);
-            this.log(`💡   OR ensure SAFETYWINGTEST_GITHUB_TOKEN has workflow permissions for API detection`);
+            this.log(`💡     SHARD_INDEX: $\{\{ strategy.job-index \}\}  # Only shard 1 should post`);
+            this.log(`💡     TOTAL_SHARDS: $\{\{ strategy.job-total \}\}`);
             return;
         }
         
         // Convert to number for comparison (default to 1 if undefined, since shard 1 is the aggregator)
         const shardIndexNum = currentShardIndex !== undefined ? parseInt(currentShardIndex, 10) : 1;
         
-        this.log(`🔍 [Shard Detection] Final values:`);
-        this.log(`🔍   currentShardIndex (string): ${currentShardIndex !== undefined ? `"${currentShardIndex}"` : 'undefined'}`);
-        this.log(`🔍   shardIndexNum (number): ${shardIndexNum}`);
-        this.log(`🔍   totalShards: ${totalShards}`);
-        
         // CRITICAL: Update ResultsParser with detected shard values immediately after detection
         // This ensures ResultsParser always has correct values, even if we block posting
         this.resultsParser.updateShardInfo(shardIndexNum, totalShards);
         
-        // For local runs with CI env vars set but not actually in CI, allow posting if single shard
-        // or if shard index is 1
-        if (!isActuallyInGitHubActions && process.env.CI && totalShards > 1 && currentShardIndex === undefined) {
-            this.log(`⚠️ [Shard Detection] Local run with CI env vars but shard info unclear - allowing post (may cause duplicates)`);
-        }
-        
-        // CRITICAL: For GitHub Actions with multiple shards, only shard 1 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
-        // Note: GitHub Actions uses 1-based indexing (shard 1, 2, 3, 4)
-        // We use 0-based internally, so GitHub Actions shard 1 = internal index 1
-        if (isActuallyInGitHubActions && totalShards > 1 && currentShardIndex === undefined) {
-            this.log(`❌ [Shard Detection] BLOCKING: GitHub Actions 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 \}\}  # GitHub Actions uses 1-based, convert to 0-based (only shard 1/internal index 1 posts)`);
-            this.log(`💡     MATRIX_COUNT: $\{\{ strategy.job-total \}\}`);
-            this.log(`💡   OR ensure SAFETYWINGTEST_GITHUB_TOKEN has workflow permissions for API detection`);
-            return;
-        }
-        
         // Only allow shard 1 to post when there are multiple shards
         // This ensures only one shard posts the aggregated report
-        // Note: GitHub Actions uses 1-based indexing (shard 1, 2, 3, 4)
-        // We use 0-based internally, so shard 1 in GitHub Actions = index 1 internally
         if (totalShards > 1 && shardIndexNum !== 1) {
-            // Convert back to 1-based for display if from GitHub Actions
-            const displayShard = isActuallyInGitHubActions ? shardIndexNum + 1 : shardIndexNum;
-            this.log(`❌ [Shard Detection] BLOCKING: Non-shard-1 detected (shard ${displayShard} of ${totalShards}${isActuallyInGitHubActions ? ' [GitHub Actions 1-based]' : ''})`);
-            this.log(`❌ Stopping reporter for shard ${displayShard} of ${totalShards}`);
+            this.log(`❌ [Shard Detection] BLOCKING: Non-shard-1 detected (shard ${shardIndexNum} of ${totalShards})`);
+            this.log(`❌ Stopping reporter for shard ${shardIndexNum} of ${totalShards}`);
             this.log(`ℹ️ Only shard 1 will post the aggregated report.`);
             return;
         }
@@ -544,9 +136,7 @@ class SlackReporter {
         if (totalShards === 1) {
             this.log(`✅ [Shard Detection] ALLOWING: Single shard detected. Posting Slack report.`);
         } else {
-            // Convert back to 1-based for display if from GitHub Actions
-            const displayShard = isActuallyInGitHubActions ? shardIndexNum + 1 : shardIndexNum;
-            this.log(`✅ [Shard Detection] ALLOWING: Multiple shards detected (${totalShards}). Shard ${displayShard} (index ${shardIndexNum}${isActuallyInGitHubActions ? ', GitHub Actions 1-based' : ''}) will post aggregated report.`);
+            this.log(`✅ [Shard Detection] ALLOWING: Multiple shards detected (${totalShards}). Shard ${shardIndexNum} will post aggregated report.`);
         }
         
         const resultSummary = await this.resultsParser.getParsedResults();

package/package.json

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