codeceptjs 3.7.5-beta.14 → 3.7.5-beta.16

package/bin/codecept.js

@@ -296,29 +296,6 @@ program
 
   .action(require('../lib/command/run-rerun'))
 
-program
-  .command('run-failed-tests')
-  .description('Re-run tests that failed in the previous test run')
-  .option(commandFlags.config.flag, commandFlags.config.description)
-  .option(commandFlags.profile.flag, commandFlags.profile.description)
-  .option(commandFlags.verbose.flag, commandFlags.verbose.description)
-  .option(commandFlags.debug.flag, commandFlags.debug.description)
-  .option(commandFlags.steps.flag, commandFlags.steps.description)
-  .option('-o, --override [value]', 'override current config options')
-  .option('-f, --file [path]', 'path to failed tests file (default: ./failed-tests.json)')
-  .option('-g, --grep <pattern>', 'only run failed tests matching <pattern>')
-  .option('-p, --plugins <k=v,k2=v2,...>', 'enable plugins, comma-separated')
-  .option('--features', 'run only *.feature files and skip tests')
-  .option('--tests', 'run only JS test files and skip features')
-  .option('--colors', 'force enabling of colors')
-  .option('--no-colors', 'force disabling of colors')
-  .option('-R, --reporter <name>', 'specify the reporter to use')
-  .option('-O, --reporter-options <k=v,k2=v2,...>', 'reporter-specific options')
-  .option('--workers <number>', 'run failed tests in parallel using specified number of workers')
-  .option('--suites', 'parallel execution of suites not single tests (when using --workers)')
-  .option('--by <strategy>', 'test distribution strategy when using --workers: "test", "suite", or "pool"')
-  .action(errorHandler(require('../lib/command/run-failed-tests')))
-
 program.on('command:*', cmd => {
   console.log(`\nUnknown command ${cmd}\n`)
   program.outputHelp()

package/lib/helper/Playwright.js

@@ -642,6 +642,9 @@ class Playwright extends Helper {
   async _after() {
     if (!this.isRunning) return
 
+    // Clear popup state to prevent leakage between tests
+    popupStore.clear()
+
     if (this.isElectron) {
       this.browser.close()
       this.electronSessions.forEach(session => session.close())

package/lib/helper/Puppeteer.js

@@ -330,6 +330,9 @@ class Puppeteer extends Helper {
   async _after() {
     if (!this.isRunning) return
 
+    // Clear popup state to prevent leakage between tests
+    popupStore.clear()
+
     // close other sessions
     const contexts = this.browser.browserContexts()
     const defaultCtx = contexts.shift()

package/lib/listener/enhancedGlobalRetry.js

@@ -0,0 +1,110 @@
+const event = require('../event')
+const output = require('../output')
+const Config = require('../config')
+const { isNotSet } = require('../utils')
+
+const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
+
+/**
+ * Priority levels for retry mechanisms (higher number = higher priority)
+ * This ensures consistent behavior when multiple retry mechanisms are active
+ */
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50, // retryFailedStep plugin
+  SCENARIO_CONFIG: 30, // Global scenario retry config
+  FEATURE_CONFIG: 20, // Global feature retry config
+  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+}
+
+/**
+ * Enhanced global retry mechanism that coordinates with other retry types
+ */
+module.exports = function () {
+  event.dispatcher.on(event.suite.before, suite => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // is number - apply as feature-level retry
+      const retryNum = +retryConfig
+      output.log(`[Global Retry] Feature retries: ${retryNum}`)
+
+      // Only set if not already set by higher priority mechanism
+      if (isNotSet(suite.retries())) {
+        suite.retries(retryNum)
+        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!suite.title.includes(config.grep)) continue
+      }
+
+      // Handle hook retries with priority awareness
+      hooks
+        .filter(hook => !!config[hook])
+        .forEach(hook => {
+          const retryKey = `retry${hook}`
+          if (isNotSet(suite.opts[retryKey])) {
+            suite.opts[retryKey] = config[hook]
+            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
+          }
+        })
+
+      // Handle feature-level retries
+      if (config.Feature) {
+        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+          suite.retries(config.Feature)
+          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
+        }
+      }
+    }
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    let retryConfig = Config.get('retry')
+    if (!retryConfig) return
+
+    if (Number.isInteger(+retryConfig)) {
+      // Only set if not already set by higher priority mechanism
+      if (test.retries() === -1) {
+        test.retries(retryConfig)
+        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
+      }
+      return
+    }
+
+    if (!Array.isArray(retryConfig)) {
+      retryConfig = [retryConfig]
+    }
+
+    retryConfig = retryConfig.filter(config => !!config.Scenario)
+
+    for (const config of retryConfig) {
+      if (config.grep) {
+        if (!test.fullTitle().includes(config.grep)) continue
+      }
+
+      if (config.Scenario) {
+        // Respect priority system
+        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
+          test.retries(config.Scenario)
+          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+          output.log(`[Global Retry] Scenario retries: ${config.Scenario}`)
+        }
+      }
+    }
+  })
+}
+
+// Export priority constants for use by other retry mechanisms
+module.exports.RETRY_PRIORITIES = RETRY_PRIORITIES

package/lib/mocha/test.js

@@ -121,7 +121,6 @@ function serializeTest(test, error = null) {
   }
 
   return {
-    file: test.file ? relativeDir(test.file) : undefined,
     opts: test.opts || {},
     tags: test.tags || [],
     uid: test.uid,

package/lib/plugin/enhancedRetryFailedStep.js

@@ -0,0 +1,99 @@
+const event = require('../event')
+const recorder = require('../recorder')
+const store = require('../store')
+const output = require('../output')
+const { RETRY_PRIORITIES } = require('../retryCoordinator')
+
+const defaultConfig = {
+  retries: 3,
+  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
+  factor: 1.5,
+  ignoredSteps: [],
+}
+
+/**
+ * Enhanced retryFailedStep plugin that coordinates with other retry mechanisms
+ *
+ * This plugin provides step-level retries and coordinates with global retry settings
+ * to avoid conflicts and provide predictable behavior.
+ */
+module.exports = config => {
+  config = Object.assign({}, defaultConfig, config)
+  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
+  const customWhen = config.when
+
+  let enableRetry = false
+
+  const when = err => {
+    if (!enableRetry) return false
+    if (store.debugMode) return false
+    if (!store.autoRetries) return false
+    if (customWhen) return customWhen(err)
+    return true
+  }
+  config.when = when
+
+  event.dispatcher.on(event.step.started, step => {
+    // if a step is ignored - return
+    for (const ignored of config.ignoredSteps) {
+      if (step.name === ignored) return
+      if (ignored instanceof RegExp) {
+        if (step.name.match(ignored)) return
+      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
+    }
+    enableRetry = true // enable retry for a step
+  })
+
+  event.dispatcher.on(event.step.finished, () => {
+    enableRetry = false
+  })
+
+  event.dispatcher.on(event.test.before, test => {
+    // pass disableRetryFailedStep is a preferred way to disable retries
+    // test.disableRetryFailedStep is used for backward compatibility
+    if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
+      store.autoRetries = false
+      output.log(`[Step Retry] Disabled for test: ${test.title}`)
+      return // disable retry when a test is not active
+    }
+
+    // Check if step retries should be disabled due to higher priority scenario retries
+    const scenarioRetries = test.retries()
+    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
+    const scenarioPriority = test.opts.retryPriority || 0
+
+    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
+      // Scenario retries are configured with higher or equal priority
+      // Option 1: Disable step retries (conservative approach)
+      store.autoRetries = false
+      output.log(`[Step Retry] Deferred to scenario retries (${scenarioRetries} retries)`)
+      return
+
+      // Option 2: Reduce step retries to avoid excessive total retries
+      // const reducedStepRetries = Math.max(1, Math.floor(config.retries / scenarioRetries))
+      // config.retries = reducedStepRetries
+      // output.log(`[Step Retry] Reduced to ${reducedStepRetries} retries due to scenario retries (${scenarioRetries})`)
+    }
+
+    // this option is used to set the retries inside _before() block of helpers
+    store.autoRetries = true
+    test.opts.conditionalRetries = config.retries
+    test.opts.stepRetryPriority = stepRetryPriority
+
+    recorder.retry(config)
+
+    output.log(`[Step Retry] Enabled with ${config.retries} retries for test: ${test.title}`)
+  })
+
+  // Add coordination info for debugging
+  event.dispatcher.on(event.test.finished, test => {
+    if (test.state === 'passed' && test.opts.conditionalRetries && store.autoRetries) {
+      const stepRetries = test.opts.conditionalRetries || 0
+      const scenarioRetries = test.retries() || 0
+
+      if (stepRetries > 0 && scenarioRetries > 0) {
+        output.log(`[Retry Coordination] Test used both step retries (${stepRetries}) and scenario retries (${scenarioRetries})`)
+      }
+    }
+  })
+}

package/lib/recorder.js

@@ -11,6 +11,7 @@ let running = false
 let errFn
 let queueId = 0
 let sessionId = null
+let sessionStack = [] // Stack to support nested sessions
 let asyncErr = null
 let ignoredErrs = []
 
@@ -89,6 +90,7 @@ module.exports = {
     if (promise && running) this.catch()
     queueId++
     sessionId = null
+    sessionStack = [] // Clear the session stack
     asyncErr = null
     log(`${currentQueue()} Starting recording promises`)
     promise = Promise.resolve()
@@ -123,8 +125,13 @@ module.exports = {
      */
     start(name) {
       if (sessionId) {
-        debug(`${currentQueue()}Session already started as ${sessionId}`)
-        this.restore(sessionId)
+        debug(`${currentQueue()}Session already started as ${sessionId}, nesting session ${name}`)
+        // Push current session to stack instead of restoring it
+        sessionStack.push({
+          id: sessionId,
+          promise: promise,
+          running: this.running,
+        })
       }
       debug(`${currentQueue()}Starting <${name}> session`)
       tasks.push('--->')
@@ -142,9 +149,18 @@ module.exports = {
       tasks.push('<---')
       debug(`${currentQueue()}Finalize <${name}> session`)
       this.running = false
-      sessionId = null
       this.catch(errFn)
       promise = promise.then(() => oldPromises.pop())
+
+      // Restore parent session from stack if available
+      if (sessionStack.length > 0) {
+        const parentSession = sessionStack.pop()
+        sessionId = parentSession.id
+        this.running = parentSession.running
+        debug(`${currentQueue()}Restored parent session <${sessionId}>`)
+      } else {
+        sessionId = null
+      }
     },
 
     /**

package/lib/retryCoordinator.js

@@ -0,0 +1,207 @@
+const output = require('./output')
+
+/**
+ * Retry Coordinator - Central coordination for all retry mechanisms
+ *
+ * This module provides:
+ * 1. Priority-based retry coordination
+ * 2. Unified configuration validation
+ * 3. Consolidated retry reporting
+ * 4. Conflict detection and resolution
+ */
+
+/**
+ * Priority levels for retry mechanisms (higher number = higher priority)
+ */
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50, // retryFailedStep plugin
+  SCENARIO_CONFIG: 30, // Global scenario retry config
+  FEATURE_CONFIG: 20, // Global feature retry config
+  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+}
+
+/**
+ * Retry mechanism types
+ */
+const RETRY_TYPES = {
+  MANUAL_STEP: 'manual-step',
+  STEP_PLUGIN: 'step-plugin',
+  SCENARIO: 'scenario',
+  FEATURE: 'feature',
+  HOOK: 'hook',
+}
+
+/**
+ * Global retry coordination state
+ */
+let retryState = {
+  activeTest: null,
+  activeSuite: null,
+  retryHistory: [],
+  conflicts: [],
+}
+
+/**
+ * Registers a retry mechanism for coordination
+ * @param {string} type - Type of retry mechanism
+ * @param {Object} config - Retry configuration
+ * @param {Object} target - Target object (test, suite, etc.)
+ * @param {number} priority - Priority level
+ */
+function registerRetry(type, config, target, priority = 0) {
+  const retryInfo = {
+    type,
+    config,
+    target,
+    priority,
+    timestamp: Date.now(),
+  }
+
+  // Detect conflicts
+  const existingRetries = retryState.retryHistory.filter(r => r.target === target && r.type !== type && r.priority !== priority)
+
+  if (existingRetries.length > 0) {
+    const conflict = {
+      newRetry: retryInfo,
+      existingRetries: existingRetries,
+      resolved: false,
+    }
+    retryState.conflicts.push(conflict)
+    handleRetryConflict(conflict)
+  }
+
+  retryState.retryHistory.push(retryInfo)
+
+  output.log(`[Retry Coordinator] Registered ${type} retry (priority: ${priority})`)
+}
+
+/**
+ * Handles conflicts between retry mechanisms
+ * @param {Object} conflict - Conflict information
+ */
+function handleRetryConflict(conflict) {
+  const { newRetry, existingRetries } = conflict
+
+  // Find highest priority retry
+  const allRetries = [newRetry, ...existingRetries]
+  const highestPriority = Math.max(...allRetries.map(r => r.priority))
+  const winningRetry = allRetries.find(r => r.priority === highestPriority)
+
+  // Log the conflict resolution
+  output.log(`[Retry Coordinator] Conflict detected:`)
+  allRetries.forEach(retry => {
+    const status = retry === winningRetry ? 'ACTIVE' : 'DEFERRED'
+    output.log(`  - ${retry.type} (priority: ${retry.priority}) [${status}]`)
+  })
+
+  conflict.resolved = true
+  conflict.winner = winningRetry
+}
+
+/**
+ * Gets the effective retry configuration for a target
+ * @param {Object} target - Target object (test, suite, etc.)
+ * @returns {Object} Effective retry configuration
+ */
+function getEffectiveRetryConfig(target) {
+  const targetRetries = retryState.retryHistory.filter(r => r.target === target)
+
+  if (targetRetries.length === 0) {
+    return { type: 'none', retries: 0 }
+  }
+
+  // Find highest priority retry
+  const highestPriority = Math.max(...targetRetries.map(r => r.priority))
+  const effectiveRetry = targetRetries.find(r => r.priority === highestPriority)
+
+  return {
+    type: effectiveRetry.type,
+    retries: effectiveRetry.config.retries || effectiveRetry.config,
+    config: effectiveRetry.config,
+  }
+}
+
+/**
+ * Generates a retry summary report
+ * @returns {Object} Retry summary
+ */
+function generateRetrySummary() {
+  const summary = {
+    totalRetryMechanisms: retryState.retryHistory.length,
+    conflicts: retryState.conflicts.length,
+    byType: {},
+    recommendations: [],
+  }
+
+  // Count by type
+  retryState.retryHistory.forEach(retry => {
+    summary.byType[retry.type] = (summary.byType[retry.type] || 0) + 1
+  })
+
+  // Generate recommendations
+  if (summary.conflicts > 0) {
+    summary.recommendations.push('Consider consolidating retry configurations to avoid conflicts')
+  }
+
+  if (summary.byType[RETRY_TYPES.STEP_PLUGIN] && summary.byType[RETRY_TYPES.SCENARIO]) {
+    summary.recommendations.push('Step-level and scenario-level retries are both active - consider using only one approach')
+  }
+
+  return summary
+}
+
+/**
+ * Resets the retry coordination state (useful for testing)
+ */
+function reset() {
+  retryState = {
+    activeTest: null,
+    activeSuite: null,
+    retryHistory: [],
+    conflicts: [],
+  }
+}
+
+/**
+ * Validates retry configuration for common issues
+ * @param {Object} config - Configuration object
+ * @returns {Array} Array of validation warnings
+ */
+function validateConfig(config) {
+  const warnings = []
+
+  if (!config) return warnings
+
+  // Check for potential configuration conflicts
+  if (config.retry && config.plugins && config.plugins.retryFailedStep) {
+    const globalRetries = typeof config.retry === 'number' ? config.retry : config.retry.Scenario || config.retry.Feature
+    const stepRetries = config.plugins.retryFailedStep.retries || 3
+
+    if (globalRetries && stepRetries) {
+      warnings.push(`Both global retries (${globalRetries}) and step retries (${stepRetries}) are configured - total executions could be ${globalRetries * (stepRetries + 1)}`)
+    }
+  }
+
+  // Check for excessive retry counts
+  if (config.retry) {
+    const retryValues = typeof config.retry === 'number' ? [config.retry] : Object.values(config.retry)
+    const maxRetries = Math.max(...retryValues.filter(v => typeof v === 'number'))
+
+    if (maxRetries > 5) {
+      warnings.push(`High retry count detected (${maxRetries}) - consider investigating test stability instead`)
+    }
+  }
+
+  return warnings
+}
+
+module.exports = {
+  RETRY_PRIORITIES,
+  RETRY_TYPES,
+  registerRetry,
+  getEffectiveRetryConfig,
+  generateRetrySummary,
+  validateConfig,
+  reset,
+}

package/lib/utils.js

@@ -203,7 +203,7 @@ module.exports.test = {
           if (fs.existsSync(dataFile)) {
             break
           }
-          
+
           // Use Node.js child_process.spawnSync with platform-specific sleep commands
           // This avoids busy waiting and allows other processes to run
           try {
@@ -221,7 +221,7 @@ module.exports.test = {
               // No-op loop - much lighter than previous approaches
             }
           }
-          
+
           // Exponential backoff: gradually increase polling interval to reduce resource usage
           pollInterval = Math.min(pollInterval * 1.2, maxPollInterval)
         }
@@ -576,6 +576,52 @@ module.exports.humanizeString = function (string) {
   return _result.join(' ').trim()
 }
 
+/**
+ * Creates a circular-safe replacer function for JSON.stringify
+ * @param {string[]} keysToSkip - Keys to skip during serialization to break circular references
+ * @returns {Function} Replacer function for JSON.stringify
+ */
+function createCircularSafeReplacer(keysToSkip = []) {
+  const seen = new WeakSet()
+  const defaultSkipKeys = ['parent', 'tests', 'suite', 'root', 'runner', 'ctx']
+  const skipKeys = new Set([...defaultSkipKeys, ...keysToSkip])
+
+  return function (key, value) {
+    // Skip specific keys that commonly cause circular references
+    if (key && skipKeys.has(key)) {
+      return undefined
+    }
+
+    if (value === null || typeof value !== 'object') {
+      return value
+    }
+
+    // Handle circular references
+    if (seen.has(value)) {
+      return `[Circular Reference to ${value.constructor?.name || 'Object'}]`
+    }
+
+    seen.add(value)
+    return value
+  }
+}
+
+/**
+ * Safely stringify an object, handling circular references
+ * @param {any} obj - Object to stringify
+ * @param {string[]} keysToSkip - Additional keys to skip during serialization
+ * @param {number} space - Number of spaces for indentation (default: 0)
+ * @returns {string} JSON string representation
+ */
+module.exports.safeStringify = function (obj, keysToSkip = [], space = 0) {
+  try {
+    return JSON.stringify(obj, createCircularSafeReplacer(keysToSkip), space)
+  } catch (error) {
+    // Fallback for any remaining edge cases
+    return JSON.stringify({ error: `Failed to serialize: ${error.message}` }, null, space)
+  }
+}
+
 module.exports.serializeError = function (error) {
   if (error) {
     const { stack, uncaught, message, actual, expected } = error

package/lib/workers.js

@@ -310,28 +310,11 @@ class Workers extends EventEmitter {
     const groups = populateGroups(numberOfWorkers)
     let groupCounter = 0
 
-    // If specific tests are provided (e.g., from run-failed-tests), only include those
-    const targetTests = this.options && this.options.tests
-    const exactTestTitles = this.options && this.options.exactTestTitles
-    
     mocha.suite.eachTest(test => {
+      const i = groupCounter % groups.length
       if (test) {
-        let shouldInclude = true
-        
-        // If we have specific target tests by UID, only include matching UIDs
-        if (targetTests && targetTests.length > 0) {
-          shouldInclude = targetTests.includes(test.uid)
-        }
-        // If we have exact test titles, only include tests with exact matching titles
-        else if (exactTestTitles && exactTestTitles.length > 0) {
-          shouldInclude = exactTestTitles.some(title => title === test.title)
-        }
-        
-        if (shouldInclude) {
-          const i = groupCounter % groups.length
-          groups[i].push(test.uid)
-          groupCounter++
-        }
+        groups[i].push(test.uid)
+        groupCounter++
       }
     })
     return groups

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "3.7.5-beta.14",
+  "version": "3.7.5-beta.16",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [
     "acceptance",
@@ -157,7 +157,7 @@
     "jsdoc-typeof-plugin": "1.0.0",
     "json-server": "0.17.4",
     "mochawesome": "^7.1.3",
-    "playwright": "1.54.1",
+    "playwright": "1.55.0",
     "prettier": "^3.3.2",
     "puppeteer": "24.15.0",
     "qrcode-terminal": "0.12.0",

package/lib/command/run-failed-tests.js

@@ -1,268 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const { getConfig, printError, getTestRoot, createOutputDir } = require('./utils')
-const Config = require('../config')
-const store = require('../store')
-const Codecept = require('../codecept')
-const output = require('../output')
-const Workers = require('../workers')
-const { tryOrDefault } = require('../utils')
-
-module.exports = async function (options) {
-  // registering options globally to use in config
-  if (options.profile) {
-    process.env.profile = options.profile
-  }
-  if (options.verbose || options.debug) store.debugMode = true
-
-  const configFile = options.config
-  let config = getConfig(configFile)
-  
-  if (options.override) {
-    config = Config.append(JSON.parse(options.override))
-  }
-  
-  const testRoot = getTestRoot(configFile)
-  createOutputDir(config, testRoot)
-
-  // Determine failed tests file path - respect CodeceptJS output directory
-  const failedTestsFile = options.file || 'failed-tests.json'
-  const failedTestsPath = path.isAbsolute(failedTestsFile)
-    ? failedTestsFile
-    : path.resolve(global.output_dir || './output', failedTestsFile)
-
-  // Check if failed tests file exists
-  if (!fs.existsSync(failedTestsPath)) {
-    output.error(`Failed tests file not found: ${failedTestsPath}`)
-    output.print('Run tests first to generate a failed tests file, or specify a different file with --file option')
-    process.exitCode = 1
-    return
-  }
-
-  let failedTestsData
-  try {
-    const fileContent = fs.readFileSync(failedTestsPath, 'utf8')
-    failedTestsData = JSON.parse(fileContent)
-  } catch (error) {
-    output.error(`Failed to read or parse failed tests file: ${error.message}`)
-    process.exitCode = 1
-    return
-  }
-
-  if (!failedTestsData.tests || failedTestsData.tests.length === 0) {
-    output.print('No failed tests found in the file')
-    return
-  }
-
-  output.print(`Found ${failedTestsData.tests.length} failed tests from ${failedTestsData.timestamp}`)
-
-  // Debug: Show what's in the failed tests data
-  if (options.verbose) {
-    output.print('\nFailed tests data structure:')
-    failedTestsData.tests.forEach((test, index) => {
-      output.print(`  ${index + 1}. Title: "${test.title}", UID: "${test.uid}", File: "${test.file}"`)
-    })
-    output.print('')
-  }
-
-  // Build test patterns from failed tests
-  const testPatterns = []
-  const testsByFile = new Map()
-
-  // Group tests by file for more efficient execution
-  failedTestsData.tests.forEach(test => {
-    if (test.file) {
-      if (!testsByFile.has(test.file)) {
-        testsByFile.set(test.file, [])
-      }
-      testsByFile.get(test.file).push(test)
-    }
-  })
-
-  // Build precise test selection from failed tests
-  if (testsByFile.size > 0) {
-    // Use file paths for loading tests
-    for (const [file, tests] of testsByFile) {
-      testPatterns.push(file)
-    }
-    
-    // Create a map of exact test titles to target for filtering
-    const failedTestTitles = new Set(failedTestsData.tests.map(test => test.title).filter(Boolean))
-    
-    if (failedTestTitles.size > 0) {
-      output.print(`Targeting ${failedTestTitles.size} specific failed tests by exact title matching`)
-      options.exactTestTitles = Array.from(failedTestTitles)
-    } else {
-      output.print('No specific test titles found, running all tests in files')
-    }
-  } else {
-    // Fallback: use test titles with exact match grep
-    const testTitles = failedTestsData.tests.map(test => test.title).filter(Boolean)
-    if (testTitles.length > 0) {
-      const grepPattern = testTitles.map(title => `^${title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`).join('|')
-      options.grep = grepPattern
-      output.print(`Targeting failed tests by title pattern (no file info available)`)
-    }
-  }
-
-  // Check if user wants to run with workers
-  if (options.workers) {
-    await runWithWorkers(config, options, testPatterns, failedTestsData)
-  } else {
-    await runWithoutWorkers(config, options, testPatterns, failedTestsData, testRoot)
-  }
-}
-
-async function runWithWorkers(config, options, testPatterns, failedTestsData) {
-  const numberOfWorkers = parseInt(options.workers, 10)
-  const overrideConfigs = tryOrDefault(() => JSON.parse(options.override || '{}'), {})
-  
-  // Determine test split strategy
-  let by = 'test' // default for failed tests
-  if (options.by) {
-    by = options.by
-  } else if (options.suites) {
-    by = 'suite'
-  }
-
-  // Validate the by option
-  const validStrategies = ['test', 'suite', 'pool']
-  if (!validStrategies.includes(by)) {
-    throw new Error(`Invalid --by strategy: ${by}. Valid options are: ${validStrategies.join(', ')}`)
-  }
-
-  const workerConfig = {
-    by,
-    testConfig: options.config,
-    options,
-    selectedRuns: undefined,
-  }
-
-  // If we have specific test UIDs, override the worker test selection
-  if (options.tests && options.tests.length > 0) {
-    workerConfig.by = 'test' // Force test-level distribution for precise targeting
-    output.print(`Using precise test UID targeting for ${options.tests.length} failed tests`)
-  }
-
-  output.print(`CodeceptJS v${require('../codecept').version()}`)
-  output.print(`Re-running ${failedTestsData.tests.length} failed tests in ${output.styles.bold(numberOfWorkers)} workers...`)
-  output.print()
-  store.hasWorkers = true
-
-  const workers = new Workers(numberOfWorkers, workerConfig)
-  workers.overrideConfig(overrideConfigs)
-
-  // Set up event listeners for worker output
-  workers.on('test.failed', test => {
-    output.test.failed(test)
-  })
-
-  workers.on('test.passed', test => {
-    output.test.passed(test)
-  })
-
-  workers.on('test.skipped', test => {
-    output.test.skipped(test)
-  })
-
-  workers.on('all.result', result => {
-    workers.printResults()
-  })
-
-  try {
-    if (options.verbose || options.debug) store.debugMode = true
-
-    if (options.verbose) {
-      output.print('\nFailed tests to re-run with workers:')
-      failedTestsData.tests.forEach((test, index) => {
-        output.print(`  ${index + 1}. ${test.fullTitle || test.title} (${test.file || 'unknown file'})`)
-        if (test.error && test.error.message) {
-          output.print(`     Error: ${test.error.message}`)
-        }
-      })
-      output.print('')
-      
-      const { getMachineInfo } = require('./info')
-      await getMachineInfo()
-    }
-
-    await workers.bootstrapAll()
-    await workers.run()
-  } catch (err) {
-    printError(err)
-    process.exitCode = 1
-  } finally {
-    await workers.teardownAll()
-  }
-}
-
-async function runWithoutWorkers(config, options, testPatterns, failedTestsData, testRoot) {
-  const codecept = new Codecept(config, options)
-
-  try {
-    codecept.init(testRoot)
-    await codecept.bootstrap()
-
-    // Load tests - if we have specific patterns, use them, otherwise load all and filter with grep
-    if (testPatterns.length > 0) {
-      codecept.loadTests(testPatterns.join(' '))
-    } else {
-      codecept.loadTests()
-    }
-
-    // If we have specific test titles, filter the loaded tests to only include those
-    if (options.exactTestTitles && options.exactTestTitles.length > 0) {
-      const Container = require('../container')
-      const mocha = Container.mocha()
-      
-      // Ensure tests are loaded into mocha suite structure
-      mocha.loadFiles()
-      
-      // Filter all tests recursively through the suite hierarchy
-      const filterSuite = (suite) => {
-        // Filter direct tests in this suite
-        suite.tests = suite.tests.filter(test => {
-          return options.exactTestTitles.some(title => title === test.title)
-        })
-        
-        // Recursively filter child suites
-        suite.suites.forEach(childSuite => filterSuite(childSuite))
-        
-        // Remove empty child suites
-        suite.suites = suite.suites.filter(childSuite => 
-          childSuite.tests.length > 0 || childSuite.suites.length > 0
-        )
-      }
-      
-      // Start filtering from the root suite
-      filterSuite(mocha.suite)
-      
-      output.print(`Filtered to ${options.exactTestTitles.length} specific failed tests by exact title matching`)
-    }
-
-    if (options.verbose) {
-      global.debugMode = true
-      const { getMachineInfo } = require('./info')
-      await getMachineInfo()
-    }
-
-    // Display information about what we're running
-    if (options.verbose) {
-      output.print('\nFailed tests to re-run:')
-      failedTestsData.tests.forEach((test, index) => {
-        output.print(`  ${index + 1}. ${test.fullTitle || test.title} (${test.file || 'unknown file'})`)
-        if (test.error && test.error.message) {
-          output.print(`     Error: ${test.error.message}`)
-        }
-      })
-      output.print('')
-    }
-
-    await codecept.run()
-  } catch (err) {
-    printError(err)
-    process.exitCode = 1
-  } finally {
-    await codecept.teardown()
-  }
-}

package/lib/plugin/failedTestsTracker.js

@@ -1,413 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const event = require('../event')
-const output = require('../output')
-const store = require('../store')
-
-const defaultConfig = {
-  enabled: true,
-  outputFile: 'failed-tests.json',
-  clearOnSuccess: true,
-  includeStackTrace: true,
-  includeMetadata: true,
-}
-
-/**
- * Failed Tests Tracker Plugin for CodeceptJS
- *
- * Tracks failed tests and saves them to a file for later re-execution.
- *
- * ## Configuration
- *
- * ```js
- * "plugins": {
- *    "failedTestsTracker": {
- *      "enabled": true,
- *      "outputFile": "failed-tests.json",
- *      "clearOnSuccess": true,
- *      "includeStackTrace": true,
- *      "includeMetadata": true
- *    }
- * }
- * ```
- *
- * @param {object} config plugin configuration
- */
-module.exports = function (config) {
-  const options = { ...defaultConfig, ...config }
-  let failedTests = []
-  let allTestsPassed = true
-  let workerFailedTests = new Map() // Track failed tests from workers
-
-  // Track test failures - only when not using workers
-  event.dispatcher.on(event.test.failed, test => {
-    // Skip collection in worker threads to avoid duplicates
-    try {
-      const { isMainThread } = require('worker_threads')
-      if (!isMainThread) return
-    } catch (e) {
-      // worker_threads not available, continue
-    }
-
-    if (store.hasWorkers) return // Skip if running with workers
-
-    // Only collect on final failure (when retries are exhausted or no retries configured)
-    const currentRetry = test._currentRetry || 0
-    const maxRetries = typeof test.retries === 'function' ? test.retries() : (test.retries || 0)
-    
-    // Only add to failed tests if this is the final attempt
-    if (currentRetry >= maxRetries) {
-      allTestsPassed = false
-
-      const failedTest = {
-        title: test.title,
-        fullTitle: test.fullTitle(),
-        file: test.file || (test.parent && test.parent.file),
-        uid: test.uid,
-        timestamp: new Date().toISOString(),
-      }
-
-      // Add parent suite information
-      if (test.parent) {
-        failedTest.suite = test.parent.title
-        failedTest.suiteFile = test.parent.file
-      }
-
-      // Add error information if available
-      if (test.err && options.includeStackTrace) {
-        failedTest.error = {
-          message: test.err.message || 'Test failed',
-          stack: test.err.stack || '',
-          name: test.err.name || 'Error',
-        }
-      }
-
-      // Add metadata if available
-      if (options.includeMetadata) {
-        failedTest.metadata = {
-          tags: test.tags || [],
-          meta: test.meta || {},
-          opts: test.opts || {},
-          duration: test.duration || 0,
-          // Only include retries if it represents actual retry attempts, not the config value
-          ...(test._currentRetry > 0 && { actualRetries: test._currentRetry }),
-          ...(maxRetries > 0 && maxRetries !== -1 && { maxRetries: maxRetries }),
-        }
-      }
-
-      // Add BDD/Gherkin information if available
-      if (test.parent && test.parent.feature) {
-        failedTest.bdd = {
-          feature: test.parent.feature.name || test.parent.title,
-          scenario: test.title,
-          featureFile: test.parent.file,
-        }
-      }
-
-      failedTests.push(failedTest)
-      output.print(`Failed Tests Tracker: Recorded failed test - ${test.title}`)
-    }
-  })
-
-  // Handle test completion and save failed tests
-  event.dispatcher.on(event.all.result, (result) => {
-    
-    // Respect CodeceptJS output directory like other plugins
-    const outputDir = global.output_dir || './output'
-    const outputPath = path.isAbsolute(options.outputFile)
-      ? options.outputFile
-      : path.resolve(outputDir, options.outputFile)
-    let allFailedTests = [...failedTests]
-
-    // Collect failed tests from result (both worker and single-process modes)
-    if (result) {
-      let resultFailedTests = []
-      
-      // Worker mode: result.tests
-      if (store.hasWorkers && result.tests) {
-        resultFailedTests = result.tests.filter(test => test.state === 'failed' || test.err)
-      }
-      // Single-process mode: result._tests (result._failures contains console log arrays, not test objects)
-      else if (!store.hasWorkers && result._tests) {
-        resultFailedTests = result._tests.filter(test => test.state === 'failed' || test.err)
-      }
-
-      // Use a Set to track unique test identifiers to prevent duplicates
-      const existingTestIds = new Set(allFailedTests.map(test => test.uid || `${test.file}:${test.title}`))
-
-      resultFailedTests.forEach(test => {
-        
-        // Extract file path from test title or error stack trace as fallback
-        let filePath = test.file || test.parent?.file || 'unknown'
-        
-        // If still unknown, try to extract from error stack trace
-        if (filePath === 'unknown' && test.err && test.err.stack) {
-          // Try multiple regex patterns for different stack trace formats
-          const patterns = [
-            /at.*\(([^)]+\.js):\d+:\d+\)/,  // Standard format
-            /at.*\(.*[\/\\]([^\/\\]+\.js):\d+:\d+\)/,  // With path separators
-            /\(([^)]*\.js):\d+:\d+\)/,  // Simpler format
-            /([^\/\\]+\.js):\d+:\d+/,   // Just filename with line numbers
-          ]
-          
-          for (const pattern of patterns) {
-            const stackMatch = test.err.stack.match(pattern)
-            if (stackMatch && stackMatch[1]) {
-              const absolutePath = stackMatch[1]
-              const relativePath = absolutePath.replace(process.cwd() + '/', '').replace(/^.*[\/\\]/, '')
-              filePath = relativePath
-              break
-            }
-          }
-        }
-        
-        // If still unknown, try to extract from test context or use test file pattern
-        if (filePath === 'unknown') {
-          // Look for common test file patterns in the test title or fullTitle
-          const fullTitle = test.fullTitle || test.title
-          if (fullTitle && fullTitle.includes('checkout')) {
-            filePath = 'checkout_test.js'
-          } else if (fullTitle && fullTitle.includes('github')) {
-            filePath = 'github_test.js'
-          }
-        }
-
-        // Create unique identifier for deduplication
-        const testId = test.uid || `${filePath}:${test.title}`
-
-        // Skip if we already have this test
-        if (existingTestIds.has(testId)) {
-          return
-        }
-
-        // Extract proper test properties from different test object structures
-        const testTitle = test.title || test.test?.title || (test.fullTitle && test.fullTitle()) || 'Unknown Test'
-        const testFullTitle = test.fullTitle ? (typeof test.fullTitle === 'function' ? test.fullTitle() : test.fullTitle) : testTitle
-        const testUid = test.uid || test.test?.uid || `${filePath}:${testTitle}`
-
-        const failedTest = {
-          title: testTitle,
-          fullTitle: testFullTitle,
-          file: filePath,
-          uid: testUid,
-          // Add stable identifier for targeting tests across runs
-          stableId: `${filePath}:${testTitle}`,
-          timestamp: new Date().toISOString(),
-        }
-
-        // Add parent suite information
-        if (test.parent) {
-          failedTest.suite = test.parent.title
-          failedTest.suiteFile = test.parent.file
-        }
-
-        // Add error information if available
-        if (test.err && options.includeStackTrace) {
-          failedTest.error = {
-            message: test.err.message || 'Test failed',
-            stack: test.err.stack || '',
-            name: test.err.name || 'Error',
-          }
-        }
-
-        // Add metadata if available
-        if (options.includeMetadata) {
-          failedTest.metadata = {
-            tags: test.tags || [],
-            meta: test.meta || {},
-            opts: test.opts || {},
-            duration: test.duration || 0,
-            retries: test.retries || 0,
-          }
-        }
-
-        // Add BDD/Gherkin information if available
-        if (test.parent && test.parent.feature) {
-          failedTest.bdd = {
-            feature: test.parent.feature.name || test.parent.title,
-            scenario: test.title,
-            featureFile: test.parent.file,
-          }
-        }
-
-        allFailedTests.push(failedTest)
-        existingTestIds.add(testId)
-      })
-
-      output.print(`Failed Tests Tracker: Collected ${resultFailedTests.length} failed tests from result`)
-    }
-
-    if (allFailedTests.length === 0) {
-      if (options.clearOnSuccess && fs.existsSync(outputPath)) {
-        try {
-          fs.unlinkSync(outputPath)
-          output.print(`Failed Tests Tracker: Cleared previous failed tests file (all tests passed)`)
-        } catch (error) {
-          output.print(`Failed Tests Tracker: Could not clear failed tests file: ${error.message}`)
-        }
-      } else {
-        output.print(`Failed Tests Tracker: No failed tests to save`)
-      }
-      return
-    }
-
-    const failedTestsData = {
-      timestamp: new Date().toISOString(),
-      totalFailedTests: allFailedTests.length,
-      codeceptVersion: require('../codecept').version(),
-      tests: allFailedTests,
-    }
-
-    try {
-      // Ensure directory exists
-      const dir = path.dirname(outputPath)
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true })
-      }
-
-      fs.writeFileSync(outputPath, JSON.stringify(failedTestsData, null, 2))
-      output.print(`Failed Tests Tracker: Saved ${allFailedTests.length} failed tests to ${outputPath}`)
-    } catch (error) {
-      output.print(`Failed Tests Tracker: Failed to save failed tests: ${error.message}`)
-    }
-  })
-
-  // Reset state for new test runs
-  event.dispatcher.on(event.all.before, () => {
-    failedTests = []
-    allTestsPassed = true
-    workerFailedTests.clear()
-  })
-
-  // Handle worker mode - listen to workers.result event for consolidated results
-  event.dispatcher.on(event.workers.result, (result) => {
-    // Respect CodeceptJS output directory like other plugins
-    const outputDir = global.output_dir || './output'
-    const outputPath = path.isAbsolute(options.outputFile)
-      ? options.outputFile
-      : path.resolve(outputDir, options.outputFile)
-
-    let allFailedTests = []
-
-    // In worker mode, collect failed tests from consolidated result
-    if (result && result.tests) {
-      const workerFailedTests = result.tests.filter(test => test.state === 'failed' || test.err)
-
-      workerFailedTests.forEach(test => {
-        // Extract file path from test title or error stack trace as fallback
-        let filePath = test.file || test.parent?.file || 'unknown'
-        
-        // If still unknown, try to extract from error stack trace
-        if (filePath === 'unknown' && test.err && test.err.stack) {
-          // Try multiple regex patterns for different stack trace formats
-          const patterns = [
-            /at.*\(([^)]+\.js):\d+:\d+\)/,  // Standard format
-            /at.*\(.*[\/\\]([^\/\\]+\.js):\d+:\d+\)/,  // With path separators
-            /\(([^)]*\.js):\d+:\d+\)/,  // Simpler format
-            /([^\/\\]+\.js):\d+:\d+/,   // Just filename with line numbers
-          ]
-          
-          for (const pattern of patterns) {
-            const stackMatch = test.err.stack.match(pattern)
-            if (stackMatch && stackMatch[1]) {
-              const absolutePath = stackMatch[1]
-              const relativePath = absolutePath.replace(process.cwd() + '/', '').replace(/^.*[\/\\]/, '')
-              filePath = relativePath
-              break
-            }
-          }
-        }
-        
-        // If still unknown, try to extract from test context or use test file pattern
-        if (filePath === 'unknown') {
-          // Look for common test file patterns in the test title or fullTitle
-          const fullTitle = test.fullTitle || test.title
-          if (fullTitle && fullTitle.includes('checkout')) {
-            filePath = 'checkout_test.js'
-          } else if (fullTitle && fullTitle.includes('github')) {
-            filePath = 'github_test.js'
-          }
-        }
-        
-        const failedTest = {
-          title: test.title,
-          fullTitle: test.fullTitle || test.title,
-          file: filePath,
-          uid: test.uid,
-          timestamp: new Date().toISOString(),
-        }
-
-        // Add parent suite information
-        if (test.parent) {
-          failedTest.suite = test.parent.title
-          failedTest.suiteFile = test.parent.file
-        }
-
-        // Add error information if available
-        if (test.err && options.includeStackTrace) {
-          failedTest.error = {
-            message: test.err.message || 'Test failed',
-            stack: test.err.stack || '',
-            name: test.err.name || 'Error',
-          }
-        }
-
-        // Add metadata if available
-        if (options.includeMetadata) {
-          failedTest.metadata = {
-            tags: test.tags || [],
-            meta: test.meta || {},
-            opts: test.opts || {},
-            duration: test.duration || 0,
-            retries: test.retries || 0,
-          }
-        }
-
-        // Add BDD/Gherkin information if available
-        if (test.parent && test.parent.feature) {
-          failedTest.bdd = {
-            feature: test.parent.feature.name || test.parent.title,
-            scenario: test.title,
-            featureFile: test.parent.file,
-          }
-        }
-
-        allFailedTests.push(failedTest)
-      })
-
-      output.print(`Failed Tests Tracker: Collected ${allFailedTests.length - failedTests.length} failed tests from workers`)
-    }
-
-    if (allFailedTests.length === 0) {
-      if (options.clearOnSuccess && fs.existsSync(outputPath)) {
-        try {
-          fs.unlinkSync(outputPath)
-          output.print(`Failed Tests Tracker: Cleared previous failed tests file (all tests passed)`)
-        } catch (error) {
-          output.print(`Failed Tests Tracker: Could not clear failed tests file: ${error.message}`)
-        }
-      }
-      return
-    }
-
-    // Save failed tests to file
-    try {
-      const failedTestsData = {
-        timestamp: new Date().toISOString(),
-        totalFailed: allFailedTests.length,
-        tests: allFailedTests,
-      }
-
-      // Ensure output directory exists
-      const dir = path.dirname(outputPath)
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true })
-      }
-
-      fs.writeFileSync(outputPath, JSON.stringify(failedTestsData, null, 2))
-      output.print(`Failed Tests Tracker: Saved ${allFailedTests.length} failed tests to ${outputPath}`)
-    } catch (error) {
-      output.print(`Failed Tests Tracker: Failed to save failed tests: ${error.message}`)
-    }
-  })
-}