testchimp-runner-core 0.0.75 → 0.0.77

package/dist/execution-service.js

@@ -36,28 +36,184 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionService = void 0;
 const vm = __importStar(require("vm"));
 const path = __importStar(require("path"));
+const async_hooks_1 = require("async_hooks");
 const playwright_mcp_service_1 = require("./playwright-mcp-service");
 const types_1 = require("./types");
 const browser_utils_1 = require("./utils/browser-utils");
 const llm_facade_1 = require("./llm-facade");
-const script_utils_1 = require("./script-utils");
 const credit_usage_service_1 = require("./credit-usage-service");
 const model_constants_1 = require("./model-constants");
 const ai_command_utils_1 = require("./utils/ai-command-utils");
 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");
+class ModuleResolutionManager {
+    /**
+     * Install the global hook (only once, shared by all instances)
+     */
+    static installHook() {
+        if (this.hookInstalled) {
+            return; // Already installed
+        }
+        const Module = require('module');
+        const path = require('path');
+        const fs = require('fs');
+        this.originalResolveFilename = Module._resolveFilename;
+        // Cache scriptservice node_modules path from execution-service.js location
+        // execution-service.js is at: .../scriptservice/node_modules/testchimp-runner-core/dist/execution-service.js
+        // Go up 2 levels to get to scriptservice/node_modules
+        try {
+            const executionServicePath = __filename; // This file's path
+            const distDir = path.dirname(executionServicePath);
+            const runnerCoreDir = path.dirname(distDir);
+            const nodeModulesDir = path.dirname(runnerCoreDir);
+            if (fs.existsSync(nodeModulesDir) && path.basename(nodeModulesDir) === 'node_modules') {
+                this.scriptserviceNodeModules = nodeModulesDir;
+                console.log(`[ModuleResolution] Cached scriptservice node_modules: ${this.scriptserviceNodeModules}`);
+            }
+        }
+        catch (e) {
+            // Ignore errors
+        }
+        // Install hook that uses AsyncLocalStorage to get the current tempDir and testFileDir
+        Module._resolveFilename = function (request, parent, isMain, options) {
+            // Get resolution context for current execution
+            const context = ModuleResolutionManager.asyncLocalStorage.getStore();
+            // If no context, use original resolution (for requires outside our execution context)
+            if (!context) {
+                return ModuleResolutionManager.originalResolveFilename.call(this, request, parent, isMain, options);
+            }
+            // Log all module resolution attempts when we have context
+            console.log(`[ModuleResolution] Hook intercepted: "${request}" (parent: ${parent?.filename || 'none'})`);
+            // Handle relative imports
+            if (request.startsWith('.')) {
+                // Use standard Node.js relative path resolution
+                // The folder structure is exactly as specified in the DB (folderPath)
+                // Resolve relative to testFileDir (the directory where the test file is located)
+                const resolveDir = context.testFileDir || (parent?.filename ? path.dirname(parent.filename) : context.tempDir);
+                // Log module resolution attempt
+                console.log(`[ModuleResolution] Resolving relative import: "${request}"`);
+                console.log(`[ModuleResolution]   resolveDir: ${resolveDir}`);
+                // Resolve the relative path using standard Node.js resolution
+                // This will correctly resolve based on the actual folder structure in tempDir
+                const resolvedPath = path.resolve(resolveDir, request);
+                console.log(`[ModuleResolution]   resolvedPath: ${resolvedPath}`);
+                // Try extensions in order: .page.ts, .page.js (POM files)
+                const extensions = ['.page.ts', '.page.js'];
+                for (const ext of extensions) {
+                    const testPath = resolvedPath + ext;
+                    try {
+                        if (fs.existsSync(testPath)) {
+                            console.log(`[ModuleResolution]   ✓ Found file: ${testPath}`);
+                            return testPath;
+                        }
+                        else {
+                            console.log(`[ModuleResolution]   ✗ File does not exist: ${testPath}`);
+                        }
+                    }
+                    catch (e) {
+                        console.log(`[ModuleResolution]   ✗ Error checking file: ${testPath} - ${e}`);
+                    }
+                }
+                // If no extension worked, try original resolution
+                try {
+                    return ModuleResolutionManager.originalResolveFilename.call(this, request, parent, isMain, options);
+                }
+                catch (err) {
+                    // If that fails, try resolving as directory with index file
+                    for (const ext of extensions) {
+                        const indexPath = path.join(resolvedPath, 'index' + ext);
+                        try {
+                            if (fs.existsSync(indexPath)) {
+                                return indexPath;
+                            }
+                        }
+                        catch (e) {
+                            // Continue
+                        }
+                    }
+                    throw err;
+                }
+            }
+            // For non-relative imports (like 'ai-wright', '@playwright/test'), use standard Node.js resolution
+            // These should resolve from node_modules where runner-core is installed (scriptservice's node_modules)
+            console.log(`[ModuleResolution] Resolving non-relative import: "${request}"`);
+            try {
+                // Use original Node.js resolution (will find from node_modules)
+                const resolved = ModuleResolutionManager.originalResolveFilename.call(this, request, parent, isMain, options);
+                console.log(`[ModuleResolution]   ✓ Resolved to: ${resolved}`);
+                return resolved;
+            }
+            catch (err) {
+                console.log(`[ModuleResolution]   ✗ Failed to resolve: ${err.message}`);
+                // Build enhanced paths that include scriptservice's node_modules
+                // Find node_modules by looking up from the execution-service.js location
+                const enhancedPaths = [...(options?.paths || [])];
+                // Add tempDir paths
+                if (context.tempDir) {
+                    enhancedPaths.push(context.tempDir);
+                    enhancedPaths.push(path.join(context.tempDir, 'node_modules'));
+                }
+                // Add scriptservice's node_modules (where runner-core is installed)
+                // Use the cached path from execution-service.js location
+                if (ModuleResolutionManager.scriptserviceNodeModules) {
+                    enhancedPaths.push(ModuleResolutionManager.scriptserviceNodeModules);
+                    console.log(`[ModuleResolution]   Added scriptservice node_modules to paths: ${ModuleResolutionManager.scriptserviceNodeModules}`);
+                }
+                // Try with enhanced paths
+                try {
+                    const enhancedOptions = {
+                        ...options,
+                        paths: enhancedPaths
+                    };
+                    const resolved = ModuleResolutionManager.originalResolveFilename.call(this, request, parent, isMain, enhancedOptions);
+                    console.log(`[ModuleResolution]   ✓ Resolved (with enhanced paths): ${resolved}`);
+                    return resolved;
+                }
+                catch (resolveErr) {
+                    console.log(`[ModuleResolution]   ✗ Failed with enhanced paths: ${resolveErr}`);
+                    // Fall back to original error
+                    throw err;
+                }
+            }
+        };
+        this.hookInstalled = true;
+    }
+    /**
+     * Run code in an isolated context with a specific tempDir
+     */
+    static runWithTempDir(tempDir, fn) {
+        return this.asyncLocalStorage.run({ tempDir }, fn);
+    }
+    static runWithContext(context, fn) {
+        return this.asyncLocalStorage.run(context, fn);
+    }
+}
+ModuleResolutionManager.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+ModuleResolutionManager.hookInstalled = false;
+ModuleResolutionManager.scriptserviceNodeModules = null;
 /**
  * Persistent execution context using vm.createContext
  * Maintains variable scope across multiple step executions
  * Variables defined in earlier steps remain available in later steps without re-evaluation
  */
 class PersistentExecutionContext {
-    constructor(page, expect, test, ai, browser, browserContext) {
+    constructor(page, expect, test, ai, browser, browserContext, tempDir) {
+        this.tempDir = tempDir;
+        // Install global hook if not already installed (only happens once)
+        if (tempDir) {
+            ModuleResolutionManager.installHook();
+            this.setupTypeScriptSupport(tempDir);
+        }
         // Create V8 context with Playwright globals
         // ai-wright will handle timeout extension internally (test.setTimeout or page.setDefaultTimeout)
-        this.context = vm.createContext({
+        const contextGlobals = {
             // Playwright objects
             page,
             expect,
@@ -67,15 +223,15 @@ class PersistentExecutionContext {
             context: browserContext,
             // Node.js globals
             console,
-            require,
+            require, // Normal require - hook will intercept resolution
             setTimeout,
             setInterval,
             clearTimeout,
             clearInterval,
             Buffer,
             process,
-            __dirname,
-            __filename,
+            __dirname: tempDir || __dirname,
+            __filename: tempDir ? path.join(tempDir, 'script.ts') : __filename,
             // JavaScript built-ins
             Math,
             Date,
@@ -91,20 +247,87 @@ class PersistentExecutionContext {
             Map,
             WeakSet,
             WeakMap,
-        });
+            globalThis: undefined, // Will be set after context creation
+        };
+        this.context = vm.createContext(contextGlobals);
+        // Set globalThis to point to the context object itself
+        // This allows assignments like globalThis.varName = value to work
+        contextGlobals.globalThis = this.context;
+    }
+    /**
+     * Set up TypeScript support by generating tsconfig.json and registering ts-node
+     */
+    setupTypeScriptSupport(tempDir) {
+        const path = require('path');
+        const fs = require('fs');
+        // Generate minimal tsconfig.json if it doesn't exist
+        const tsconfigPath = path.join(tempDir, 'tsconfig.json');
+        if (!fs.existsSync(tsconfigPath)) {
+            const tsconfig = {
+                compilerOptions: {
+                    target: 'ES2020',
+                    module: 'commonjs',
+                    esModuleInterop: true,
+                    skipLibCheck: true,
+                    allowJs: true,
+                    resolveJsonModule: true,
+                    moduleResolution: 'node'
+                },
+                include: ['**/*.ts', '**/*.js'],
+                exclude: ['node_modules']
+            };
+            try {
+                fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+            }
+            catch (e) {
+                // If we can't write tsconfig, continue without it
+                // ts-node might still work with defaults
+            }
+        }
+        // Register ts-node with tempDir as project root
+        try {
+            require('ts-node').register({
+                project: tsconfigPath,
+                transpileOnly: true, // Faster, skip type checking
+                compilerOptions: {
+                    module: 'commonjs',
+                    esModuleInterop: true
+                }
+            });
+        }
+        catch (e) {
+            // ts-node not available or registration failed
+            // That's okay - will work for .js files, .ts files will fail with clear error
+        }
     }
     /**
      * Execute code in persistent context
      * Variables defined here persist for future executions
+     * Uses AsyncLocalStorage to ensure module resolution is isolated per execution
      */
     async executeCode(code) {
         // Wrap in async IIFE for await support
         const wrappedCode = `(async () => { ${code} })()`;
-        // Compile and execute in persistent context
-        const script = new vm.Script(wrappedCode);
-        const result = script.runInContext(this.context);
-        // Wait for async completion
-        await result;
+        // If tempDir is set, run in isolated context with module resolution
+        if (this.tempDir) {
+            // Execute within AsyncLocalStorage context so module resolution hook can access tempDir
+            // Use the stored testFileDir if available, otherwise use tempDir
+            const context = {
+                tempDir: this.tempDir,
+                testFileDir: this.context.__testFileDir
+            };
+            await ModuleResolutionManager.runWithContext(context, async () => {
+                const script = new vm.Script(wrappedCode);
+                const result = script.runInContext(this.context);
+                await result;
+            });
+        }
+        else {
+            // No tempDir - execute normally without module resolution
+            const script = new vm.Script(wrappedCode);
+            const result = script.runInContext(this.context);
+            await result;
+        }
     }
     /**
      * Get list of user-defined variables (for debugging)
@@ -123,6 +346,8 @@ class PersistentExecutionContext {
     /**
      * Dispose the context (cleanup)
      * Called after test execution completes
+     * Note: Module resolution hook is shared and not restored here
+     * (it remains installed for other concurrent executions)
      */
     dispose() {
         // V8 will garbage collect the context when no longer referenced
@@ -368,10 +593,306 @@ class ExecutionService {
      * Variables persist across steps without re-execution
      */
     async executeStepsInPersistentContext(steps, page, browser, browserContext, options) {
+        this.log(`[executeStepsInPersistentContext] Called with ${steps.length} steps, mode=${options.mode}, originalScript=${!!options.originalScript}, tempDir=${!!options.tempDir}`);
         const { expect, test } = require('@playwright/test');
         const { ai } = require('ai-wright');
-        // Create persistent execution context
-        const persistentContext = new PersistentExecutionContext(page, expect, test, ai, browser, browserContext);
+        // Create persistent execution context with module resolution support
+        const persistentContext = new PersistentExecutionContext(page, expect, test, ai, browser, browserContext, options.tempDir);
+        // Extract and execute imports from original script if provided
+        this.log(`[executeStepsInPersistentContext] Checking imports: originalScript=${!!options.originalScript}, tempDir=${!!options.tempDir}`);
+        if (options.originalScript && options.tempDir) {
+            try {
+                this.log(`Extracting import statements from script (length: ${options.originalScript.length})`);
+                const importStatements = import_utils_1.ImportUtils.extractImportStatements(options.originalScript, (msg) => this.log(msg));
+                if (importStatements.length > 0) {
+                    this.log(`Executing ${importStatements.length} import statement(s) before steps`);
+                    // Convert ES6 imports to CommonJS requires and execute
+                    const requireStatements = import_utils_1.ImportUtils.convertImportsToRequires(importStatements, (msg) => this.log(msg));
+                    // Execute imports with proper context - find the actual test file path
+                    // All tests are within the tests folder
+                    // We search for test files in tempDir/tests directory tree
+                    let testFileDir = path.join(options.tempDir, 'tests'); // Default to tests directory
+                    try {
+                        const fs = require('fs');
+                        const testsDir = path.join(options.tempDir, 'tests');
+                        // Check if tests directory exists
+                        if (!fs.existsSync(testsDir)) {
+                            this.log(`Tests directory ${testsDir} does not exist, using default for module resolution`, 'warn');
+                        }
+                        else {
+                            // Recursive search with depth limit to prevent infinite loops
+                            const findTestFile = (dir, depth = 0, maxDepth = 10) => {
+                                if (depth > maxDepth) {
+                                    return null; // Prevent infinite recursion
+                                }
+                                try {
+                                    const files = fs.readdirSync(dir);
+                                    for (const file of files) {
+                                        const fullPath = path.join(dir, file);
+                                        try {
+                                            const stat = fs.statSync(fullPath);
+                                            if (stat.isDirectory()) {
+                                                const found = findTestFile(fullPath, depth + 1, maxDepth);
+                                                if (found)
+                                                    return found;
+                                            }
+                                            else if (file.endsWith('.spec.ts') || file.endsWith('.spec.js') ||
+                                                file.endsWith('.test.ts') || file.endsWith('.test.js')) {
+                                                return fullPath; // Found a test file
+                                            }
+                                        }
+                                        catch (statError) {
+                                            // Skip files we can't stat
+                                            continue;
+                                        }
+                                    }
+                                }
+                                catch (e) {
+                                    // Continue searching in other directories
+                                }
+                                return null;
+                            };
+                            const testFilePath = findTestFile(testsDir);
+                            if (testFilePath) {
+                                testFileDir = path.dirname(testFilePath);
+                                this.log(`Found test file at ${testFilePath}, using directory ${testFileDir} for module resolution`);
+                            }
+                            else {
+                                this.log(`No test file found in ${testsDir}, using tests directory for module resolution`, 'warn');
+                            }
+                        }
+                    }
+                    catch (searchError) {
+                        this.log(`Could not search for test file: ${searchError.message}, using tests directory for module resolution`, 'warn');
+                    }
+                    // Store test file directory in context for module resolution
+                    persistentContext.context.__testFileDir = testFileDir;
+                    this.log(`Module resolution context: testFileDir=${testFileDir}, tempDir=${options.tempDir}`);
+                    this.log(`Executing require statements in persistent context...`);
+                    try {
+                        // Execute require statements - variables will be in the IIFE scope
+                        // We need to explicitly assign them to the context so they're accessible later
+                        // The issue is that const declarations in an IIFE don't leak to the outer context
+                        // Solution: Execute the requires and then manually assign to context
+                        const context = persistentContext.context;
+                        // Execute require statements and capture results
+                        // We execute each require and capture the module, then assign exports to context
+                        // This approach is more robust - we execute the require and then extract what was imported
+                        const requireLines = requireStatements.split('\n').filter(line => line.trim().length > 0);
+                        const captureCodeParts = [];
+                        const importMappings = [];
+                        requireLines.forEach((line, idx) => {
+                            // Extract module path
+                            const modulePathMatch = line.match(/require\(['"]([^'"]+)['"]\)/);
+                            if (!modulePathMatch)
+                                return;
+                            const modulePath = modulePathMatch[1];
+                            // Extract variable names from the require statement
+                            // Handle: const { X, Y } = require(...), const X = require(...), const * as X = require(...)
+                            const varNames = [];
+                            const namedMatch = line.match(/const\s+\{([^}]+)\}\s*=/);
+                            const defaultMatch = line.match(/const\s+(\w+)\s*=/);
+                            const namespaceMatch = line.match(/const\s+\*\s+as\s+(\w+)\s*=/);
+                            if (namedMatch) {
+                                // Named imports: const { X, Y } = require(...)
+                                const names = namedMatch[1].split(',').map(n => n.trim().split(' as ')[0].trim());
+                                varNames.push(...names);
+                            }
+                            else if (namespaceMatch) {
+                                // Namespace import: const * as X = require(...)
+                                varNames.push(namespaceMatch[1]);
+                            }
+                            else if (defaultMatch) {
+                                // Default import: const X = require(...)
+                                varNames.push(defaultMatch[1]);
+                            }
+                            importMappings.push({ line, modulePath, varNames });
+                            // Generate code to execute require and capture exports
+                            captureCodeParts.push(`
+                const _mod${idx} = require('${modulePath}');
+                if (_mod${idx} !== null && _mod${idx} !== undefined) {
+                  ${varNames.map((varName, varIdx) => {
+                                if (namedMatch) {
+                                    // Named import - get from module
+                                    return `_importResults['${varName}'] = _mod${idx}.${varName};`;
+                                }
+                                else if (namespaceMatch) {
+                                    // Namespace import - get entire module
+                                    return `_importResults['${varName}'] = _mod${idx};`;
+                                }
+                                else {
+                                    // Default import - get default or entire module
+                                    return `_importResults['${varName}'] = _mod${idx}.default !== undefined ? _mod${idx}.default : _mod${idx};`;
+                                }
+                            }).join('\n                  ')}
+                }
+              `);
+                        });
+                        const captureCode = `
+              (async () => {
+                const _importResults = {};
+                ${captureCodeParts.join('\n')}
+                return _importResults;
+              })()
+            `;
+                        this.log(`Executing require statements with capture...`);
+                        let importResults = {};
+                        try {
+                            if (options.tempDir) {
+                                importResults = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir }, async () => {
+                                    const script = new vm.Script(captureCode);
+                                    const result = script.runInContext(context);
+                                    return await result;
+                                });
+                            }
+                            else {
+                                const script = new vm.Script(captureCode);
+                                const result = script.runInContext(context);
+                                importResults = await result;
+                            }
+                            // Assign results to context
+                            for (const [key, value] of Object.entries(importResults)) {
+                                context[key] = value;
+                                this.log(`Assigned ${key} to context`);
+                            }
+                        }
+                        catch (importExecError) {
+                            // If import execution fails (e.g., due to missing dependencies in POM files),
+                            // try to execute imports individually to see which ones succeed
+                            this.log(`Import execution failed: ${importExecError.message}. Attempting individual imports...`, 'warn');
+                            // Execute each require statement individually and capture results
+                            // This is more robust - we execute the require and capture all exports
+                            const individualRequires = requireStatements.split('\n').filter(line => line.trim().length > 0);
+                            for (const requireStmt of individualRequires) {
+                                try {
+                                    // Execute the require statement and capture the module
+                                    // We'll extract the module path if possible, but if not, execute as-is
+                                    const modulePathMatch = requireStmt.match(/require\(['"]([^'"]+)['"]\)/);
+                                    const modulePath = modulePathMatch ? modulePathMatch[1] : null;
+                                    let moduleResult;
+                                    if (modulePath && options.tempDir) {
+                                        // Execute require for the specific module
+                                        moduleResult = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir }, async () => {
+                                            const script = new vm.Script(`(() => require('${modulePath}'))()`);
+                                            return script.runInContext(context);
+                                        });
+                                    }
+                                    else {
+                                        // Execute the full require statement as-is
+                                        if (options.tempDir) {
+                                            moduleResult = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir }, async () => {
+                                                // Try to extract variable name, but execute the require
+                                                const varNameMatch = requireStmt.match(/const\s+(\w+)\s*=/);
+                                                if (varNameMatch) {
+                                                    const script = new vm.Script(`(() => { ${requireStmt}; return ${varNameMatch[1]}; })()`);
+                                                    return script.runInContext(context);
+                                                }
+                                                else {
+                                                    // Side-effect import - just execute
+                                                    const script = new vm.Script(`(() => { ${requireStmt}; return null; })()`);
+                                                    script.runInContext(context);
+                                                    return null;
+                                                }
+                                            });
+                                        }
+                                        else {
+                                            const varNameMatch = requireStmt.match(/const\s+(\w+)\s*=/);
+                                            if (varNameMatch) {
+                                                const script = new vm.Script(`(() => { ${requireStmt}; return ${varNameMatch[1]}; })()`);
+                                                moduleResult = script.runInContext(context);
+                                            }
+                                            else {
+                                                const script = new vm.Script(`(() => { ${requireStmt}; return null; })()`);
+                                                script.runInContext(context);
+                                                moduleResult = null;
+                                            }
+                                        }
+                                    }
+                                    // Assign all exports from the module to context
+                                    // This handles named imports, default imports, and namespace imports generically
+                                    if (moduleResult && typeof moduleResult === 'object') {
+                                        // Assign all named exports
+                                        Object.keys(moduleResult).forEach(key => {
+                                            if (key !== 'default') {
+                                                context[key] = moduleResult[key];
+                                                this.log(`Assigned ${key} to context`);
+                                            }
+                                        });
+                                        // Assign default export if present
+                                        if (moduleResult.default !== undefined) {
+                                            // Try to find the variable name from the require statement
+                                            const varNameMatch = requireStmt.match(/const\s+(\w+)\s*=/);
+                                            if (varNameMatch) {
+                                                context[varNameMatch[1]] = moduleResult.default;
+                                                this.log(`Assigned ${varNameMatch[1]} (default) to context`);
+                                            }
+                                        }
+                                    }
+                                    else if (moduleResult !== null && moduleResult !== undefined) {
+                                        // Module is not an object (e.g., primitive or function)
+                                        const varNameMatch = requireStmt.match(/const\s+(\w+)\s*=/);
+                                        if (varNameMatch) {
+                                            context[varNameMatch[1]] = moduleResult;
+                                            this.log(`Assigned ${varNameMatch[1]} to context`);
+                                        }
+                                    }
+                                    this.log(`Successfully executed: ${requireStmt.substring(0, 80)}...`);
+                                }
+                                catch (individualError) {
+                                    this.log(`Failed to execute: ${requireStmt.substring(0, 80)}... - ${individualError.message}`, 'warn');
+                                    // Continue with other imports
+                                }
+                            }
+                        }
+                        this.log('Import statements executed successfully');
+                        // Verify that the imports were actually loaded by checking the context
+                        const contextKeys = Object.keys(context);
+                        const userVars = contextKeys.filter((key) => !['page', 'expect', 'test', 'ai', 'browser', 'context', 'console', 'require',
+                            'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'Buffer',
+                            'process', '__dirname', '__filename', '__testFileDir', 'Math', 'Date',
+                            'JSON', 'Promise', 'Array', 'Object', 'String', 'Number', 'Boolean',
+                            'Error', 'Set', 'Map', 'WeakSet', 'WeakMap'].includes(key));
+                        this.log(`Context variables after import execution: ${userVars.join(', ') || '(none)'}`);
+                    }
+                    catch (execError) {
+                        this.log(`Error executing require statements: ${execError.message}`, 'error');
+                        this.log(`Stack trace: ${execError.stack}`, 'error');
+                        throw execError;
+                    }
+                }
+            }
+            catch (importError) {
+                this.log(`Warning: Failed to execute imports: ${importError.message}`, 'warn');
+                // Continue execution - some imports might not be needed
+            }
+            // Extract and execute initialization code from the test script
+            // This includes code like: const signInPage = new SignInPage(page);
+            // We execute this using the same mechanism as steps (persistentContext.executeCode)
+            // But we need to transform const/let to assignments so variables are available in context
+            if (options.originalScript) {
+                try {
+                    this.log('Extracting initialization code from test script...');
+                    const initializationCode = initialization_code_utils_1.InitializationCodeUtils.extractInitializationCode(options.originalScript, (msg, level) => this.log(msg, level));
+                    if (initializationCode) {
+                        this.log(`Executing initialization code: ${initializationCode.substring(0, 100)}...`);
+                        // Transform const/let declarations to assignments so they create properties on context
+                        // This is necessary because const/let create block-scoped variables, not context properties
+                        const { transformedCode } = initialization_code_utils_1.InitializationCodeUtils.transformInitializationCode(initializationCode, (msg, level) => this.log(msg, level));
+                        // Execute using the same mechanism as steps
+                        // This ensures consistent behavior and module resolution
+                        await persistentContext.executeCode(transformedCode);
+                        this.log('Initialization code executed successfully');
+                    }
+                    else {
+                        this.log('No initialization code found in test script');
+                    }
+                }
+                catch (initError) {
+                    this.log(`Warning: Failed to execute initialization code: ${initError.message}`, 'warn');
+                    // Continue execution - initialization might not be needed
+                }
+            }
+        }
         this.log(`Executing ${steps.length} steps in persistent context (mode: ${options.mode})`);
         // Track executed step descriptions for repair context
         const executedStepDescriptions = [];
