testchimp-runner-core 0.0.21 → 0.0.23

package/src/script-utils.ts

@@ -115,7 +115,14 @@ export function addTestChimpComment(script: string, repairAdvice?: string, hasht
  */
 export function generateTestScript(
   testName: string, 
-  steps: Array<{ stepNumber: number; description: string; playwrightCommand?: string; success?: boolean }>,
+  steps: Array<{ 
+    stepNumber: number; 
+    description: string; 
+    playwrightCommand?: string; 
+    playwrightCommands?: string[];
+    success?: boolean;
+    error?: string;
+  }>,
   repairAdvice?: string,
   hashtags?: string[]
 ): string {
@@ -134,10 +141,48 @@ export function generateTestScript(
   
   // Add steps
   for (const step of steps) {
-    const status = step.success === false ? ' [FAILED]' : '';
-    scriptLines.push(`  // ${step.description}${status}`);
-    if (step.playwrightCommand && step.success !== false) {
-      scriptLines.push(`  ${step.playwrightCommand}`);
+    // Check if step was skipped
+    const isSkipped = step.error?.includes('Skipped due to') || 
+                     (step.success === false && (!step.playwrightCommand && (!step.playwrightCommands || step.playwrightCommands.length === 0)));
+    
+    if (isSkipped) {
+      // Step was skipped due to previous failures
+      scriptLines.push(`  // ${step.description} [SKIPPED]`);
+    } else if (step.success === false) {
+      // Step failed - only show command if this step actually attempted any commands
+      if (step.playwrightCommands && step.playwrightCommands.length > 0) {
+        // Failed after attempting commands - show them
+        scriptLines.push(`  // ${step.description} [FAILED]`);
+        step.playwrightCommands.forEach((cmd: string) => {
+          scriptLines.push(`  // Attempted: ${cmd}`);
+        });
+      } else if (step.playwrightCommand) {
+        // Single command attempted (backward compatibility)
+        scriptLines.push(`  // ${step.description} [FAILED] - ${step.playwrightCommand}`);
+      } else {
+        // Failed without attempting any commands
+        scriptLines.push(`  // ${step.description} [FAILED]`);
+      }
+    } else {
+      // Step succeeded or in progress
+      // Only add comment if step has commands to show
+      const hasCommands = (step.playwrightCommands && step.playwrightCommands.length > 0) || step.playwrightCommand;
+      
+      if (hasCommands) {
+        scriptLines.push(`  // ${step.description}`);
+        
+        // Handle multiple commands per step
+        if (step.playwrightCommands && step.playwrightCommands.length > 0) {
+          // Multiple commands - output all of them
+          step.playwrightCommands.forEach((cmd: string) => {
+            scriptLines.push(`  ${cmd}`);
+          });
+        } else if (step.playwrightCommand) {
+          // Single command (backward compatibility)
+          scriptLines.push(`  ${step.playwrightCommand}`);
+        }
+      }
+      // If step has no commands, skip it entirely (work was done in previous step)
     }
   }
   

package/src/types.ts

@@ -99,13 +99,25 @@ export interface ScenarioResponse {
   error?: string;
 }
 
+/**
+ * Individual sub-action within a step
+ */
+export interface SubAction {
+  command: string;
+  success: boolean;
+  error?: string;
+  retryCount: number;
+}
+
 /**
  * Individual scenario step
  */
 export interface ScenarioStep {
   stepNumber: number;
   description: string;
-  playwrightCommand?: string;
+  playwrightCommand?: string; // For backward compatibility - last successful command or aggregated command
+  playwrightCommands?: string[]; // Multiple commands for complex steps
+  subActions?: SubAction[]; // Detailed tracking of all sub-actions
   success?: boolean;
   error?: string;
   retryCount?: number;

package/src/utils/browser-utils.ts

@@ -8,14 +8,24 @@ const { build } = esbuild;
  * Initialize browser with Playwright configuration
  * @param playwrightConfig - JavaScript config file content (playwright.config.js)
  * @param headless - Override headless mode (optional)
+ * @param playwrightConfigFilePath - Path to playwright config file (optional)
+ * @param logger - Optional logger callback for capturing logs
  * @returns Browser, context, and page instances
  */
 export async function initializeBrowser(
   playwrightConfigContent?: string, 
   headless?: boolean,
-  playwrightConfigFilePath?: string
+  playwrightConfigFilePath?: string,
+  logger?: (message: string, level?: 'log' | 'error' | 'warn') => void
 ): Promise<{ browser: any; context: any; page: any }> {
-  console.log('Initializing browser with Playwright');
+  const log = (message: string, level: 'log' | 'error' | 'warn' = 'log') => {
+    if (logger) {
+      logger(message, level);
+    }
+    // No console fallback - logs are routed to consumer
+  };
+  
+  log('Initializing browser with Playwright');
   
   // Import Playwright modules dynamically
   const playwright = await import('playwright');
@@ -25,11 +35,11 @@ export async function initializeBrowser(
   
   // Use Playwright config content if provided
   if (playwrightConfigContent) {
-    console.log('Using provided Playwright config content');
+    log('Using provided Playwright config content');
     
     try {
       // Transpile the config content in-memory and evaluate it
-      console.log(`Transpiling config content (${playwrightConfigContent.length} characters)`);
+      log(`Transpiling config content (${playwrightConfigContent.length} characters)`);
       
       const result = await build({
         stdin: {
@@ -55,25 +65,25 @@ export async function initializeBrowser(
       }
 
       const transpiledCode = result.outputFiles[0].text;
-      console.log(`Transpilation complete. Generated ${transpiledCode.length} characters of code`);
+      log(`Transpilation complete. Generated ${transpiledCode.length} characters of code`);
       
       // Evaluate the transpiled code in a safe context
       const loadedConfig = eval(transpiledCode);
-      console.log('Loaded config object:', loadedConfig);
-      console.log('Config type:', typeof loadedConfig);
-      console.log('Config keys:', loadedConfig ? Object.keys(loadedConfig) : 'null/undefined');
+      log(`Loaded config object: ${JSON.stringify(loadedConfig)}`);
+      log(`Config type: ${typeof loadedConfig}`);
+      log(`Config keys: ${loadedConfig ? Object.keys(loadedConfig).join(', ') : 'null/undefined'}`);
       
       // Get the actual config from the default export (ES module transpiled to CommonJS)
       const actualConfig = loadedConfig.default || loadedConfig;
       
       if (actualConfig && typeof actualConfig === 'object') {
-        console.log('Successfully loaded Playwright config from content');
-        console.log(`Config keys: ${Object.keys(actualConfig).join(', ')}`);
+        log('Successfully loaded Playwright config from content');
+        log(`Config keys: ${Object.keys(actualConfig).join(', ')}`);
         
         // Extract context options from the config
         if (actualConfig.use && actualConfig.use.contextOptions) {
           contextOptions = { ...contextOptions, ...actualConfig.use.contextOptions };
-          console.log('Applied context options from config');
+          log('Applied context options from config');
         }
         
         // Apply other config settings
@@ -81,113 +91,113 @@ export async function initializeBrowser(
           // Override headless mode if specified in config and not explicitly overridden
           if (headless === undefined) {
             headless = actualConfig.use.headless;
-            console.log(`Using headless mode from config: ${headless}`);
+            log(`Using headless mode from config: ${headless}`);
           }
         }
         
         // Apply timeout settings
         if (actualConfig.use && actualConfig.use.actionTimeout) {
-          console.log(`Using action timeout from config: ${actualConfig.use.actionTimeout}ms`);
+          log(`Using action timeout from config: ${actualConfig.use.actionTimeout}ms`);
         }
         
         // Apply viewport settings
         if (actualConfig.use && actualConfig.use.viewport) {
           contextOptions.viewport = actualConfig.use.viewport;
-          console.log(`Using viewport from config: ${JSON.stringify(actualConfig.use.viewport)}`);
+          log(`Using viewport from config: ${JSON.stringify(actualConfig.use.viewport)}`);
         }
         
         // Apply user agent
         if (actualConfig.use && actualConfig.use.userAgent) {
           contextOptions.userAgent = actualConfig.use.userAgent;
-          console.log(`Using user agent from config: ${actualConfig.use.userAgent}`);
+          log(`Using user agent from config: ${actualConfig.use.userAgent}`);
         }
         
         // Apply other context options
         if (actualConfig.use && actualConfig.use.extraHTTPHeaders) {
           contextOptions.extraHTTPHeaders = actualConfig.use.extraHTTPHeaders;
-          console.log(`Using extra HTTP headers from config`);
+          log(`Using extra HTTP headers from config`);
         }
         
         if (actualConfig.use && actualConfig.use.locale) {
           contextOptions.locale = actualConfig.use.locale;
-          console.log(`Using locale from config: ${actualConfig.use.locale}`);
+          log(`Using locale from config: ${actualConfig.use.locale}`);
         }
         
         if (actualConfig.use && actualConfig.use.timezoneId) {
           contextOptions.timezoneId = actualConfig.use.timezoneId;
-          console.log(`Using timezone from config: ${actualConfig.use.timezoneId}`);
+          log(`Using timezone from config: ${actualConfig.use.timezoneId}`);
         }
         
         if (actualConfig.use && actualConfig.use.geolocation) {
           contextOptions.geolocation = actualConfig.use.geolocation;
-          console.log(`Using geolocation from config: ${JSON.stringify(actualConfig.use.geolocation)}`);
+          log(`Using geolocation from config: ${JSON.stringify(actualConfig.use.geolocation)}`);
         }
         
         if (actualConfig.use && actualConfig.use.permissions) {
           contextOptions.permissions = actualConfig.use.permissions;
-          console.log(`Using permissions from config: ${JSON.stringify(actualConfig.use.permissions)}`);
+          log(`Using permissions from config: ${JSON.stringify(actualConfig.use.permissions)}`);
         }
         
         if (actualConfig.use && actualConfig.use.colorScheme) {
           contextOptions.colorScheme = actualConfig.use.colorScheme;
-          console.log(`Using color scheme from config: ${actualConfig.use.colorScheme}`);
+          log(`Using color scheme from config: ${actualConfig.use.colorScheme}`);
         }
         
         if (actualConfig.use && actualConfig.use.reducedMotion) {
           contextOptions.reducedMotion = actualConfig.use.reducedMotion;
-          console.log(`Using reduced motion from config: ${actualConfig.use.reducedMotion}`);
+          log(`Using reduced motion from config: ${actualConfig.use.reducedMotion}`);
         }
         
         if (actualConfig.use && actualConfig.use.forcedColors) {
           contextOptions.forcedColors = actualConfig.use.forcedColors;
-          console.log(`Using forced colors from config: ${actualConfig.use.forcedColors}`);
+          log(`Using forced colors from config: ${actualConfig.use.forcedColors}`);
         }
         
         if (actualConfig.use && actualConfig.use.acceptDownloads) {
           contextOptions.acceptDownloads = actualConfig.use.acceptDownloads;
-          console.log(`Using accept downloads from config: ${actualConfig.use.acceptDownloads}`);
+          log(`Using accept downloads from config: ${actualConfig.use.acceptDownloads}`);
         }
         
         if (actualConfig.use && actualConfig.use.bypassCSP) {
           contextOptions.bypassCSP = actualConfig.use.bypassCSP;
-          console.log(`Using bypass CSP from config: ${actualConfig.use.bypassCSP}`);
+          log(`Using bypass CSP from config: ${actualConfig.use.bypassCSP}`);
         }
         
         if (actualConfig.use && actualConfig.use.javaScriptEnabled) {
           contextOptions.javaScriptEnabled = actualConfig.use.javaScriptEnabled;
-          console.log(`Using JavaScript enabled from config: ${actualConfig.use.javaScriptEnabled}`);
+          log(`Using JavaScript enabled from config: ${actualConfig.use.javaScriptEnabled}`);
         }
         
         if (actualConfig.use && actualConfig.use.ignoreHTTPSErrors) {
           contextOptions.ignoreHTTPSErrors = actualConfig.use.ignoreHTTPSErrors;
-          console.log(`Using ignore HTTPS errors from config: ${actualConfig.use.ignoreHTTPSErrors}`);
+          log(`Using ignore HTTPS errors from config: ${actualConfig.use.ignoreHTTPSErrors}`);
         }
         
-        console.log(`Final context options: ${JSON.stringify(contextOptions, null, 2)}`);
+        log(`Final context options: ${JSON.stringify(contextOptions, null, 2)}`);
       } else {
-        console.log('Config loaded but no valid configuration found');
+        log('Config loaded but no valid configuration found');
       }
     } catch (error) {
-      console.error(`Error transpiling config content: ${error}`);
-      console.log('Falling back to default configuration');
+      log(`Error transpiling config content: ${error}`, 'error');
+      log('Falling back to default configuration');
     }
   } else if (playwrightConfigFilePath) {
     // Fallback to file path if no content provided (for backward compatibility)
-    console.log('No config content provided, falling back to file path');
+    log('No config content provided, falling back to file path');
     // Resolve the path - it might be relative or absolute
     const resolvedPath = path.isAbsolute(String(playwrightConfigFilePath)) 
       ? String(playwrightConfigFilePath) 
       : path.resolve(String(process.cwd()), String(playwrightConfigFilePath));
     
-    console.log(`Looking for Playwright config at: ${resolvedPath}`);
-    console.log(`File exists: ${fs.existsSync(String(resolvedPath))}`);
+    log(`Looking for Playwright config at: ${resolvedPath}`);
+    log(`File exists: ${fs.existsSync(String(resolvedPath))}`);
     
     if (fs.existsSync(String(resolvedPath))) {
-      console.log(`Loading Playwright config from: ${resolvedPath}`);
+      log(`Loading Playwright config from: ${resolvedPath}`);
 
       try {
         // Transpile the config in-memory and evaluate it
-        console.log(`Transpiling config in-memory from: ${resolvedPath}`);
+        log(`Transpiling config in-memory from: ${resolvedPath}`);
         
         const result = await build({
           entryPoints: [String(resolvedPath)],
@@ -210,50 +220,50 @@ export async function initializeBrowser(
         }
 
         const transpiledCode = result.outputFiles[0].text;
-        console.log(`Transpilation complete. Generated ${transpiledCode.length} characters of code`);
+        log(`Transpilation complete. Generated ${transpiledCode.length} characters of code`);
         
         // Evaluate the transpiled code in a safe context
         const loadedConfig = eval(transpiledCode);
-        console.log('Loaded config object:', loadedConfig);
-        console.log('Config type:', typeof loadedConfig);
-        console.log('Config keys:', loadedConfig ? Object.keys(loadedConfig) : 'null/undefined');
+        log(`Loaded config object: ${JSON.stringify(loadedConfig)}`);
+        log(`Config type: ${typeof loadedConfig}`);
+        log(`Config keys: ${loadedConfig ? Object.keys(loadedConfig).join(', ') : 'null/undefined'}`);
         
         // Get the actual config from the default export (ES module transpiled to CommonJS)
         const actualConfig = loadedConfig.default || loadedConfig;
-        console.log('Actual config:', actualConfig);
-        console.log('Actual config keys:', actualConfig ? Object.keys(actualConfig) : 'null/undefined');
+        log(`Actual config: ${JSON.stringify(actualConfig)}`);
+        log(`Actual config keys: ${actualConfig ? Object.keys(actualConfig).join(', ') : 'null/undefined'}`);
         
         if (!actualConfig) {
-          console.log('Config import did not return a valid config; using defaults');
+          log('Config import did not return a valid config; using defaults');
         } else {
           // Apply global use options
           if (actualConfig.use) {
             contextOptions = { ...actualConfig.use };
-            console.log('Applied context options from Playwright config:', contextOptions);
+            log('Applied context options from Playwright config:', contextOptions);
           } else {
-            console.log('No use property found in config');
+            log('No use property found in config');
           }
           // Apply first project overrides if present
           if (Array.isArray(actualConfig.projects) && actualConfig.projects.length > 0) {
             const firstProject = actualConfig.projects[0];
             if (firstProject && firstProject.use) {
               contextOptions = { ...contextOptions, ...firstProject.use };
-              console.log('Applied project-specific options:', firstProject.use);
+              log('Applied project-specific options:', firstProject.use);
             }
           } else {
-            console.log('No projects found in config');
+            log('No projects found in config');
           }
         }
 
         // No cleanup needed - we used in-memory transpilation
 
       } catch (error) {
-        console.log(`Failed to load Playwright config via esbuild/import: ${error}`);
-        console.log('Using default browser settings');
+        log(`Failed to load Playwright config via esbuild/import: ${error}`);
+        log('Using default browser settings');
       }
     } else {
-      console.log(`Playwright config file not found at: ${resolvedPath}`);
-      console.log('Using default browser settings');
+      log(`Playwright config file not found at: ${resolvedPath}`);
+      log('Using default browser settings');
     }
   }
   
@@ -274,3 +284,65 @@ export async function initializeBrowser(
 
   return { browser, context, page };
 }
+
+/**
+ * Capture an optimized screenshot for vision API calls
+ * - Sets temporary viewport to reduce image size
+ * - Uses JPEG compression
+ * - Returns base64 data URL
+ * 
+ * @param page - Playwright page instance
+ * @param options - Screenshot options
+ * @param log - Optional logger callback
+ * @returns Data URL string (data:image/jpeg;base64,...)
+ */
+export async function captureOptimizedScreenshot(
+  page: any,
+  options: {
+    quality?: number; // JPEG quality (0-100), default 60 (optimal for vision API)
+    width?: number;   // Viewport width, default 800
+    height?: number;  // Viewport height, default 800
+    timeout?: number; // Screenshot timeout in ms, default 10000
+  } = {},
+  log?: (message: string) => void
+): Promise<string> {
+  const {
+    quality = 60, // Sweet spot: 50% smaller than quality 85, minimal visual loss
+    width = 800,
+    height = 800,
+    timeout = 10000
+  } = options;
+
+  // Save current viewport
+  const currentViewport = page.viewportSize();
+  
+  // Set smaller viewport to reduce screenshot size
+  await page.setViewportSize({ width, height });
+  
+  try {
+    const screenshotBuffer = await page.screenshot({
+      type: 'jpeg', // JPEG for smaller file size
+      quality,      // Compression quality
+      fullPage: false, // Viewport only
+      timeout       // Timeout for slow pages
+    });
+    
+    // Convert Buffer to base64 string explicitly
+    const screenshotBase64 = screenshotBuffer.toString('base64');
+    
+    if (log) {
+      const sizeKB = Math.round(screenshotBase64.length * 0.75 / 1024);
+      log(`  📏 Screenshot size: ~${sizeKB}KB (base64)`);
+    }
+    
+    // Construct data URL for vision API
+    const imageDataUrl = `data:image/jpeg;base64,${screenshotBase64}`;
+    
+    return imageDataUrl;
+  } finally {
+    // Always restore original viewport, even if screenshot fails
+    if (currentViewport) {
+      await page.setViewportSize(currentViewport);
+    }
+  }
+}