testchimp-runner-core 0.0.86 → 0.0.88

package/dist/execution-service.d.ts

@@ -1,4 +1,4 @@
-import { PlaywrightExecutionRequest, PlaywrightExecutionResponse, ScriptExecutionRequest, ScriptExecutionResponse } from './types';
+import { PlaywrightExecutionRequest, PlaywrightExecutionResponse, ScriptExecutionRequest, ScriptExecutionResponse, TestFileExecutionRequest, TestFileExecutionResponse } from './types';
 import { AuthConfig } from './auth-config';
 import { LLMProvider } from './llm-provider';
 import { ProgressReporter } from './progress-reporter';
@@ -84,12 +84,15 @@ export declare class ExecutionService {
      */
     private initializeBrowser;
     /**
-     * Execute step with command-level tracking
-     * Parses step code into individual commands and executes them one-by-one
-     * Maintains execution context so variables defined in earlier commands/steps are accessible to later ones
-     * Returns successful commands, the failing command, remaining commands, and error
-     * This allows us to preserve successful commands and continue with remaining ones after repair
+     * Execute a test file with hooks support
+     * Parses the test file, extracts hooks and tests, executes them in correct order
+     * Each test is reported separately with its own jobId
      */
-    private executeStepWithTracking;
+    runTestFile(request: TestFileExecutionRequest): Promise<TestFileExecutionResponse>;
+    /**
+     * Execute a hook (beforeAll, afterAll, beforeEach, afterEach)
+     * Uses the same execution context as tests
+     */
+    private executeHook;
 }
 //# sourceMappingURL=execution-service.d.ts.map

