testchimp-runner-core 0.1.5 → 0.1.7

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

@@ -1 +1 @@
-{"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,EAG1B,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;AAmbvD;;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;IA4lB7C;;;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;IAorBxF;;;;;OAKG;YACW,WAAW;CAgI1B"}
+{"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,EAG1B,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;AAylBvD;;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;IAmkB7C;;;OAGG;YACW,iBAAiB;YAiGjB,UAAU;YAoLV,eAAe;YAqKf,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;IAqrBxF;;;;;OAKG;YACW,WAAW;CAkI1B"}

package/dist/execution-service.js

@@ -56,6 +56,13 @@ const build_info_1 = require("./build-info");
 const orchestrator_1 = require("./orchestrator");
 const test_file_parser_1 = require("./utils/test-file-parser");
 class ModuleResolutionManager {
+    /**
+     * Get the current module resolution context from AsyncLocalStorage
+     * Public method to allow requireWrapper to access the context
+     */
+    static getContext() {
+        return this.asyncLocalStorage.getStore();
+    }
     /**
      * Install the global hook (only once, shared by all instances)
      */
@@ -77,7 +84,7 @@ class ModuleResolutionManager {
             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}`);
+                // Note: This runs at module load time, before we have a logger, so we can't log here
             }
         }
         catch (e) {
@@ -87,12 +94,14 @@ class ModuleResolutionManager {
         Module._resolveFilename = function (request, parent, isMain, options) {
             // Get resolution context for current execution
             const context = ModuleResolutionManager.asyncLocalStorage.getStore();
+            const log = context?.log || (() => { }); // No-op if no logger available
+            // Log all module resolution attempts (even without context, for debugging)
+            log(`[ModuleResolution] Hook intercepted: "${request}" (parent: ${parent?.filename || 'none'}, hasContext: ${!!context})`);
             // If no context, use original resolution (for requires outside our execution context)
             if (!context) {
+                log(`[ModuleResolution] No context available, using original resolution`);
                 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
@@ -100,27 +109,27 @@ class ModuleResolutionManager {
                 // 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}`);
+                log(`[ModuleResolution] Resolving relative import: "${request}"`);
+                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}`);
+                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}`);
+                            log(`[ModuleResolution]   ✓ Found file: ${testPath}`);
                             return testPath;
                         }
                         else {
-                            console.log(`[ModuleResolution]   ✗ File does not exist: ${testPath}`);
+                            log(`[ModuleResolution]   ✗ File does not exist: ${testPath}`);
                         }
                     }
                     catch (e) {
-                        console.log(`[ModuleResolution]   ✗ Error checking file: ${testPath} - ${e}`);
+                        log(`[ModuleResolution]   ✗ Error checking file: ${testPath} - ${e}`, 'error');
                     }
                 }
                 // If no extension worked, try original resolution
@@ -144,45 +153,95 @@ class ModuleResolutionManager {
                 }
             }
             // 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}"`);
