testchimp-runner-core 0.1.8 → 0.1.10

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;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"}
+{"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"}

package/dist/execution-service.js

@@ -56,13 +56,6 @@ 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)
      */
@@ -84,7 +77,7 @@ class ModuleResolutionManager {
             const nodeModulesDir = path.dirname(runnerCoreDir);
             if (fs.existsSync(nodeModulesDir) && path.basename(nodeModulesDir) === 'node_modules') {
                 this.scriptserviceNodeModules = nodeModulesDir;
-                // Note: This runs at module load time, before we have a logger, so we can't log here
+                console.log(`[ModuleResolution] Cached scriptservice node_modules: ${this.scriptserviceNodeModules}`);
             }
         }
         catch (e) {
@@ -94,14 +87,12 @@ 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
@@ -109,27 +100,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
-                log(`[ModuleResolution] Resolving relative import: "${request}"`);
-                log(`[ModuleResolution]   resolveDir: ${resolveDir}`);
+                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);
-                log(`[ModuleResolution]   resolvedPath: ${resolvedPath}`);
+                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)) {
-                            log(`[ModuleResolution]   ✓ Found file: ${testPath}`);
+                            console.log(`[ModuleResolution]   ✓ Found file: ${testPath}`);
                             return testPath;
                         }
                         else {
-                            log(`[ModuleResolution]   ✗ File does not exist: ${testPath}`);
+                            console.log(`[ModuleResolution]   ✗ File does not exist: ${testPath}`);
                         }
                     }
                     catch (e) {
-                        log(`[ModuleResolution]   ✗ Error checking file: ${testPath} - ${e}`, 'error');
+                        console.log(`[ModuleResolution]   ✗ Error checking file: ${testPath} - ${e}`);
                     }
                 }
                 // If no extension worked, try original resolution
@@ -153,95 +144,45 @@ class ModuleResolutionManager {
                 }
             }
             // For non-relative imports (like 'ai-wright', '@playwright/test'), use standard Node.js resolution
-            // 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}`);
-            }
+            // 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 now search workspace root's node_modules first)
-                log(`[ModuleResolution]   Attempting resolution with modified paths...`);
+                // Use original Node.js resolution (will find from node_modules)
                 const resolved = ModuleResolutionManager.originalResolveFilename.call(this, request, parent, isMain, options);
-                log(`[ModuleResolution]   ✓ Resolved to: ${resolved}`);
-                // Restore original _nodeModulePaths
-                if (nodeModulePathsModified) {
-                    Module._nodeModulePaths = originalNodeModulePaths;
-                }
+                console.log(`[ModuleResolution]   ✓ Resolved to: ${resolved}`);
                 return resolved;
             }
             catch (err) {
-                // Restore original _nodeModulePaths before handling error
-                if (nodeModulePathsModified) {
-                    Module._nodeModulePaths = originalNodeModulePaths;
-                }
-                log(`[ModuleResolution]   ✗ Failed to resolve: ${err.message}`, 'error');
-                // Fallback: try scriptservice's node_modules (for server-side usage)
+                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) {
-                    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
-                    }
+                    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;
                 }
-                throw err;
             }
         };
         this.hookInstalled = true;
@@ -253,9 +194,6 @@ 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);
     }
 }