package/dist/execution-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execution-service.d.ts","sourceRoot":"","sources":["../src/execution-service.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAE3B,sBAAsB,EACtB,uBAAuB,EAKxB,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAW3C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AA8ZvD;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,MAAM,CAAC,CAA8D;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAkB;IAExC;;OAEG;IACH,aAAa;gBAKX,UAAU,CAAC,EAAE,UAAU,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,uBAAuB,GAAE,MAAW,EACpC,WAAW,CAAC,EAAE,WAAW,EACzB,gBAAgB,CAAC,EAAE,gBAAgB;IA8BrC;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,KAAK,IAAI,GAAG,IAAI;IAKpF;;OAEG;IACH,OAAO,CAAC,GAAG;IAOX,OAAO,CAAC,WAAW;IAanB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAQ3C;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkBtF;;OAEG;YACW,qBAAqB;IAmBnC;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAgCjG;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsC7B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;YACW,+BAA+B;IAiiB7C;;;OAGG;YACW,iBAAiB;YAiGjB,UAAU;YAkLV,eAAe;YAoKf,oBAAoB;YAiBpB,eAAe;IAuC7B,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;YACW,iBAAiB;IAI/B;;;;;;OAMG;YACW,uBAAuB;CAmHtC"}
+{"version":3,"file":"execution-service.d.ts","sourceRoot":"","sources":["../src/execution-service.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAE3B,sBAAsB,EACtB,uBAAuB,EAKvB,wBAAwB,EACxB,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAW3C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AA+ZvD;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,gBAAgB,CAAC,CAAmB;IAC5C,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,uBAAuB,CAAS;IACxC,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,MAAM,CAAC,CAA8D;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,cAAc,CAAkB;IAExC;;OAEG;IACH,aAAa;gBAKX,UAAU,CAAC,EAAE,UAAU,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,uBAAuB,GAAE,MAAW,EACpC,WAAW,CAAC,EAAE,WAAW,EACzB,gBAAgB,CAAC,EAAE,gBAAgB;IA8BrC;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,KAAK,IAAI,GAAG,IAAI;IAKpF;;OAEG;IACH,OAAO,CAAC,GAAG;IAOX,OAAO,CAAC,WAAW;IAanB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAQ3C;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAkBtF;;OAEG;YACW,qBAAqB;IAmBnC;;OAEG;IACG,gBAAgB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAgCjG;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsC7B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;YACW,+BAA+B;IA2iB7C;;;OAGG;YACW,iBAAiB;YAiGjB,UAAU;YAkLV,eAAe;YAoKf,oBAAoB;YAiBpB,eAAe;IAuC7B,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;YACW,iBAAiB;IAI/B;;;;OAIG;IACG,WAAW,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAgaxF;;;OAGG;YACW,WAAW;CAuB1B"}

package/dist/execution-service.js

@@ -36,6 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionService = void 0;
 const vm = __importStar(require("vm"));
 const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
 const async_hooks_1 = require("async_hooks");
 const playwright_mcp_service_1 = require("./playwright-mcp-service");
 const types_1 = require("./types");
@@ -48,11 +50,11 @@ const playwright_runner_1 = require("./utils/playwright-runner");
 const import_utils_1 = require("./utils/import-utils");
 const initialization_code_utils_1 = require("./utils/initialization-code-utils");
 const script_parser_utils_1 = require("./utils/script-parser-utils");
-const step_execution_utils_1 = require("./utils/step-execution-utils");
 const script_generator_utils_1 = require("./utils/script-generator-utils");
 const backend_proxy_llm_provider_1 = require("./providers/backend-proxy-llm-provider");
 const build_info_1 = require("./build-info");
 const orchestrator_1 = require("./orchestrator");
+const test_file_parser_1 = require("./utils/test-file-parser");
 class ModuleResolutionManager {
     /**
      * Install the global hook (only once, shared by all instances)
@@ -889,7 +891,8 @@ class ExecutionService {
                     code: step.code,
                     isVariableDeclaration,
                     intentComment: step.description !== step.code ? step.description : undefined,
-                    screenStateAnnotation: undefined // Will be in description for pre-parsed steps
+                    screenStateAnnotation: undefined, // Will be in description for pre-parsed steps
+                    stepId: step.id // Preserve block index ID (e.g., "0", "1", "2")
                 };
             });
         }
@@ -934,8 +937,9 @@ class ExecutionService {
                 // LIFECYCLE: beforeStepStart (call before execution)
                 if (this.progressReporter?.beforeStepStart && options.jobId) {
                     const description = stmt.intentComment || ''; // Don't use code as fallback
+                    const stepId = stmt.stepId || `step-${stepNumber}`; // Use preserved ID, fallback to sequential
                     await this.progressReporter.beforeStepStart({
-                        stepId: `step-${stepNumber}`,
+                        stepId,
                         stepNumber,
                         description,
                         code: stmt.code
@@ -948,13 +952,14 @@ class ExecutionService {
                 // Only report non-variable statements as steps
                 if (!isVariable) {
                     const description = stmt.intentComment || ''; // Don't use code as fallback
+                    const stepId = stmt.stepId || `step-${stepNumber}`; // Use preserved ID, fallback to sequential
                     this.log(`  ✓ Step ${stepNumber} succeeded: ${description || stmt.code}`);
                     executedStepDescriptions.push(description);
                     // LIFECYCLE: onStepProgress (success)
                     if (this.progressReporter?.onStepProgress && options.jobId) {
                         await this.progressReporter.onStepProgress({
                             jobId: options.jobId,
-                            stepId: `step-${stepNumber}`,
+                            stepId,
                             stepNumber,
                             description,
                             code: stmt.code,
@@ -974,12 +979,13 @@ class ExecutionService {
                 if (!isVariable) {
                     // stepNumber already incremented in beforeStepStart
                     const description = stmt.intentComment || ''; // Don't use code as fallback
+                    const stepId = stmt.stepId || `step-${stepNumber}`; // Use preserved ID, fallback to sequential
                     this.log(`  ✗ Step ${stepNumber} failed: ${errorMsg}`);
                     // LIFECYCLE: onStepProgress (failure)
                     if (this.progressReporter?.onStepProgress && options.jobId) {
                         await this.progressReporter.onStepProgress({
                             jobId: options.jobId,
-                            stepId: `step-${stepNumber}`,
+                            stepId,
                             stepNumber,
                             description,
                             code: stmt.code,
@@ -1003,20 +1009,25 @@ class ExecutionService {
                     // RUN_WITH_AI_REPAIR: Attempt repair (only for non-variable statements)
                     if (!isVariable) {
                         // Convert statement to step format for repair
+                        const stepId = stmt.stepId || `step-${stepNumber}`;
                         const stepForRepair = {
-                            id: `step-${stepNumber}`,
+                            id: stepId,
                             description: stmt.intentComment || '', // Don't use code as fallback
                             code: stmt.code
                         };
                         // Create temporary steps array for repair context
                         const stepsForRepair = allStatements
                             .filter(s => !s.isVariableDeclaration)
-                            .map((s, idx) => ({
-                            id: `step-${idx + 1}`,
-                            description: s.intentComment || '', // Don't use code as fallback
-                            code: s.code,
-                            success: idx < stepNumber - 1 // Previous steps succeeded
-                        }));
+                            .map((s, idx) => {
+                            // Find original index in allStatements to get correct stepId
+                            const originalIndex = allStatements.indexOf(s);
+                            return {
+                                id: s.stepId || `step-${idx + 1}`, // Use preserved block index ID
+                                description: s.intentComment || '', // Don't use code as fallback
+                                code: s.code,
+                                success: originalIndex < i // Previous steps succeeded (use original index)
+                            };
+                        });
                         const repairResult = await this.attemptStepRepair(stepNumber - 1, // 0-based index
                         stepForRepair, stepsForRepair, executedStepDescriptions, page, persistentContext, options.jobId || '', options.model || model_constants_1.DEFAULT_MODEL);
                         if (repairResult.success) {
@@ -1462,108 +1473,396 @@ class ExecutionService {
         return (0, browser_utils_1.initializeBrowser)(playwrightConfig, headless, playwrightConfigFilePath, this.logger);
     }
     /**
-     * Execute step with command-level tracking
-     * Parses step code into individual commands and executes them one-by-one
-     * Maintains execution context so variables defined in earlier commands/steps are accessible to later ones
-     * Returns successful commands, the failing command, remaining commands, and error
-     * This allows us to preserve successful commands and continue with remaining ones after repair
+     * Execute a test file with hooks support
+     * Parses the test file, extracts hooks and tests, executes them in correct order
+     * Each test is reported separately with its own jobId
      */
-    async executeStepWithTracking(stepCode, page, priorStepsContext = '') {
-        const successfulCommands = [];
-        let failingCommand;
-        let remainingCommands = [];
-        let error;
-        // Parse step code into individual statements (handles multi-line await blocks)
-        const statements = step_execution_utils_1.StepExecutionUtils.splitIntoExecutableStatements(stepCode);
-        // Separate variable declarations and Playwright commands
-        const declarations = []; // const/let/var declarations
-        const commands = []; // executable statements (await/page/expect/ai/control flow)
-        for (const statement of statements) {
-            const trimmed = statement.trim();
-            if (trimmed.length === 0) {
-                continue;
-            }
-            // Skip comment-only statements
-            const withoutComments = trimmed.replace(/^\s*\/\/.*$/gm, '').trim();
-            if (withoutComments.length === 0) {
-                continue;
-            }
-            const isDeclaration = /^(const|let|var)\b/.test(trimmed) && !/\bawait\b/.test(trimmed);
-            const isExecutable = /\bawait\b/.test(statement) ||
-                /\bpage\./.test(statement) ||
-                /\bexpect\(/.test(statement) ||
-                /\bai\./.test(statement) ||
-                /^(if|for|while|switch|try|do)\b/.test(trimmed);
-            if (isDeclaration) {
-                declarations.push(statement);
+    async runTestFile(request) {
+        const startTime = Date.now();
+        const testResults = [];
+        try {
+            // Read script content if scriptFilePath is provided
+            let script;
+            if (request.script) {
+                script = request.script;
             }
-            else if (isExecutable) {
-                commands.push(statement);
+            else if (request.scriptFilePath) {
+                try {
+                    script = fs.readFileSync(request.scriptFilePath, 'utf8');
+                    this.log(`Read test file from: ${request.scriptFilePath}`);
+                }
+                catch (error) {
+                    throw new Error(`Failed to read test file: ${error instanceof Error ? error.message : String(error)}`);
+                }
             }
             else {
-                // Default to executing the statement to preserve behaviour
-                commands.push(statement);
+                throw new Error('Either script or scriptFilePath must be provided');
             }
-        }
-        if (commands.length === 0 && declarations.length === 0) {
-            // No parseable commands - try to execute whole code as-is with prior context
-            try {
-                const fullCode = priorStepsContext ? priorStepsContext + '\n' + stepCode : stepCode;
-                await this.executeStepCode(fullCode, page);
-                return { successfulCommands: [stepCode], failingCommand: undefined, remainingCommands: [], error: undefined };
+            // Validate tempDir is provided
+            if (!request.tempDir) {
+                throw new Error('tempDir is required for test file execution');
             }
-            catch (err) {
+            // Auto-discover playwright.config.js if not provided
+            let playwrightConfig = request.playwrightConfig;
+            let playwrightConfigFilePath = request.playwrightConfigFilePath;
+            if (!playwrightConfig && !playwrightConfigFilePath) {
+                const configExtensions = ['.js', '.ts', '.mjs'];
+                for (const ext of configExtensions) {
+                    const configPath = path.join(request.tempDir, `playwright.config${ext}`);
+                    if (fs.existsSync(configPath)) {
+                        playwrightConfigFilePath = configPath;
+                        this.log(`Auto-discovered Playwright config: ${configPath}`);
+                        break;
+                    }
+                }
+            }
+            // Extract imports from the original script once (they'll be needed for hooks and tests)
+            // Store the full original script for passing to test executions
+            const originalScript = script;
+            // Parse test file to extract hooks and tests
+            this.log('Parsing test file to extract hooks and tests...');
+            const parsed = test_file_parser_1.TestFileParser.parseTestFile(script, request.testNames);
+            // Flatten structure for execution
+            const flattened = test_file_parser_1.TestFileParser.flattenForExecution(parsed);
+            this.log(`Found ${flattened.fileLevelHooks.beforeAll.length} file-level beforeAll hooks, ${flattened.fileLevelHooks.afterAll.length} file-level afterAll hooks`);
+            this.log(`Found ${flattened.fileLevelHooks.beforeEach.length} file-level beforeEach hooks, ${flattened.fileLevelHooks.afterEach.length} file-level afterEach hooks`);
+            this.log(`Found ${flattened.suites.length} suite(s) with suite-level hooks`);
+            this.log(`Found ${flattened.tests.length} test(s)`);
+            if (flattened.tests.length === 0) {
+                this.log('No tests found in file', 'warn');
                 return {
-                    successfulCommands: [],
-                    failingCommand: stepCode,
-                    remainingCommands: [],
-                    error: step_execution_utils_1.StepExecutionUtils.safeSerializeError(err)
+                    success: true,
+                    testResults: [],
+                    executionTime: Date.now() - startTime
                 };
             }
-        }
-        // Build accumulated context: start with prior steps context, then add current declarations
-        const accumulatedContext = [];
-        if (priorStepsContext) {
-            accumulatedContext.push(priorStepsContext);
-        }
-        accumulatedContext.push(...declarations);
-        successfulCommands.push(...declarations); // Declarations are part of successful commands
-        // Execute commands one by one, maintaining variable context only
-        // We accumulate executed commands separately to avoid re-executing them
-        const executedCommands = [];
-        for (let cmdIdx = 0; cmdIdx < commands.length; cmdIdx++) {
-            const cmd = commands[cmdIdx];
-            try {
-                // Execute ONLY this command (not re-executing prior ones)
-                // Include accumulated context for variable access only
-                const codeToExecute = accumulatedContext.length > 0
-                    ? [...accumulatedContext, cmd].join('\n')
-                    : cmd;
-                await this.executeStepCode(codeToExecute, page);
-                // Success - track the command
-                executedCommands.push(cmd);
-                successfulCommands.push(cmd);
-                // Only add declarations to accumulated context (not action commands)
-                if (cmd.startsWith('const ') || cmd.startsWith('let ') || cmd.startsWith('var ')) {
-                    accumulatedContext.push(cmd);
+            // Initialize browser/context/page (shared across all hooks and tests)
+            const useExistingBrowser = !!(request.existingBrowser && request.existingContext && request.existingPage);
+            let browser;
+            let context;
+            let page;
+            let browserCreated = false;
+            if (useExistingBrowser) {
+                this.log('Using existing browser/page provided by caller');
+                browser = request.existingBrowser;
+                context = request.existingContext;
+                page = request.existingPage;
+            }
+            else {
+                this.log('Initializing browser for test file execution...');
+                const browserInstance = await this.initializeBrowser(playwrightConfig, request.headless !== false, playwrightConfigFilePath);
+                browser = browserInstance.browser;
+                context = browserInstance.context;
+                page = browserInstance.page;
+                browserCreated = true;
+            }
+            // Apply file upload overrides if tempDir is provided
+            if (request.tempDir) {
+                applyFileUploadOverrides(page, request.tempDir, request.testFolderPath, (msg, level) => this.log(msg, level));
+                this.log(`Applied file upload overrides with tempDir: ${request.tempDir}`);
+            }
+            // Execute file-level beforeAll hooks
+            if (flattened.fileLevelHooks.beforeAll.length > 0) {
+                this.log(`Executing ${flattened.fileLevelHooks.beforeAll.length} file-level beforeAll hook(s)...`);
+                try {
+                    for (const hook of flattened.fileLevelHooks.beforeAll) {
+                        await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                    }
+                    this.log('File-level beforeAll hooks executed successfully');
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    this.log(`File-level beforeAll hook failed: ${errorMsg}`, 'error');
+                    // Cleanup browser if we created it
+                    if (browserCreated && browser) {
+                        try {
+                            await browser.close();
+                        }
+                        catch (closeError) {
+                            // Ignore close errors
+                        }
+                    }
+                    return {
+                        success: false,
+                        testResults: [],
+                        executionTime: Date.now() - startTime,
+                        error: `File-level beforeAll hook failed: ${errorMsg}`
+                    };
                 }
-                this.log(`    ✓ Command succeeded: ${cmd.substring(0, 60)}...`);
             }
-            catch (err) {
-                // This command failed - it's the failing one
-                failingCommand = cmd;
-                error = step_execution_utils_1.StepExecutionUtils.safeSerializeError(err);
-                // Capture remaining commands that were not executed
-                remainingCommands = commands.slice(cmdIdx + 1);
-                this.log(`    ✗ Command failed: ${cmd.substring(0, 60)}...`);
-                this.log(`       Error: ${error}`);
-                if (remainingCommands.length > 0) {
-                    this.log(`    ⏭  ${remainingCommands.length} remaining commands not executed`);
+            // Helper function to create a unique key from suite path (avoids collisions if suite names contain '__')
+            const getSuiteKey = (suitePath) => {
+                // Use JSON.stringify to safely serialize the array, avoiding collisions
+                return JSON.stringify(suitePath);
+            };
+            // Build a Map of suites by key for O(1) lookups (instead of O(n) .find() calls)
+            const suiteMap = new Map();
+            for (const suite of flattened.suites) {
+                const suiteKey = getSuiteKey(suite.suitePath);
+                suiteMap.set(suiteKey, suite);
+            }
+            // Track suite execution state (which suites have had beforeAll executed)
+            const suiteBeforeAllExecuted = new Set();
+            // Track test counts per suite (for determining last test in suite)
+            const suiteTestCounts = new Map();
+            const suiteTotalTests = new Map();
+            // Initialize suite test counts
+            for (const suite of flattened.suites) {
+                const suiteKey = getSuiteKey(suite.suitePath);
+                suiteTotalTests.set(suiteKey, suite.testIndices.length);
+                suiteTestCounts.set(suiteKey, 0);
+            }
+            // Execute each test
+            for (let testIndex = 0; testIndex < flattened.tests.length; testIndex++) {
+                const testData = flattened.tests[testIndex];
+                const test = testData.test;
+                const testStartTime = Date.now();
+                const jobId = crypto.randomUUID();
+                let testStatus = 'passed';
+                let testError;
+                try {
+                    // Before test execution: Execute suite-level beforeAll hooks (if first test in suite)
+                    if (testData.suitePath.length > 0) {
+                        // Execute beforeAll for each suite in the path (in order: parent → child)
+                        for (let i = 0; i < testData.suitePath.length; i++) {
+                            const suitePath = testData.suitePath.slice(0, i + 1);
+                            const suiteKey = getSuiteKey(suitePath);
+                            // Look up suite in Map (O(1) instead of O(n) .find())
+                            const suite = suiteMap.get(suiteKey);
+                            if (suite && suite.beforeAll.length > 0 && !suiteBeforeAllExecuted.has(suiteKey)) {
+                                // Use human-readable suite name for logging
+                                const suiteDisplayName = suitePath.join('__');
+                                this.log(`Executing suite-level beforeAll hooks for suite: ${suiteDisplayName}`);
+                                try {
+                                    for (const hook of suite.beforeAll) {
+                                        await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                                    }
+                                    suiteBeforeAllExecuted.add(suiteKey);
+                                    this.log(`Suite-level beforeAll hooks executed for suite: ${suiteDisplayName}`);
+                                }
+                                catch (error) {
+                                    const errorMsg = error instanceof Error ? error.message : String(error);
+                                    this.log(`Suite-level beforeAll hook failed for suite ${suiteDisplayName}: ${errorMsg}`, 'error');
+                                    testStatus = 'failed';
+                                    testError = `Suite-level beforeAll hook failed: ${errorMsg}`;
+                                }
+                            }
+                        }
+                    }
+                    // Call onStartTest callback (use fullName)
+                    if (this.progressReporter?.onStartTest) {
+                        await this.progressReporter.onStartTest(test.fullName, jobId, page, browser, context);
+                    }
+                    // Execute file-level beforeEach hooks
+                    if (flattened.fileLevelHooks.beforeEach.length > 0 && testStatus === 'passed') {
+                        this.log(`Executing ${flattened.fileLevelHooks.beforeEach.length} file-level beforeEach hook(s) for test: ${test.fullName}`);
+                        try {
+                            for (const hook of flattened.fileLevelHooks.beforeEach) {
+                                await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.log(`File-level beforeEach hook failed for test ${test.fullName}: ${errorMsg}`, 'error');
+                            testStatus = 'failed';
+                            testError = `File-level beforeEach hook failed: ${errorMsg}`;
+                        }
+                    }
+                    // Execute suite-level beforeEach hooks (from all parent suites, in order: parent → child)
+                    if (testData.suiteBeforeEachHooks.length > 0 && testStatus === 'passed') {
+                        this.log(`Executing ${testData.suiteBeforeEachHooks.length} suite-level beforeEach hook(s) for test: ${test.fullName}`);
+                        try {
+                            for (const hook of testData.suiteBeforeEachHooks) {
+                                await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.log(`Suite-level beforeEach hook failed for test ${test.fullName}: ${errorMsg}`, 'error');
+                            testStatus = 'failed';
+                            testError = `Suite-level beforeEach hook failed: ${errorMsg}`;
+                        }
+                    }
+                    // Run the test if hooks didn't fail
+                    if (testStatus === 'passed') {
+                        try {
+                            // Execute test using existing infrastructure
+                            // Construct a script with imports + this test using AST (more robust than string interpolation)
+                            const testScript = test_file_parser_1.TestFileParser.constructTestScriptWithImports(originalScript, test.fullName, // Use fullName for test execution
+                            test.code);
+                            const result = await this.executeStepsInPersistentContext([], // No pre-parsed steps - AST will extract from test body
+                            page, browser, context, {
+                                mode: request.mode || types_1.ExecutionMode.RUN_EXACTLY,
+                                jobId: jobId,
+                                tempDir: request.tempDir,
+                                originalScript: testScript // Full script with imports + test
+                            });
+                            if (!result.success) {
+                                testStatus = 'failed';
+                                testError = result.error || 'Test execution failed';
+                            }
+                        }
+                        catch (error) {
+                            testStatus = 'failed';
+                            testError = error instanceof Error ? error.message : String(error);
+                        }
+                    }
+                    // Execute suite-level afterEach hooks (from all parent suites, in reverse order: child → parent)
+                    if (testData.suiteAfterEachHooks.length > 0) {
+                        this.log(`Executing ${testData.suiteAfterEachHooks.length} suite-level afterEach hook(s) for test: ${test.fullName}`);
+                        try {
+                            for (const hook of testData.suiteAfterEachHooks) {
+                                await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.log(`Suite-level afterEach hook failed for test ${test.fullName}: ${errorMsg}`, 'warn');
+                            // Log but continue - don't fail the test because of afterEach failure
+                        }
+                    }
+                    // Execute file-level afterEach hooks (even if test failed)
+                    if (flattened.fileLevelHooks.afterEach.length > 0) {
+                        this.log(`Executing ${flattened.fileLevelHooks.afterEach.length} file-level afterEach hook(s) for test: ${test.fullName}`);
+                        try {
+                            for (const hook of flattened.fileLevelHooks.afterEach) {
+                                await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                            }
+                        }
+                        catch (error) {
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.log(`File-level afterEach hook failed for test ${test.fullName}: ${errorMsg}`, 'warn');
+                            // Log but continue - don't fail the test because of afterEach failure
+                        }
+                    }
+                    // After test execution: Increment test counts and execute suite-level afterAll hooks (if last test in suite)
+                    if (testData.suitePath.length > 0) {
+                        // Increment test count for each suite in the path
+                        for (let i = 0; i < testData.suitePath.length; i++) {
+                            const suitePath = testData.suitePath.slice(0, i + 1);
+                            const suiteKey = getSuiteKey(suitePath);
+                            const currentCount = suiteTestCounts.get(suiteKey) || 0;
+                            suiteTestCounts.set(suiteKey, currentCount + 1);
+                        }
+                        // Execute afterAll for each suite in the path (in reverse order: child → parent)
+                        for (let i = testData.suitePath.length - 1; i >= 0; i--) {
+                            const suitePath = testData.suitePath.slice(0, i + 1);
+                            const suiteKey = getSuiteKey(suitePath);
+                            // Look up suite in Map (O(1) instead of O(n) .find())
+                            const suite = suiteMap.get(suiteKey);
+                            if (suite && suite.afterAll.length > 0) {
+                                const totalTests = suiteTotalTests.get(suiteKey) || 0;
+                                const currentCount = suiteTestCounts.get(suiteKey) || 0;
+                                // If this is the last test in the suite, execute afterAll
+                                if (currentCount >= totalTests) {
+                                    // Use human-readable suite name for logging
+                                    const suiteDisplayName = suitePath.join('__');
+                                    this.log(`Executing suite-level afterAll hooks for suite: ${suiteDisplayName}`);
+                                    try {
+                                        for (const hook of suite.afterAll) {
+                                            await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                                        }
+                                        this.log(`Suite-level afterAll hooks executed for suite: ${suiteDisplayName}`);
+                                    }
+                                    catch (error) {
+                                        const errorMsg = error instanceof Error ? error.message : String(error);
+                                        this.log(`Suite-level afterAll hook failed for suite ${suiteDisplayName}: ${errorMsg}`, 'warn');
+                                        // Log but continue - don't fail the test because of afterAll failure
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Call onEndTest callback (use fullName)
+                    if (this.progressReporter?.onEndTest) {
+                        await this.progressReporter.onEndTest(test.fullName, jobId, testStatus, testError, page, browser, context);
+                    }
+                }
+                catch (error) {
+                    // Unexpected error during test execution
+                    testStatus = 'failed';
+                    testError = error instanceof Error ? error.message : String(error);
+                    this.log(`Unexpected error during test ${test.name}: ${testError}`, 'error');
+                    // Still call onEndTest if possible
+                    if (this.progressReporter?.onEndTest) {
+                        try {
+                            await this.progressReporter.onEndTest(test.fullName, jobId, testStatus, testError, page, browser, context);
+                        }
+                        catch (callbackError) {
+                            this.log(`onEndTest callback failed: ${callbackError}`, 'warn');
+                        }
+                    }
+                }
+                // Record test result (use fullName)
+                testResults.push({
+                    testName: test.fullName,
+                    jobId: jobId,
+                    status: testStatus,
+                    error: testError,
+                    executionTime: Date.now() - testStartTime
+                });
+                this.log(`Test ${test.fullName} completed with status: ${testStatus}`);
+            }
+            // Execute file-level afterAll hooks
+            if (flattened.fileLevelHooks.afterAll.length > 0) {
+                this.log(`Executing ${flattened.fileLevelHooks.afterAll.length} file-level afterAll hook(s)...`);
+                try {
+                    for (const hook of flattened.fileLevelHooks.afterAll) {
+                        await this.executeHook(hook.code, page, context, browser, request.tempDir);
+                    }
+                    this.log('File-level afterAll hooks executed successfully');
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    this.log(`File-level afterAll hook failed: ${errorMsg}`, 'warn');
+                    // Log but don't fail overall execution
                 }
-                break; // Stop at first failure
             }
+            // Cleanup browser if we created it
+            if (browserCreated && browser) {
+                try {
+                    await browser.close();
+                    this.log('Browser closed');
+                }
+                catch (closeError) {
+                    this.log(`Error closing browser: ${closeError}`, 'warn');
+                }
+            }
+            // Determine overall success (all tests passed)
+            const allPassed = testResults.every(result => result.status === 'passed');
+            return {
+                success: allPassed,
+                testResults: testResults,
+                executionTime: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.log(`Test file execution failed: ${errorMsg}`, 'error');
+            return {
+                success: false,
+                testResults: testResults,
+                executionTime: Date.now() - startTime,
+                error: errorMsg
+            };
+        }
+    }
+    /**
+     * Execute a hook (beforeAll, afterAll, beforeEach, afterEach)
+     * Uses the same execution context as tests
+     */
+    async executeHook(hookCode, page, context, browser, tempDir) {
+        const { expect, test } = require('@playwright/test');
+        const { ai } = require('ai-wright');
+        // Create execution context for the hook
+        const hookContext = new PersistentExecutionContext(page, expect, test, ai, browser, context, tempDir);
+        try {
+            // Execute hook code
+            await hookContext.executeCode(hookCode);
+        }
+        finally {
+            hookContext.dispose();
         }
-        return { successfulCommands, failingCommand, remainingCommands, error };
     }
 }
 exports.ExecutionService = ExecutionService;