+            // These should resolve from node_modules in the workspace root (where the test files are)
+            log(`[ModuleResolution] Resolving non-relative import: "${request}"`);
+            log(`[ModuleResolution]   tempDir: ${context.tempDir}, testFileDir: ${context.testFileDir || 'undefined'}`);
+            // Find workspace root by looking for node_modules or package.json going up from tempDir
+            // tempDir is the tests folder (e.g., /workspace/tests), so we need to find /workspace/node_modules
+            let workspaceRoot = null;
+            if (context.tempDir) {
+                let currentDir = context.tempDir;
+                const maxDepth = 10; // Prevent infinite loops
+                let depth = 0;
+                log(`[ModuleResolution]   Searching for workspace root starting from: ${currentDir}`);
+                while (depth < maxDepth && currentDir !== path.dirname(currentDir)) {
+                    const nodeModulesPath = path.join(currentDir, 'node_modules');
+                    const packageJsonPath = path.join(currentDir, 'package.json');
+                    log(`[ModuleResolution]   Checking: ${currentDir} (depth: ${depth})`);
+                    if (fs.existsSync(nodeModulesPath) || fs.existsSync(packageJsonPath)) {
+                        workspaceRoot = currentDir;
+                        log(`[ModuleResolution]   ✓ Found workspace root: ${workspaceRoot}`);
+                        break;
+                    }
+                    currentDir = path.dirname(currentDir);
+                    depth++;
+                }
+                if (!workspaceRoot) {
+                    log(`[ModuleResolution]   ✗ Workspace root not found after ${depth} levels`, 'warn');
+                }
+            }
+            else {
+                log(`[ModuleResolution]   ✗ No tempDir in context`, 'warn');
+            }
+            // Temporarily modify Module._nodeModulePaths to include workspace root's node_modules
+            // This ensures Node.js searches the workspace root for modules like @playwright/test and ai-wright
+            const originalNodeModulePaths = Module._nodeModulePaths;
+            let nodeModulePathsModified = false;
+            if (workspaceRoot) {
+                const workspaceNodeModules = path.join(workspaceRoot, 'node_modules');
+                log(`[ModuleResolution]   Workspace node_modules: ${workspaceNodeModules}`);
+                Module._nodeModulePaths = function (from) {
+                    const paths = originalNodeModulePaths.call(this, from);
+                    // Prepend workspace root's node_modules to the search paths (highest priority)
+                    if (!paths.includes(workspaceNodeModules)) {
+                        paths.unshift(workspaceNodeModules);
+                        log(`[ModuleResolution]   Modified _nodeModulePaths: prepended ${workspaceNodeModules}`);
+                    }
+                    return paths;
+                };
+                nodeModulePathsModified = true;
+                log(`[ModuleResolution]   Modified _nodeModulePaths to include workspace root: ${workspaceNodeModules}`);
+            }
             try {
-                // Use original Node.js resolution (will find from node_modules)
+                // Use original Node.js resolution (will now search workspace root's node_modules first)
+                log(`[ModuleResolution]   Attempting resolution with modified paths...`);
                 const resolved = ModuleResolutionManager.originalResolveFilename.call(this, request, parent, isMain, options);
-                console.log(`[ModuleResolution]   ✓ Resolved to: ${resolved}`);
+                log(`[ModuleResolution]   ✓ Resolved to: ${resolved}`);
+                // Restore original _nodeModulePaths
+                if (nodeModulePathsModified) {
+                    Module._nodeModulePaths = originalNodeModulePaths;
+                }
                 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;
+                // Restore original _nodeModulePaths before handling error
+                if (nodeModulePathsModified) {
+                    Module._nodeModulePaths = originalNodeModulePaths;
                 }
-                catch (resolveErr) {
-                    console.log(`[ModuleResolution]   ✗ Failed with enhanced paths: ${resolveErr}`);
-                    // Fall back to original error
-                    throw err;
+                log(`[ModuleResolution]   ✗ Failed to resolve: ${err.message}`, 'error');
+                // Fallback: try scriptservice's node_modules (for server-side usage)
+                if (ModuleResolutionManager.scriptserviceNodeModules) {
+                    log(`[ModuleResolution]   Trying scriptservice node_modules fallback...`);
+                    try {
+                        // Manually check if module exists in scriptservice's node_modules
+                        const scriptserviceModulePath = path.join(ModuleResolutionManager.scriptserviceNodeModules, request);
+                        // Check for both directory and file modules
+                        if (fs.existsSync(scriptserviceModulePath) ||
+                            fs.existsSync(scriptserviceModulePath + '.js') ||
+                            fs.existsSync(scriptserviceModulePath + '.json')) {
+                            log(`[ModuleResolution]   ✓ Found in scriptservice node_modules: ${scriptserviceModulePath}`);
+                            return scriptserviceModulePath;
+                        }
+                        else {
+                            log(`[ModuleResolution]   ✗ Not found in scriptservice node_modules: ${scriptserviceModulePath}`);
+                        }
+                    }
+                    catch (fallbackErr) {
+                        log(`[ModuleResolution]   ✗ Fallback error: ${fallbackErr.message}`, 'error');
+                        // Continue to throw original error
+                    }
                 }
+                throw err;
             }
         };
         this.hookInstalled = true;
@@ -194,6 +253,9 @@ class ModuleResolutionManager {
         return this.asyncLocalStorage.run({ tempDir }, fn);
     }
     static runWithContext(context, fn) {
+        // Log when context is set
+        const log = context.log || (() => { });
+        log(`[ModuleResolutionManager] Setting context: tempDir=${context.tempDir}, testFileDir=${context.testFileDir || 'undefined'}`);
         return this.asyncLocalStorage.run(context, fn);
     }
 }