@@ -268,97 +206,13 @@ 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, log) {
+    constructor(page, expect, test, ai, browser, browserContext, tempDir) {
         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 = {
@@ -371,7 +225,7 @@ class PersistentExecutionContext {
             context: browserContext,
             // Node.js globals
             console,
-            require: requireWrapper, // Wrapper that ensures ModuleResolutionManager hook is triggered
+            require, // Normal require - hook will intercept resolution
             setTimeout,
             setInterval,
             clearTimeout,
@@ -470,13 +324,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 directly (it's already the tests folder)
-            const testFileDir = this.testFileDir || this.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);
             const context = {
                 tempDir: this.tempDir,
                 testFileDir: testFileDir
             };
-            await ModuleResolutionManager.runWithContext({ ...context, log: this.log }, async () => {
+            await ModuleResolutionManager.runWithContext(context, async () => {
                 if (!this.context) {
                     throw new Error('Context has been disposed');
                 }
@@ -540,12 +394,11 @@ function resolveFilePaths(tempDir, files) {
  * Overrides setInputFiles to resolve relative paths using the test file's directory
  */
 function applyFileUploadOverrides(page, tempDir, testFolderPath, log) {
-    // 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)
+    // 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
     const testFileDir = testFolderPath && testFolderPath.length > 0
         ? path.join(tempDir, ...testFolderPath)
-        : tempDir; // Use tempDir directly since it's already the tests folder path
+        : path.join(tempDir, 'tests'); // Fallback if not provided
     log(`Using test file directory for file path resolution: ${testFileDir}`);
     const originalSetInputFiles = page.setInputFiles.bind(page);
     const originalLocator = page.locator.bind(page);
@@ -771,7 +624,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, this.log.bind(this));
+        const persistentContext = sharedContext || new PersistentExecutionContext(page, expect, test, ai, browser, browserContext, options.tempDir);
         const isSharedContext = !!sharedContext;
         // Extract and execute imports from original script if provided
         this.log(`[executeStepsInPersistentContext] Checking imports: originalScript=${!!options.originalScript}, tempDir=${!!options.tempDir}`);
@@ -783,22 +636,62 @@ 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));
-                    // 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}`);
-                    }
-                    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}`);
+                    // 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');
+                            }
+                        }
                     }
-                    else {
-                        throw new Error('Either scriptFilePath or tempDir must be provided for module resolution');
+                    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.setTestFileDir(testFileDir);
@@ -874,8 +767,7 @@ class ExecutionService {
                         let importResults = {};
                         try {
                             if (options.tempDir) {
-                                importResults = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir, log: this.log.bind(this) }, async () => {
-                                    this.log(`[executeStepsInPersistentContext] Executing import capture code`);
+                                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;
@@ -908,36 +800,25 @@ class ExecutionService {
                                     let moduleResult;
                                     if (modulePath && options.tempDir) {
                                         // Execute require for the specific module
-                                        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`);
+                                        moduleResult = await ModuleResolutionManager.runWithContext({ tempDir: options.tempDir, testFileDir: context.__testFileDir }, async () => {
                                             const script = new vm.Script(`(() => require('${modulePath}'))()`);
-                                            const result = script.runInContext(context);
-                                            this.log(`[DEBUG] require('${modulePath}') completed in VM context`);
-                                            return result;
+                                            return script.runInContext(context);
                                         });
                                     }
                                     else {
                                         // Execute the full require statement as-is
                                         if (options.tempDir) {
-                                            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}`);
+                                            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]}; })()`);
-                                                    const result = script.runInContext(context);
-                                                    this.log(`[DEBUG] require statement completed in VM context`);
-                                                    return result;
+                                                    return script.runInContext(context);
                                                 }
                                                 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;
                                                 }
                                             });
@@ -1371,8 +1252,7 @@ class ExecutionService {
                     mode: 'RUN_EXACTLY',
                     jobId: request.jobId,
                     tempDir: request.tempDir,
-                    originalScript: request.script, // AST will extract statements from this
-                    scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
+                    originalScript: request.script // AST will extract statements from this
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1425,8 +1305,7 @@ class ExecutionService {
                     mode: 'RUN_EXACTLY',
                     jobId: request.jobId,
                     tempDir: request.tempDir,
-                    originalScript: request.script, // AST will extract statements from this
-                    scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
+                    originalScript: request.script // AST will extract statements from this
                 });
                 // LIFECYCLE: afterEndTest
                 if (this.progressReporter?.afterEndTest) {
@@ -1542,8 +1421,7 @@ class ExecutionService {
                 jobId: request.jobId,
                 model,
                 tempDir: request.tempDir,
-                originalScript: request.script, // Pass original script for import extraction
-                scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
+                originalScript: request.script // Pass original script for import extraction
             });
             const updatedSteps = result.updatedSteps || steps;
             const allStepsSuccessful = result.success;
@@ -2029,8 +1907,7 @@ class ExecutionService {
                                 jobId: jobId,
                                 tempDir: request.tempDir,
                                 originalScript: testScript, // For module resolution (imports)
-                                model: request.model,
-                                scriptFilePath: request.scriptFilePath // Pass script file path for module resolution
+                                model: request.model
                             }, suiteContext // Pass shared context
                             );
                             if (!result.success) {
@@ -2299,13 +2176,11 @@ 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) {