testchimp-runner-core 0.0.35 → 0.0.36

package/src/utils/browser-utils.ts

@@ -1,348 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-const esbuild = require('esbuild');
-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,
-  logger?: (message: string, level?: 'log' | 'error' | 'warn') => void
-): Promise<{ browser: any; context: any; page: any }> {
-  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');
-  const { chromium, firefox, webkit } = playwright;
-  
-  let contextOptions: any = {};
-  
-  // Use Playwright config content if provided
-  if (playwrightConfigContent) {
-    log('Using provided Playwright config content');
-    
-    try {
-      // Transpile the config content in-memory and evaluate it
-      log(`Transpiling config content (${playwrightConfigContent.length} characters)`);
-      
-      const result = await build({
-        stdin: {
-          contents: playwrightConfigContent,
-          resolveDir: String(process.cwd()),
-        },
-        bundle: true,
-        platform: 'node',
-        format: 'cjs',
-        sourcemap: false,
-        target: 'node18',
-        logLevel: 'silent',
-        write: false, // Don't write to file, get the result in memory
-        external: [
-          '@playwright/test',
-          'playwright',
-          'playwright-core'
-        ]
-      });
-
-      if (!result.outputFiles || result.outputFiles.length === 0) {
-        throw new Error('esbuild failed to generate output');
-      }
-
-      const transpiledCode = result.outputFiles[0].text;
-      log(`Transpilation complete. Generated ${transpiledCode.length} characters of code`);
-      
-      // Evaluate the transpiled code in a safe context
-      const loadedConfig = eval(transpiledCode);
-      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') {
-        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 };
-          log('Applied context options from config');
-        }
-        
-        // Apply other config settings
-        if (actualConfig.use && actualConfig.use.headless !== undefined) {
-          // Override headless mode if specified in config and not explicitly overridden
-          if (headless === undefined) {
-            headless = actualConfig.use.headless;
-            log(`Using headless mode from config: ${headless}`);
-          }
-        }
-        
-        // Apply timeout settings
-        if (actualConfig.use && actualConfig.use.actionTimeout) {
-          log(`Using action timeout from config: ${actualConfig.use.actionTimeout}ms`);
-        }
-        
-        // Apply viewport settings
-        if (actualConfig.use && actualConfig.use.viewport) {
-          contextOptions.viewport = 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;
-          log(`Using user agent from config: ${actualConfig.use.userAgent}`);
-        }
-        
-        // Apply other context options
-        if (actualConfig.use && actualConfig.use.extraHTTPHeaders) {
-          contextOptions.extraHTTPHeaders = actualConfig.use.extraHTTPHeaders;
-          log(`Using extra HTTP headers from config`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.locale) {
-          contextOptions.locale = actualConfig.use.locale;
-          log(`Using locale from config: ${actualConfig.use.locale}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.timezoneId) {
-          contextOptions.timezoneId = actualConfig.use.timezoneId;
-          log(`Using timezone from config: ${actualConfig.use.timezoneId}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.geolocation) {
-          contextOptions.geolocation = actualConfig.use.geolocation;
-          log(`Using geolocation from config: ${JSON.stringify(actualConfig.use.geolocation)}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.permissions) {
-          contextOptions.permissions = actualConfig.use.permissions;
-          log(`Using permissions from config: ${JSON.stringify(actualConfig.use.permissions)}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.colorScheme) {
-          contextOptions.colorScheme = actualConfig.use.colorScheme;
-          log(`Using color scheme from config: ${actualConfig.use.colorScheme}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.reducedMotion) {
-          contextOptions.reducedMotion = actualConfig.use.reducedMotion;
-          log(`Using reduced motion from config: ${actualConfig.use.reducedMotion}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.forcedColors) {
-          contextOptions.forcedColors = actualConfig.use.forcedColors;
-          log(`Using forced colors from config: ${actualConfig.use.forcedColors}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.acceptDownloads) {
-          contextOptions.acceptDownloads = actualConfig.use.acceptDownloads;
-          log(`Using accept downloads from config: ${actualConfig.use.acceptDownloads}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.bypassCSP) {
-          contextOptions.bypassCSP = actualConfig.use.bypassCSP;
-          log(`Using bypass CSP from config: ${actualConfig.use.bypassCSP}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.javaScriptEnabled) {
-          contextOptions.javaScriptEnabled = actualConfig.use.javaScriptEnabled;
-          log(`Using JavaScript enabled from config: ${actualConfig.use.javaScriptEnabled}`);
-        }
-        
-        if (actualConfig.use && actualConfig.use.ignoreHTTPSErrors) {
-          contextOptions.ignoreHTTPSErrors = actualConfig.use.ignoreHTTPSErrors;
-          log(`Using ignore HTTPS errors from config: ${actualConfig.use.ignoreHTTPSErrors}`);
-        }
-        
-        log(`Final context options: ${JSON.stringify(contextOptions, null, 2)}`);
-      } else {
-        log('Config loaded but no valid configuration found');
-      }
-    } catch (error) {
-      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)
-    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));
-    
-    log(`Looking for Playwright config at: ${resolvedPath}`);
-    log(`File exists: ${fs.existsSync(String(resolvedPath))}`);
-    
-    if (fs.existsSync(String(resolvedPath))) {
-      log(`Loading Playwright config from: ${resolvedPath}`);
-
-      try {
-        // Transpile the config in-memory and evaluate it
-        log(`Transpiling config in-memory from: ${resolvedPath}`);
-        
-        const result = await build({
-          entryPoints: [String(resolvedPath)],
-          bundle: true,
-          platform: 'node',
-          format: 'cjs',
-          sourcemap: false,
-          target: 'node18',
-          logLevel: 'silent',
-          write: false, // Don't write to file, get the result in memory
-          external: [
-            '@playwright/test',
-            'playwright',
-            'playwright-core'
-          ]
-        });
-
-        if (!result.outputFiles || result.outputFiles.length === 0) {
-          throw new Error('esbuild failed to generate output');
-        }
-
-        const transpiledCode = result.outputFiles[0].text;
-        log(`Transpilation complete. Generated ${transpiledCode.length} characters of code`);
-        
-        // Evaluate the transpiled code in a safe context
-        const loadedConfig = eval(transpiledCode);
-        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;
-        log(`Actual config: ${JSON.stringify(actualConfig)}`);
-        log(`Actual config keys: ${actualConfig ? Object.keys(actualConfig).join(', ') : 'null/undefined'}`);
-        
-        if (!actualConfig) {
-          log('Config import did not return a valid config; using defaults');
-        } else {
-          // Apply global use options
-          if (actualConfig.use) {
-            contextOptions = { ...actualConfig.use };
-            log('Applied context options from Playwright config:', contextOptions);
-          } else {
-            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 };
-              log('Applied project-specific options:', firstProject.use);
-            }
-          } else {
-            log('No projects found in config');
-          }
-        }
-
-        // No cleanup needed - we used in-memory transpilation
-
-      } catch (error) {
-        log(`Failed to load Playwright config via esbuild/import: ${error}`);
-        log('Using default browser settings');
-      }
-    } else {
-      log(`Playwright config file not found at: ${resolvedPath}`);
-      log('Using default browser settings');
-    }
-  }
-  
-  // Use chromium as default browser
-  const browser = await chromium.launch({ 
-    headless: headless !== undefined ? headless : false 
-  });
-  
-  // Create context with config options or defaults
-  const context = await browser.newContext(contextOptions);
-  const page = await context.newPage();
-  
-  // Set default timeout to 5 seconds (unless overridden by playwright config)
-  if (!contextOptions.timeout) {
-    context.setDefaultTimeout(5000);
-    page.setDefaultTimeout(5000);
-  }
-
-  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);
-    }
-  }
-}

package/src/utils/coordinate-converter.ts

@@ -1,162 +0,0 @@
-/**
- * Coordinate Converter Utility
- * Converts percentage-based coordinates to pixel coordinates and generates Playwright commands
- */
-
-import { CoordinateAction } from '../orchestrator/types';
-
-export class CoordinateConverter {
-  
-  /**
-   * Convert percentage coordinates to actual pixel coordinates
-   */
-  static percentToPixels(
-    xPercent: number,
-    yPercent: number,
-    viewportWidth: number,
-    viewportHeight: number
-  ): { x: number; y: number } {
-    return {
-      x: Math.round((xPercent / 100) * viewportWidth),
-      y: Math.round((yPercent / 100) * viewportHeight)
-    };
-  }
-  
-  /**
-   * Get viewport dimensions from page
-   */
-  static async getViewportSize(page: any): Promise<{ width: number; height: number }> {
-    return await page.evaluate((): { width: number; height: number } => {
-      const win = (globalThis as any).window;
-      return {
-        width: win.innerWidth as number,
-        height: win.innerHeight as number
-      };
-    });
-  }
-  
-  /**
-   * Convert coordinate action with percentages to Playwright commands
-   * Returns array of command strings
-   */
-  static async generateCommands(
-    action: CoordinateAction,
-    page: any
-  ): Promise<string[]> {
-    const viewport = await this.getViewportSize(page);
-    const { x, y } = this.percentToPixels(action.xPercent, action.yPercent, viewport.width, viewport.height);
-    
-    const commands: string[] = [];
-    
-    switch (action.action) {
-      case 'click':
-        commands.push(`await page.mouse.click(${x}, ${y});`);
-        break;
-        
-      case 'doubleClick':
-        commands.push(`await page.mouse.dblclick(${x}, ${y});`);
-        break;
-        
-      case 'rightClick':
-        commands.push(`await page.mouse.click(${x}, ${y}, { button: 'right' });`);
-        break;
-        
-      case 'hover':
-        commands.push(`await page.mouse.move(${x}, ${y});`);
-        break;
-        
-      case 'drag':
-        if (action.toXPercent === undefined || action.toYPercent === undefined) {
-          throw new Error('Drag action requires toXPercent and toYPercent');
-        }
-        const to = this.percentToPixels(action.toXPercent, action.toYPercent, viewport.width, viewport.height);
-        commands.push(`await page.mouse.move(${x}, ${y});`);
-        commands.push(`await page.mouse.down();`);
-        commands.push(`await page.mouse.move(${to.x}, ${to.y});`);
-        commands.push(`await page.mouse.up();`);
-        break;
-        
-      case 'fill':
-        if (!action.value) {
-          throw new Error('Fill action requires value');
-        }
-        // Click to focus, wait briefly, then type
-        commands.push(`await page.mouse.click(${x}, ${y});`);
-        commands.push(`await page.waitForTimeout(100);`);
-        commands.push(`await page.keyboard.type(${JSON.stringify(action.value)});`);
-        break;
-        
-      case 'scroll':
-        const scrollAmount = action.scrollAmount || 100;
-        // Move to position, then scroll
-        commands.push(`await page.mouse.move(${x}, ${y});`);
-        commands.push(`await page.mouse.wheel(0, ${scrollAmount});`);
-        break;
-        
-      default:
-        throw new Error(`Unknown coordinate action: ${action.action}`);
-    }
-    
-    return commands;
-  }
-  
-  /**
-   * Execute coordinate action directly on page
-   * Used during agent execution (converts and runs immediately)
-   */
-  static async executeAction(
-    action: CoordinateAction,
-    page: any
-  ): Promise<void> {
-    const viewport = await this.getViewportSize(page);
-    const { x, y } = this.percentToPixels(action.xPercent, action.yPercent, viewport.width, viewport.height);
-    
-    switch (action.action) {
-      case 'click':
-        await page.mouse.click(x, y);
-        break;
-        
-      case 'doubleClick':
-        await page.mouse.dblclick(x, y);
-        break;
-        
-      case 'rightClick':
-        await page.mouse.click(x, y, { button: 'right' });
-        break;
-        
-      case 'hover':
-        await page.mouse.move(x, y);
-        break;
-        
-      case 'drag':
-        if (action.toXPercent === undefined || action.toYPercent === undefined) {
-          throw new Error('Drag requires toXPercent and toYPercent');
-        }
-        const to = this.percentToPixels(action.toXPercent, action.toYPercent, viewport.width, viewport.height);
-        await page.mouse.move(x, y);
-        await page.mouse.down();
-        await page.mouse.move(to.x, to.y);
-        await page.mouse.up();
-        break;
-        
-      case 'fill':
-        if (!action.value) {
-          throw new Error('Fill requires value');
-        }
-        await page.mouse.click(x, y);
-        await page.waitForTimeout(100);
-        await page.keyboard.type(action.value);
-        break;
-        
-      case 'scroll':
-        const scrollAmount = action.scrollAmount || 100;
-        await page.mouse.move(x, y);
-        await page.mouse.wheel(0, scrollAmount);
-        break;
-        
-      default:
-        throw new Error(`Unknown coordinate action: ${action.action}`);
-    }
-  }
-}
-

package/src/utils/page-info-retry.ts

@@ -1,65 +0,0 @@
-/**
- * Page Info Retry Utility
- * Handles adaptive page loading with exponential backoff
- */
-
-import { getEnhancedPageInfo, PageInfo } from './page-info-utils';
-
-export class PageInfoRetry {
-  /**
-   * Get page info with retry logic - waits for interactive elements to appear
-   * Uses exponential backoff to handle slow-loading React/Vue/Angular apps
-   */
-  static async getWithRetry(page: any, maxAttempts: number = 6): Promise<PageInfo> {
-    // Wait for initial page load (generous timeout for slow apps)
-    try {
-      await page.waitForLoadState('domcontentloaded', { timeout: 20000 }).catch(() => {});
-    } catch (waitError) {
-      // Continue even if wait fails
-    }
-    
-    let attempt = 0;
-    let backoffMs = 1000; // Start with 1 second (adequate for most sites)
-    
-    while (attempt < maxAttempts) {
-      attempt++;
-      
-      // Try to extract page info
-      const pageInfo = await getEnhancedPageInfo(page);
-      
-      // If we got a reasonable number of elements, we're done
-      if (pageInfo.interactiveElements && pageInfo.interactiveElements.length >= 3) {
-        if (attempt > 1) {
-          console.log(`[PageInfoRetry] ✓ Page elements loaded after ${attempt} attempts`);
-        }
-        return pageInfo;
-      }
-      
-      // If this is the last attempt, return what we have
-      if (attempt >= maxAttempts) {
-        const totalWait = this.calculateTotalWaitTime(maxAttempts);
-        console.log(`[PageInfoRetry] ⚠️  Only found ${pageInfo.interactiveElements?.length || 0} elements after ${maxAttempts} attempts (total wait: ~${totalWait}ms)`);
-        return pageInfo;
-      }
-      
-      // Wait with exponential backoff before retrying
-      console.log(`[PageInfoRetry] Only ${pageInfo.interactiveElements?.length || 0} elements found (attempt ${attempt}/${maxAttempts}), waiting ${backoffMs}ms...`);
-      await page.waitForTimeout(backoffMs);
-      backoffMs = Math.min(backoffMs * 1.6, 15000); // Cap at 15 seconds per attempt
-    }
-    
-    // Fallback (shouldn't reach here, but for type safety)
-    return await getEnhancedPageInfo(page);
-  }
-  
-  private static calculateTotalWaitTime(maxAttempts: number): number {
-    let total = 0;
-    let backoffMs = 1000;
-    for (let i = 1; i < maxAttempts; i++) {
-      total += backoffMs;
-      backoffMs = Math.min(backoffMs * 1.6, 15000);
-    }
-    return Math.round(total);
-  }
-}
-