@@ -206,13 +268,97 @@ ModuleResolutionManager.scriptserviceNodeModules = null;
  * Variables defined in earlier steps remain available in later steps without re-evaluation
  */
 class PersistentExecutionContext {
-    constructor(page, expect, test, ai, browser, browserContext, tempDir) {
+    constructor(page, expect, test, ai, browser, browserContext, tempDir, log) {
         this.tempDir = tempDir;
+        this.log = log;
+        // Find workspace root by looking for node_modules or package.json going up from tempDir
+        // tempDir is the tests folder (e.g., /workspace/tests), so we need to find /workspace/node_modules
+        const path = require('path');
+        const Module = require('module');
+        let workspaceRoot = null;
+        if (tempDir) {
+            const fs = require('fs');
+            let currentDir = tempDir;
+            const maxDepth = 10; // Prevent infinite loops
+            let depth = 0;
+            while (depth < maxDepth && currentDir !== path.dirname(currentDir)) {
+                const nodeModulesPath = path.join(currentDir, 'node_modules');
+                const packageJsonPath = path.join(currentDir, 'package.json');
+                if (fs.existsSync(nodeModulesPath) || fs.existsSync(packageJsonPath)) {
+                    workspaceRoot = currentDir;
+                    this.log?.(`[PersistentExecutionContext] Found workspace root: ${workspaceRoot}`);
+                    break;
+                }
+                currentDir = path.dirname(currentDir);
+                depth++;
+            }
+            if (!workspaceRoot) {
+                this.log?.(`[PersistentExecutionContext] Workspace root not found, tempDir: ${tempDir}`);
+            }
+        }
+        this.workspaceRoot = workspaceRoot || undefined;
         // Install global hook if not already installed (only happens once)
         if (tempDir) {
             ModuleResolutionManager.installHook();
             this.setupTypeScriptSupport(tempDir);
         }
+        // Create a require wrapper that ensures the hook is triggered
+        // When require is passed directly to vm.createContext(), it may not use the hooked Module._resolveFilename
+        // We manually invoke Module._resolveFilename (our hook) when context is available
+        const parentRequire = require;
+        const requireWrapper = (function (parentReq, logFn) {
+            return function (id) {
+                // Log when wrapper is called
+                logFn?.(`[RequireWrapper] Wrapper called for: "${id}"`);
+                // Get the current AsyncLocalStorage context
+                const context = ModuleResolutionManager.getContext();
+                if (context) {
+                    // We have context, so manually trigger our hook logic by calling Module._resolveFilename
+                    logFn?.(`[RequireWrapper] Context available, manually invoking Module._resolveFilename for: "${id}"`);
+                    try {
+                        // Create a fake parent module object for resolution
+                        // Use testFileDir or tempDir as the parent's filename to ensure relative paths resolve correctly
+                        const parentFilename = context.testFileDir
+                            ? path.join(context.testFileDir, 'dummy.js')
+                            : (context.tempDir ? path.join(context.tempDir, 'dummy.js') : __filename);
+                        // Manually call the hooked Module._resolveFilename to get the resolved path
+                        // This will trigger our custom resolution logic (e.g., .page.ts extensions)
+                        const resolvedPath = Module._resolveFilename(id, { filename: parentFilename }, false);
+                        logFn?.(`[RequireWrapper] Resolved path: ${resolvedPath}`);
+                        // Now load the module using Module._load with the resolved path
+                        const module = Module._load(resolvedPath, { filename: parentFilename }, false);
+                        logFn?.(`[RequireWrapper] Successfully loaded: "${id}"`);
+                        return module;
+                    }
+                    catch (err) {
+                        logFn?.(`[RequireWrapper] Manual resolution failed for: "${id}" - ${err.message}`, 'error');
+                        // Fall back to standard require
+                        try {
+                            const result = parentReq(id);
+                            logFn?.(`[RequireWrapper] Fallback to standard require succeeded for: "${id}"`);
+                            return result;
+                        }
+                        catch (fallbackErr) {
+                            logFn?.(`[RequireWrapper] Fallback also failed for: "${id}" - ${fallbackErr.message}`, 'error');
+                            throw err; // Throw original error from our hook
+                        }
+                    }
+                }
+                else {
+                    // No context, use standard require (for requires outside our execution context)
+                    logFn?.(`[RequireWrapper] No context available, using standard require for: "${id}"`);
+                    try {
+                        const result = parentReq(id);
+                        logFn?.(`[RequireWrapper] Successfully resolved: "${id}"`);
+                        return result;
+                    }
+                    catch (err) {
+                        logFn?.(`[RequireWrapper] Failed to resolve: "${id}" - ${err.message}`, 'error');
+                        throw err;
+                    }
+                }
+            };
+        }(parentRequire, this.log));
         // Create V8 context with Playwright globals
         // ai-wright will handle timeout extension internally (test.setTimeout or page.setDefaultTimeout)
         const contextGlobals = {
@@ -225,7 +371,7 @@ class PersistentExecutionContext {
             context: browserContext,
             // Node.js globals
             console,
-            require, // Normal require - hook will intercept resolution
+            require: requireWrapper, // Wrapper that ensures ModuleResolutionManager hook is triggered
             setTimeout,
             setInterval,
             clearTimeout,
@@ -324,13 +470,13 @@ class PersistentExecutionContext {
         // 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/tests as default
-            const testFileDir = this.testFileDir || (this.tempDir ? require('path').join(this.tempDir, 'tests') : undefined);
+            // Use the stored testFileDir if available, otherwise use tempDir directly (it's already the tests folder)
+            const testFileDir = this.testFileDir || this.tempDir;
             const context = {
                 tempDir: this.tempDir,
                 testFileDir: testFileDir
             };
-            await ModuleResolutionManager.runWithContext(context, async () => {
+            await ModuleResolutionManager.runWithContext({ ...context, log: this.log }, async () => {
                 if (!this.context) {
                     throw new Error('Context has been disposed');
                 }
@@ -394,11 +540,12 @@ function resolveFilePaths(tempDir, files) {
  * Overrides setInputFiles to resolve relative paths using the test file's directory
  */
 function applyFileUploadOverrides(page, tempDir, testFolderPath, log) {
-    // Use test folder path from DB (e.g., ["tests", "e2e"]) to construct test file directory
-    // This ensures paths like "../fixtures/file.pdf" resolve correctly regardless of test nesting
+    // tempDir is already the tests folder path (workspace root + tests folder setting)
+    // Use testFolderPath if provided (e.g., ["e2e"]) to construct test file directory within tests folder
+    // Otherwise use tempDir directly (don't append '/tests' again since tempDir is already the tests folder)
     const testFileDir = testFolderPath && testFolderPath.length > 0
         ? path.join(tempDir, ...testFolderPath)
-        : path.join(tempDir, 'tests'); // Fallback if not provided
+        : tempDir; // Use tempDir directly since it's already the tests folder path
     log(`Using test file directory for file path resolution: ${testFileDir}`);
     const originalSetInputFiles = page.setInputFiles.bind(page);
     const originalLocator = page.locator.bind(page);
@@ -624,7 +771,7 @@ class ExecutionService {
         const { expect, test } = require('@playwright/test');
         const { ai } = require('ai-wright');
         // Use shared context if provided, otherwise create new context
-        const persistentContext = sharedContext || new PersistentExecutionContext(page, expect, test, ai, browser, browserContext, options.tempDir);
+        const persistentContext = sharedContext || new PersistentExecutionContext(page, expect, test, ai, browser, browserContext, options.tempDir, this.log.bind(this));
         const isSharedContext = !!sharedContext;
         // Extract and execute imports from original script if provided
         this.log(`[executeStepsInPersistentContext] Checking imports: originalScript=${!!options.originalScript}, tempDir=${!!options.tempDir}`);
@@ -636,62 +783,22 @@ class ExecutionService {
                     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');
-                            }
-                        }
+                    // Determine test file directory for module resolution
+                    // tempDir is already the tests folder path (workspace root + tests folder setting)
+                    // If scriptFilePath is provided, use its directory; otherwise use tempDir as fallback
+                    let testFileDir;
+                    if (options.scriptFilePath) {
+                        // Use the directory of the actual script file for module resolution
+                        testFileDir = path.dirname(options.scriptFilePath);
+                        this.log(`Using script file directory for module resolution: ${testFileDir}`);
                     }
-                    catch (searchError) {
-                        this.log(`Could not search for test file: ${searchError.message}, using tests directory for module resolution`, 'warn');
+                    else if (options.tempDir) {
+                        // Fallback: use tempDir directly (it's already the tests folder path)
+                        testFileDir = options.tempDir;
+                        this.log(`Using tempDir for module resolution (script file path not available): ${testFileDir}`);
+                    }
+                    else {
+                        throw new Error('Either scriptFilePath or tempDir must be provided for module resolution');
                     }
                     // Store test file directory in context for module resolution
                     persistentContext.setTestFileDir(testFileDir);
@@ -767,7 +874,8 @@ class ExecutionService {
                         let importResults = {};
                         try {
                             if (options.tempDir) {
-                                importResults = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir }, async () => {
+                                importResults = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir, log: this.log.bind(this) }, async () => {
+                                    this.log(`[executeStepsInPersistentContext] Executing import capture code`);
                                     const script = new vm.Script(captureCode);
                                     const result = script.runInContext(context);
                                     return await result;
@@ -800,25 +908,36 @@ class ExecutionService {
                                     let moduleResult;
                                     if (modulePath && options.tempDir) {
                                         // Execute require for the specific module
-                                        moduleResult = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir }, async () => {
+                                        this.log(`[executeStepsInPersistentContext] About to call runWithContext for module: ${modulePath}`);
+                                        moduleResult = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir, log: this.log.bind(this) }, async () => {
+                                            this.log(`[executeStepsInPersistentContext] Inside runWithContext, executing require for module: ${modulePath}`);
+                                            this.log(`[DEBUG] About to execute require('${modulePath}') in VM context`);
                                             const script = new vm.Script(`(() => require('${modulePath}'))()`);
-                                            return script.runInContext(context);
+                                            const result = script.runInContext(context);
+                                            this.log(`[DEBUG] require('${modulePath}') completed in VM context`);
+                                            return result;
                                         });
                                     }
                                     else {
                                         // Execute the full require statement as-is
                                         if (options.tempDir) {
-                                            moduleResult = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir }, async () => {
+                                            this.log(`[executeStepsInPersistentContext] About to call runWithContext for require statement: ${requireStmt}`);
+                                            moduleResult = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir, log: this.log.bind(this) }, async () => {
+                                                this.log(`[executeStepsInPersistentContext] Inside runWithContext, executing require statement: ${requireStmt}`);
+                                                this.log(`[DEBUG] About to execute require statement in VM context: ${requireStmt}`);
                                                 // 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);
+                                                    const result = script.runInContext(context);
+                                                    this.log(`[DEBUG] require statement completed in VM context`);
+                                                    return result;
                                                 }
                                                 else {
                                                     // Side-effect import - just execute
                                                     const script = new vm.Script(`(() => { ${requireStmt}; return null; })()`);
                                                     script.runInContext(context);
+                                                    this.log(`[DEBUG] Side-effect require statement completed in VM context`);
                                                     return null;
                                                 }
                                             });
@@ -1252,7 +1371,8 @@ class ExecutionService {
                     mode: 'RUN_EXACTLY',
                     jobId: request.jobId,
                     tempDir: request.tempDir,
-                    originalScript: request.script // AST will extract statements from this
+                    originalScript: request.script, // AST will extract statements from this
+                    scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1305,7 +1425,8 @@ class ExecutionService {
                     mode: 'RUN_EXACTLY',
                     jobId: request.jobId,
                     tempDir: request.tempDir,
-                    originalScript: request.script // AST will extract statements from this
+                    originalScript: request.script, // AST will extract statements from this
+                    scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1421,7 +1542,8 @@ class ExecutionService {
                 jobId: request.jobId,
                 model,
                 tempDir: request.tempDir,
-                originalScript: request.script // Pass original script for import extraction
+                originalScript: request.script, // Pass original script for import extraction
+                scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
             });
             const updatedSteps = result.updatedSteps || steps;
             const allStepsSuccessful = result.success;
@@ -1907,7 +2029,8 @@ class ExecutionService {
                                 jobId: jobId,
                                 tempDir: request.tempDir,
                                 originalScript: testScript, // For module resolution (imports)
-                                model: request.model
+                                model: request.model,
+                                scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
                             }, suiteContext // Pass shared context
                             );
                             if (!result.success) {
@@ -2176,11 +2299,13 @@ class ExecutionService {
             const hookContext = sharedContext || new PersistentExecutionContext(page, expect, test, ai, browser, context, tempDir);
             try {
                 // Execute using step-wise execution infrastructure to trigger callbacks
+                // Note: Hooks don't have a scriptFilePath, so tempDir will be used as fallback
                 const result = await this.executeStepsInPersistentContext(steps, page, browser, context, {
                     mode: types_1.ExecutionMode.RUN_EXACTLY,
                     jobId: jobId,
                     tempDir: tempDir,
                     originalScript: hookScript
+                    // No scriptFilePath for hooks - will use tempDir as fallback
                 }, hookContext // Pass shared context
                 );
                 if (!result.success) {