@@ -404,7 +925,12 @@ class ExecutionService {
                 await persistentContext.executeCode(step.code);
                 this.log(`  ✓ Step ${i + 1} succeeded`);
                 // Mark step as successful
-                step.success = true;
+                // Ensure we're updating the step in the array (important after repair when new object was created)
+                updatedSteps[i].success = true;
+                // Ensure code is preserved in array (defensive - step is a reference but be explicit after repair)
+                if (step.code && step.code.trim().length > 0) {
+                    updatedSteps[i].code = step.code;
+                }
                 // Track executed step for repair context
                 executedStepDescriptions.push(step.description);
                 // LIFECYCLE: onStepComplete (success)
@@ -544,6 +1070,7 @@ class ExecutionService {
         const totalAttempts = deflakeRunCount + 1; // Original run + deflake attempts
         let lastError = null;
         this.log(`runExactly: deflakeRunCount = ${deflakeRunCount}, totalAttempts = ${totalAttempts}`);
+        this.log(`runExactly: request.script = ${!!request.script} (length: ${request.script?.length || 0}), request.tempDir = ${request.tempDir}`);
         // Script content should be provided by the caller (TestChimpService)
         // The TestChimpService handles file reading through the appropriate FileHandler
         if (!request.script) {
@@ -575,7 +1102,9 @@ class ExecutionService {
                 // Execute steps in persistent context (STOP on first error)
                 const result = await this.executeStepsInPersistentContext(steps, page, browser, context, {
                     mode: 'RUN_EXACTLY',
-                    jobId: request.jobId
+                    jobId: request.jobId,
+                    tempDir: request.tempDir,
+                    originalScript: request.script // Pass original script for import extraction
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -630,7 +1159,9 @@ class ExecutionService {
                 // Execute steps in persistent context (STOP on first error)
                 const result = await this.executeStepsInPersistentContext(steps, page, browser, context, {
                     mode: 'RUN_EXACTLY',
-                    jobId: request.jobId
+                    jobId: request.jobId,
+                    tempDir: request.tempDir,
+                    originalScript: request.script // Pass original script for import extraction
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -744,7 +1275,9 @@ class ExecutionService {
             const result = await this.executeStepsInPersistentContext(steps, repairPage, repairBrowser, repairContext, {
                 mode: 'RUN_WITH_AI_REPAIR',
                 jobId: request.jobId,
-                model
+                model,
+                tempDir: request.tempDir,
+                originalScript: request.script // Pass original script for import extraction
             });
             const updatedSteps = result.updatedSteps || steps;
             const allStepsSuccessful = result.success;
@@ -813,52 +1346,11 @@ class ExecutionService {
         }
         catch (error) {
             this.log(`LLM parsing failed, falling back to code parsing: ${error}`);
-            const fallbackResult = this.parseScriptIntoStepsFallback(script);
+            const fallbackResult = script_parser_utils_1.ScriptParserUtils.parseScriptIntoStepsFallback(script);
             this.log(`Fallback parsing successful, got ${fallbackResult.length} steps`);
             return fallbackResult;
         }
     }
-    parseScriptIntoStepsFallback(script) {
-        const lines = script.split('\n');
-        const steps = [];
-        let currentStep = null;
-        let currentCode = [];
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            // Check for step comment
-            if (trimmedLine.startsWith('// Step ')) {
-                // Save previous step if exists and has code
-                if (currentStep) {
-                    const code = currentCode.join('\n').trim();
-                    const cleanedCode = this.cleanStepCode(code);
-                    if (cleanedCode) {
-                        currentStep.code = cleanedCode;
-                        steps.push(currentStep);
-                    }
-                }
-                // Start new step
-                const description = trimmedLine.replace(/^\/\/\s*Step\s*\d+:\s*/, '').replace(/\s*\[FAILED\]\s*$/, '').trim();
-                currentStep = { description, code: '' };
-                currentCode = [];
-            }
-            else if (trimmedLine && !trimmedLine.startsWith('import') && !trimmedLine.startsWith('test(') && !trimmedLine.startsWith('});')) {
-                // Add code line to current step
-                if (currentStep) {
-                    currentCode.push(line);
-                }
-            }
-        }
-        // Add the last step if it has code
-        if (currentStep) {
-            const code = currentCode.join('\n').trim();
-            const cleanedCode = this.cleanStepCode(code);
-            if (cleanedCode) {
-                currentStep.code = cleanedCode;
-                steps.push(currentStep);
-            }
-        }
-        return steps;
-    }
     async repairStepsWithAI(steps, page, repairFlexibility, model, jobId) {
         let updatedSteps = [...steps];
         const maxTries = 3;
@@ -964,7 +1456,7 @@ class ExecutionService {
                 // Unexpected error in the tracking logic itself
                 this.log(`Unexpected error in step execution tracking: ${error}`);
                 step.success = false;
-                step.error = this.safeSerializeError(error);
+                step.error = step_execution_utils_1.StepExecutionUtils.safeSerializeError(error);
                 stepWasAttempted = true; // Mark as attempted (failed)
             }
             // Only attempt repair if step was actually tried and failed
@@ -1096,7 +1588,7 @@ class ExecutionService {
         page.setDefaultNavigationTimeout(30000);
         try {
             // Clean and validate the code before execution
-            const cleanedCode = this.cleanStepCode(code);
+            const cleanedCode = script_parser_utils_1.ScriptParserUtils.cleanStepCode(code);
             if (!cleanedCode || cleanedCode.trim().length === 0) {
                 throw new Error('Step code is empty or contains only comments');
             }
@@ -1120,20 +1612,6 @@ class ExecutionService {
             page.setDefaultNavigationTimeout(30000);
         }
     }
-    /**
-     * Validate step code has executable content (preserves comments)
-     */
-    cleanStepCode(code) {
-        if (!code || code.trim().length === 0) {
-            return '';
-        }
-        // Check if there are any executable statements (including those with comments)
-        const hasExecutableCode = /[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(|await\s+|return\s+|if\s*\(|for\s*\(|while\s*\(|switch\s*\(|try\s*\{|catch\s*\(/.test(code);
-        if (!hasExecutableCode) {
-            return '';
-        }
-        return code; // Return the original code without removing comments
-    }
     // Legacy repair helper methods (now unused but kept for compilation)
     buildFailureHistory() { return ''; }
     buildRecentRepairsContext() { return ''; }
@@ -1141,43 +1619,7 @@ class ExecutionService {
         return { success: false };
     }
     generateUpdatedScript(steps, repairAdvice, originalScript) {
-        // Extract test name and hashtags from original script if provided
-        let testName = 'repairedTest';
-        let hashtags = [];
-        if (originalScript) {
-            const testNameMatch = originalScript.match(/test\(['"]([^'"]+)['"]/);
-            if (testNameMatch) {
-                testName = testNameMatch[1];
-            }
-            // Extract hashtags from TestChimp comment
-            const hashtagMatch = originalScript.match(/#\w+(?:\s+#\w+)*/);
-            if (hashtagMatch) {
-                hashtags = hashtagMatch[0].split(/\s+/).filter(tag => tag.startsWith('#'));
-            }
-        }
-        const scriptLines = [
-            "import { test, expect } from '@playwright/test';"
-        ];
-        const needsAiImport = steps.some(step => (0, ai_command_utils_1.containsAiCommand)(step.code));
-        if (needsAiImport) {
-            scriptLines.push("import { ai } from 'ai-wright';");
-        }
-        scriptLines.push('');
-        scriptLines.push(`test('${testName}', async ({ page, browser, context }) => {`);
-        steps.forEach((step, index) => {
-            // Only add step if it has code to execute
-            if (step.code && step.code.trim().length > 0) {
-                scriptLines.push(`  // ${step.description}`);
-                const codeLines = step.code.split('\n');
-                codeLines.forEach(line => {
-                    scriptLines.push(`  ${line}`);
-                });
-            }
-        });
-        scriptLines.push('});');
-        const script = scriptLines.join('\n');
-        // Add TestChimp comment with hashtags and repair advice
-        return (0, script_utils_1.addTestChimpComment)(script, repairAdvice, hashtags);
+        return script_generator_utils_1.ScriptGeneratorUtils.generateUpdatedScript(steps, repairAdvice, originalScript);
     }
     /**
      * Initialize browser with configuration (delegates to utility function)
@@ -1198,7 +1640,7 @@ class ExecutionService {
         let remainingCommands = [];
         let error;
         // Parse step code into individual statements (handles multi-line await blocks)
-        const statements = this.splitIntoExecutableStatements(stepCode);
+        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)
@@ -1241,7 +1683,7 @@ class ExecutionService {
                     successfulCommands: [],
                     failingCommand: stepCode,
                     remainingCommands: [],
-                    error: this.safeSerializeError(err)
+                    error: step_execution_utils_1.StepExecutionUtils.safeSerializeError(err)
                 };
             }
         }
@@ -1276,7 +1718,7 @@ class ExecutionService {
             catch (err) {
                 // This command failed - it's the failing one
                 failingCommand = cmd;
-                error = this.safeSerializeError(err);
+                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)}...`);
@@ -1289,90 +1731,6 @@ class ExecutionService {
         }
         return { successfulCommands, failingCommand, remainingCommands, error };
     }
-    /**
-     * Split raw step code into syntactically complete statements.
-     * Uses Function compilation to detect when a statement is complete so that
-     * multi-line await blocks (e.g., ai.verify) are preserved.
-     */
-    splitIntoExecutableStatements(stepCode) {
-        const statements = [];
-        const lines = stepCode.split('\n');
-        let buffer = [];
-        const flushBuffer = () => {
-            if (buffer.length === 0) {
-                return;
-            }
-            const statement = buffer.join('\n').trim();
-            if (statement.length > 0) {
-                statements.push(statement);
-            }
-            buffer = [];
-        };
-        const isIncomplete = (code) => {
-            const trimmed = code.trim();
-            if (trimmed.length === 0) {
-                return false;
-            }
-            try {
-                new Function('page', 'expect', 'test', 'ai', `return async () => {\n${code}\n};`);
-                return false;
-            }
-            catch (error) {
-                if (error instanceof SyntaxError) {
-                    return true;
-                }
-                return false;
-            }
-        };
-        for (const rawLine of lines) {
-            if (buffer.length === 0 && rawLine.trim().length === 0) {
-                continue;
-            }
-            buffer.push(rawLine);
-            const candidate = buffer.join('\n');
-            if (!isIncomplete(candidate)) {
-                flushBuffer();
-            }
-        }
-        flushBuffer();
-        return statements;
-    }
-    /**
-     * Safely serialize error information, filtering out non-serializable values
-     */
-    safeSerializeError(error) {
-        try {
-            if (error instanceof Error) {
-                return error.message;
-            }
-            if (typeof error === 'string') {
-                return error;
-            }
-            if (typeof error === 'object' && error !== null) {
-                // Try to extract meaningful information without serializing the entire object
-                const safeError = {};
-                // Copy safe properties
-                if (error.message)
-                    safeError.message = error.message;
-                if (error.name)
-                    safeError.name = error.name;
-                if (error.code)
-                    safeError.code = error.code;
-                if (error.status)
-                    safeError.status = error.status;
-                // Try to get stack trace safely
-                if (error.stack && typeof error.stack === 'string') {
-                    safeError.stack = error.stack;
-                }
-                return JSON.stringify(safeError);
-            }
-            return String(error);
-        }
-        catch (serializationError) {
-            // If even safe serialization fails, return a basic string representation
-            return `Error: ${String(error)}`;
-        }
-    }
 }
 exports.ExecutionService = ExecutionService;
 //# sourceMappingURL=execution-service.js.map