testchimp-runner-core 0.0.1

package/src/utils/browser-utils.ts

@@ -0,0 +1,272 @@
+import { chromium, firefox, webkit, Browser, BrowserContext, Page } from 'playwright';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { build } from 'esbuild';
+
+/**
+ * Initialize browser with Playwright configuration
+ * @param playwrightConfig - JavaScript config file content (playwright.config.js)
+ * @param headless - Override headless mode (optional)
+ * @returns Browser, context, and page instances
+ */
+export async function initializeBrowser(
+  playwrightConfigContent?: string, 
+  headless?: boolean,
+  playwrightConfigFilePath?: string
+): Promise<{ browser: Browser; context: BrowserContext; page: Page }> {
+  console.log('Initializing browser with Playwright');
+  
+  let contextOptions: any = {};
+  
+  // Use Playwright config content if provided
+  if (playwrightConfigContent) {
+    console.log('Using provided Playwright config content');
+    
+    try {
+      // Transpile the config content in-memory and evaluate it
+      console.log(`Transpiling config content (${playwrightConfigContent.length} characters)`);
+      
+      const result = await build({
+        stdin: {
+          contents: playwrightConfigContent,
+          resolveDir: 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;
+      console.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');
+      
+      // 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(', ')}`);
+        
+        // Extract context options from the config
+        if (actualConfig.use && actualConfig.use.contextOptions) {
+          contextOptions = { ...contextOptions, ...actualConfig.use.contextOptions };
+          console.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;
+            console.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`);
+        }
+        
+        // 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)}`);
+        }
+        
+        // Apply user agent
+        if (actualConfig.use && actualConfig.use.userAgent) {
+          contextOptions.userAgent = actualConfig.use.userAgent;
+          console.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`);
+        }
+        
+        if (actualConfig.use && actualConfig.use.locale) {
+          contextOptions.locale = actualConfig.use.locale;
+          console.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}`);
+        }
+        
+        if (actualConfig.use && actualConfig.use.geolocation) {
+          contextOptions.geolocation = actualConfig.use.geolocation;
+          console.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)}`);
+        }
+        
+        if (actualConfig.use && actualConfig.use.colorScheme) {
+          contextOptions.colorScheme = actualConfig.use.colorScheme;
+          console.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}`);
+        }
+        
+        if (actualConfig.use && actualConfig.use.forcedColors) {
+          contextOptions.forcedColors = actualConfig.use.forcedColors;
+          console.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}`);
+        }
+        
+        if (actualConfig.use && actualConfig.use.bypassCSP) {
+          contextOptions.bypassCSP = actualConfig.use.bypassCSP;
+          console.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}`);
+        }
+        
+        if (actualConfig.use && actualConfig.use.ignoreHTTPSErrors) {
+          contextOptions.ignoreHTTPSErrors = actualConfig.use.ignoreHTTPSErrors;
+          console.log(`Using ignore HTTPS errors from config: ${actualConfig.use.ignoreHTTPSErrors}`);
+        }
+        
+        console.log(`Final context options: ${JSON.stringify(contextOptions, null, 2)}`);
+      } else {
+        console.log('Config loaded but no valid configuration found');
+      }
+    } catch (error) {
+      console.error(`Error transpiling config content: ${error}`);
+      console.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');
+    // Resolve the path - it might be relative or absolute
+    const resolvedPath = path.isAbsolute(playwrightConfigFilePath) 
+      ? playwrightConfigFilePath 
+      : path.resolve(process.cwd(), playwrightConfigFilePath);
+    
+    console.log(`Looking for Playwright config at: ${resolvedPath}`);
+    console.log(`File exists: ${fs.existsSync(resolvedPath)}`);
+    
+    if (fs.existsSync(resolvedPath)) {
+      console.log(`Loading Playwright config from: ${resolvedPath}`);
+
+      try {
+        // Transpile the config in-memory and evaluate it
+        console.log(`Transpiling config in-memory from: ${resolvedPath}`);
+        
+        const result = await build({
+          entryPoints: [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;
+        console.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');
+        
+        // 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');
+        
+        if (!actualConfig) {
+          console.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);
+          } else {
+            console.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);
+            }
+          } else {
+            console.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');
+      }
+    } else {
+      console.log(`Playwright config file not found at: ${resolvedPath}`);
+      console.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 };
+}

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

@@ -0,0 +1,93 @@
+import { Page } from 'playwright';
+
+export interface PageInfo {
+  url: string;
+  title: string;
+  elements: string;
+  formFields: string;
+  interactiveElements: string;
+  pageStructure: string;
+}
+
+export async function getEnhancedPageInfo(page: Page): Promise<PageInfo>;
+export async function getEnhancedPageInfo(domSnapshot: { url: string; title: string; accessibilityTree: any }): Promise<PageInfo>;
+export async function getEnhancedPageInfo(input: Page | { url: string; title: string; accessibilityTree: any }): Promise<PageInfo> {
+  let domSnapshot: { url: string; title: string; accessibilityTree: any } = { url: 'Unknown', title: 'Unknown', accessibilityTree: null };
+  
+  try {
+    if ('accessibility' in input) {
+      // Input is a Page object
+      const snapshot = await input.accessibility.snapshot();
+      const url = input.url();
+      const title = await input.title();
+      domSnapshot = { url, title, accessibilityTree: snapshot };
+    } else {
+      // Input is already a domSnapshot
+      domSnapshot = input;
+    }
+
+    // Extract key information from accessibility tree
+    const elements: string[] = [];
+    const formFields: string[] = [];
+    const interactiveElements: string[] = [];
+    const pageStructure: string[] = [];
+
+    const extractElements = (node: any, depth = 0) => {
+      if (depth > 4) return; // Limit depth to avoid overwhelming output
+      
+      if (node && typeof node === 'object') {
+        if (node.role) {
+          const elementInfo = `${node.role}${node.name ? `: ${node.name}` : ''}`;
+          elements.push(elementInfo);
+
+          // Categorize elements
+          if (['textbox', 'button', 'link', 'checkbox', 'radio', 'combobox', 'slider'].includes(node.role)) {
+            interactiveElements.push(elementInfo);
+          }
+          
+          if (['textbox', 'checkbox', 'radio', 'combobox', 'slider'].includes(node.role)) {
+            formFields.push(elementInfo);
+          }
+
+          if (['main', 'navigation', 'banner', 'contentinfo', 'complementary', 'search'].includes(node.role)) {
+            pageStructure.push(elementInfo);
+          }
+        }
+
+        if (node.children) {
+          node.children.forEach((child: any) => extractElements(child, depth + 1));
+        }
+      }
+    };
+
+    extractElements(domSnapshot.accessibilityTree);
+
+    // Create a more focused summary
+    const getElementSummary = (elementList: string[], maxItems: number, category: string) => {
+      if (elementList.length === 0) return `No ${category} found`;
+      const limited = elementList.slice(0, maxItems);
+      const remaining = elementList.length - maxItems;
+      const summary = limited.join(', ');
+      return remaining > 0 ? `${summary} (+${remaining} more)` : summary;
+    };
+
+    return {
+      url: domSnapshot.url,
+      title: domSnapshot.title,
+      elements: getElementSummary(elements, 15, 'elements'),
+      formFields: getElementSummary(formFields, 8, 'form fields'),
+      interactiveElements: getElementSummary(interactiveElements, 12, 'interactive elements'),
+      pageStructure: getElementSummary(pageStructure, 6, 'page sections')
+    };
+  } catch (error) {
+    console.error('Error extracting page info:', error);
+    return {
+      url: domSnapshot?.url || 'Unknown',
+      title: 'Unknown',
+      elements: 'Unable to extract',
+      formFields: 'Unable to extract',
+      interactiveElements: 'Unable to extract',
+      pageStructure: 'Unable to extract'
+    };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}