mcpbrowser 0.2.28 → 0.2.30

package/tests/auth-flow.test.js

@@ -0,0 +1,279 @@
+import assert from 'assert';
+import { waitForAutoAuth, waitForManualAuth } from '../src/mcp-browser.js';
+
+console.log('🧪 Testing authentication flow functions\n');
+
+let testsPassed = 0;
+let testsFailed = 0;
+
+function test(description, fn) {
+  return new Promise((resolve) => {
+    fn()
+      .then(() => {
+        console.log(`✅ ${description}`);
+        testsPassed++;
+        resolve();
+      })
+      .catch((err) => {
+        console.log(`❌ ${description}`);
+        console.log(`   Error: ${err.message}`);
+        testsFailed++;
+        resolve();
+      });
+  });
+}
+
+// Mock page object for testing
+class MockPage {
+  constructor(urlsOrConfig) {
+    if (Array.isArray(urlsOrConfig)) {
+      // Simple array of URLs
+      this.urls = urlsOrConfig;
+      this.timing = null;
+    } else {
+      // Config object with timing
+      this.urls = urlsOrConfig.urls;
+      this.timing = urlsOrConfig.timing || null; // { delayMs: 500, changeAfterCalls: 3 }
+    }
+    this.currentIndex = 0;
+    this.callCount = 0;
+  }
+
+  url() {
+    this.callCount++;
+    
+    if (this.timing) {
+      // Change URL every N calls (simulating time passing)
+      const changeEvery = this.timing.changeAfterCalls || 3;
+      const targetIndex = Math.min(
+        Math.floor(this.callCount / changeEvery),
+        this.urls.length - 1
+      );
+      return this.urls[targetIndex];
+    } else {
+      // Advance to next URL every 2 calls by default
+      const advanceEvery = 2;
+      const targetIndex = Math.min(
+        Math.floor(this.callCount / advanceEvery),
+        this.urls.length - 1
+      );
+      return this.urls[targetIndex];
+    }
+  }
+
+  reset() {
+    this.currentIndex = 0;
+    this.callCount = 0;
+  }
+}
+
+// ============================================================================
+// waitForAutoAuth Tests
+// ============================================================================
+
+console.log('\n📋 Testing waitForAutoAuth()');
+
+await test('Should detect successful auto-auth', async () => {
+  const mockPage = new MockPage([
+    'https://login.example.com/auth',
+    'https://login.example.com/auth',
+    'https://app.example.com/dashboard' // Returns to app domain
+  ]);
+
+  const result = await waitForAutoAuth(mockPage, 'example.com', 'example.com', 2000);
+  
+  assert.strictEqual(result.success, true, 'Should succeed');
+  assert.strictEqual(result.hostname, 'app.example.com', 'Should return final hostname');
+});
+
+await test('Should detect auto-auth to original domain', async () => {
+  const mockPage = new MockPage([
+    'https://login.example.com/auth',
+    'https://example.com/dashboard' // Returns to exact original domain
+  ]);
+
+  const result = await waitForAutoAuth(mockPage, 'example.com', 'example.com', 2000);
+  
+  assert.strictEqual(result.success, true, 'Should succeed');
+  assert.strictEqual(result.hostname, 'example.com', 'Should return original hostname');
+});
+
+await test('Should timeout if auto-auth does not complete', async () => {
+  const mockPage = new MockPage([
+    'https://login.example.com/auth' // Stays on auth page
+  ]);
+
+  const result = await waitForAutoAuth(mockPage, 'example.com', 'example.com', 1000);
+  
+  assert.strictEqual(result.success, false, 'Should fail on timeout');
+  assert.strictEqual(result.hostname, undefined, 'Should not have hostname');
+});
+
+await test('Should NOT accept return to auth URL on same domain', async () => {
+  const mockPage = new MockPage([
+    'https://auth.site.com/login',
+    'https://site.com/login' // Returns to site.com but still on /login
+  ]);
+
+  const result = await waitForAutoAuth(mockPage, 'site.com', 'site.com', 1000);
+  
+  assert.strictEqual(result.success, false, 'Should fail - still on auth URL');
+});
+
+await test('Should accept return to different subdomain', async () => {
+  const mockPage = new MockPage([
+    'https://accounts.google.com/signin',
+    'https://accounts.google.com/signin',
+    'https://mail.google.com' // Different subdomain but same base
+  ]);
+
+  const result = await waitForAutoAuth(mockPage, 'gmail.com', 'google.com', 2000);
+  
+  assert.strictEqual(result.success, true, 'Should succeed');
+  assert.strictEqual(result.hostname, 'mail.google.com', 'Should return new hostname');
+});
+
+await test('Should handle page navigation errors gracefully', async () => {
+  const mockPage = {
+    url: () => {
+      throw new Error('Page not accessible');
+    }
+  };
+
+  const result = await waitForAutoAuth(mockPage, 'example.com', 'example.com', 1000);
+  
+  assert.strictEqual(result.success, false, 'Should handle errors and timeout');
+});
+
+// ============================================================================
+// waitForManualAuth Tests
+// ============================================================================
+
+console.log('\n📋 Testing waitForManualAuth()');
+
+await test('Should detect successful manual auth', async () => {
+  // Manual auth polls every 2 seconds, so we need URL to change after ~2 polling attempts
+  const mockPage = new MockPage({
+    urls: [
+      'https://login.microsoftonline.com/oauth',
+      'https://app.example.com/dashboard' // User completes auth
+    ],
+    timing: { changeAfterCalls: 3 } // Change URL after 3 calls (simulating ~4 seconds)
+  });
+
+  const result = await waitForManualAuth(mockPage, 'example.com', 'example.com', 10000);
+  
+  assert.strictEqual(result.success, true, 'Should succeed');
+  assert.strictEqual(result.hostname, 'app.example.com', 'Should return final hostname');
+});
+
+await test('Should return to original domain after auth', async () => {
+  const mockPage = new MockPage({
+    urls: [
+      'https://accounts.google.com/signin',
+      'https://myapp.com/home' // Returns to original
+    ],
+    timing: { changeAfterCalls: 2 }
+  });
+
+  const result = await waitForManualAuth(mockPage, 'myapp.com', 'myapp.com', 10000);
+  
+  assert.strictEqual(result.success, true, 'Should succeed');
+  assert.strictEqual(result.hostname, 'myapp.com', 'Should return to myapp.com');
+});
+
+await test('Should timeout if user does not complete auth', async () => {
+  const mockPage = new MockPage([
+    'https://login.example.com/auth' // User never completes
+  ]);
+
+  const result = await waitForManualAuth(mockPage, 'example.com', 'example.com', 2000);
+  
+  assert.strictEqual(result.success, false, 'Should timeout');
+  assert.ok(result.error, 'Should have error message');
+  assert.ok(result.hint, 'Should have hint for user');
+  assert.ok(result.hint.includes('Authentication timeout'), 'Hint should mention timeout');
+});
+
+await test('Should detect landing on different subdomain', async () => {
+  const mockPage = new MockPage({
+    urls: [
+      'https://sso.company.com/login',
+      'https://dashboard.company.com' // Different subdomain, same base
+    ],
+    timing: { changeAfterCalls: 3 }
+  });
+
+  const result = await waitForManualAuth(mockPage, 'company.com', 'company.com', 10000);
+  
+  assert.strictEqual(result.success, true, 'Should succeed');
+  assert.strictEqual(result.hostname, 'dashboard.company.com', 'Should accept different subdomain');
+});
+
+await test('Should NOT accept return to auth page on same base domain', async () => {
+  const mockPage = new MockPage([
+    'https://auth0.company.com/login',
+    'https://auth0.company.com/login',
+    'https://company.com/login' // Returns to base but still on /login
+  ]);
+
+  const result = await waitForManualAuth(mockPage, 'company.com', 'company.com', 2000);
+  
+  assert.strictEqual(result.success, false, 'Should timeout - still on auth page');
+});
+
+await test('Should handle page navigation errors', async () => {
+  let callCount = 0;
+  const mockPage = {
+    url: () => {
+      callCount++;
+      if (callCount < 3) {
+        throw new Error('Navigation in progress');
+      }
+      return 'https://app.example.com/home';
+    }
+  };
+
+  const result = await waitForManualAuth(mockPage, 'example.com', 'example.com', 5000);
+  
+  assert.strictEqual(result.success, true, 'Should handle temporary errors and succeed');
+});
+
+await test('Should include current URL in timeout hint', async () => {
+  const mockPage = new MockPage([
+    'https://stuck.on.auth.com/page'
+  ]);
+
+  const result = await waitForManualAuth(mockPage, 'example.com', 'example.com', 1000);
+  
+  assert.strictEqual(result.success, false);
+  assert.ok(result.hint.includes('stuck.on.auth.com/page'), 'Should include stuck URL in hint');
+});
+
+await test('Should accept cross-domain SSO completion', async () => {
+  const mockPage = new MockPage({
+    urls: [
+      'https://accounts.google.com/signin',
+      'https://myapp.com' // Different domain entirely
+    ],
+    timing: { changeAfterCalls: 3 }
+  });
+
+  const result = await waitForManualAuth(mockPage, 'myapp.com', 'myapp.com', 10000);
+  
+  assert.strictEqual(result.success, true, 'Should succeed for cross-domain SSO');
+  assert.strictEqual(result.hostname, 'myapp.com', 'Should return to original app');
+});
+
+// ============================================================================
+// Summary
+// ============================================================================
+
+console.log('\n' + '='.repeat(50));
+console.log(`Tests passed: ${testsPassed}`);
+console.log(`Tests failed: ${testsFailed}`);
+console.log('='.repeat(50));
+
+if (testsFailed > 0) {
+  process.exit(1);
+}

package/tests/integration.test.js

@@ -4,183 +4,191 @@
  * Run with: node tests/integration.test.js
  */
 
-import { fileURLToPath } from 'url';
-import path from 'path';
+import assert from 'assert';
 import { fetchPage } from '../src/mcp-browser.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+console.log('🚀 Starting Integration Tests (REAL CHROME)\n');
+console.log('⚠️  This will open Chrome browser and may require authentication');
+console.log('⚠️  fetchPage function will WAIT for you to complete authentication\n');
 
-// Test framework
 let testsPassed = 0;
 let testsFailed = 0;
 
-function assert(condition, message) {
-  if (!condition) {
-    console.error(`❌ FAILED: ${message}`);
-    testsFailed++;
-    throw new Error(message);
-  } else {
-    console.log(`✅ PASSED: ${message}`);
-    testsPassed++;
-  }
-}
-
-async function test(name, fn) {
-  console.log(`\n🧪 Test: ${name}`);
-  try {
-    await fn();
-  } catch (error) {
-    console.error(`   Error: ${error.message}`);
-  }
+function test(description, fn) {
+  return new Promise((resolve) => {
+    fn()
+      .then(() => {
+        console.log(`✅ ${description}`);
+        testsPassed++;
+        resolve();
+      })
+      .catch((err) => {
+        console.log(`❌ ${description}`);
+        console.log(`   Error: ${err.message}`);
+        testsFailed++;
+        resolve();
+      });
+  });
 }
 
+// ============================================================================
 // Integration Tests
-async function runIntegrationTests() {
-  console.log('🚀 Starting Integration Tests (REAL CHROME)\n');
-  console.log('⚠️  This will open Chrome browser and may require authentication');
-  console.log('⚠️  fetchPage function will WAIT for you to complete authentication\n');
-  
-  try {
-    await test('Should fetch eng.ms page, extract links, and load them (full Copilot workflow)', async () => {
-      const url = 'https://eng.ms/docs/products/geneva';
-      
-      // Step 1: Fetch initial page (with auth waiting)
-      console.log(`   📄 Step 1: Fetching ${url}`);
-      console.log(`   ⏳ Function will wait up to 10 minutes for authentication...`);
-      console.log(`   💡 Complete login in the browser that opens`);
-      
-      const result = await fetchPage({ url });
-      
-      console.log(`   ✅ Result: ${result.success ? 'SUCCESS' : 'FAILED'}`);
-      if (result.success) {
-        console.log(`   🔗 Final URL: ${result.url}`);
-        console.log(`   📄 HTML length: ${result.html?.length || 0} chars`);
-      } else {
-        console.log(`   ❌ Error: ${result.error}`);
-        console.log(`   💡 Hint: ${result.hint}`);
-      }
-      
-      assert(result.success, 'Should successfully fetch page after authentication');
-      assert(result.url.includes('eng.ms'), `URL should be from eng.ms domain, got: ${result.url}`);
-      assert(result.html && result.html.length > 0, 'Should return HTML content');
-      
-      // Step 2: Extract ALL links from HTML, then pick 5 randomly
-      console.log(`\n   📋 Step 2: Extracting all links from HTML...`);
-      
-      const baseUrl = new URL(result.url);
-      const urlPattern = /href=["']([^"']+)["']/g;
-      const allUrls = [];
-      let match;
-      
-      // Static asset extensions to skip
-      const skipExtensions = ['.css', '.js', '.ico', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.woff', '.woff2', '.ttf', '.eot'];
-      
-      // Extract ALL URLs first
-      while ((match = urlPattern.exec(result.html)) !== null) {
-        let foundUrl = match[1];
-        
-        // Skip anchor links
-        if (foundUrl.includes('#')) continue;
-        
-        // Convert relative URLs to absolute
-        if (foundUrl.startsWith('/')) {
-          foundUrl = `${baseUrl.origin}${foundUrl}`;
-        } else if (!foundUrl.startsWith('http')) {
-          continue; // Skip other relative URLs
-        }
-        
-        // Skip static assets (check path without query string)
-        const urlWithoutQuery = foundUrl.split('?')[0];
-        if (skipExtensions.some(ext => urlWithoutQuery.toLowerCase().endsWith(ext))) continue;
-        
-        // Only include eng.ms URLs (pages)
-        if (foundUrl.includes('eng.ms')) {
-          allUrls.push(foundUrl);
-        }
-      }
-      
-      console.log(`   📊 Total page URLs found: ${allUrls.length}`);
-      
-      // Remove duplicates
-      const uniqueUrls = [...new Set(allUrls)];
-      console.log(`   🔗 Unique page URLs: ${uniqueUrls.length}`);
-      
-      // Randomly pick 5 URLs
-      const shuffled = uniqueUrls.sort(() => Math.random() - 0.5);
-      const extractedUrls = shuffled.slice(0, 5);
-      
-      console.log(`   🎲 Randomly selected ${extractedUrls.length} URLs to test:`);
-      extractedUrls.forEach((link, i) => console.log(`      ${i+1}. ${link}`));
-      
-      assert(extractedUrls.length > 0, `Should extract at least one eng.ms URL, found ${extractedUrls.length}`);
-      
-      // Step 3: Load each extracted URL (tab reuse)
-      console.log(`\n   🔄 Step 3: Loading extracted links (using same tab)...`);
-      
-      const linksToTest = extractedUrls.slice(0, Math.min(5, extractedUrls.length));
-      for (let i = 0; i < linksToTest.length; i++) {
-        const link = linksToTest[i];
-        console.log(`   📄 Loading link ${i+1}/${linksToTest.length}: ${link}`);
-        
-        const linkResult = await fetchPage({ url: link });
-        
-        console.log(`   ✅ Loaded: ${linkResult.url}`);
-        assert(linkResult.success, `Should successfully load link ${i+1}: ${link}`);
-        assert(linkResult.html && linkResult.html.length > 0, `Link ${i+1} should return HTML content`);
-      }
-    });
+// ============================================================================
+
+await test('Should handle gmail.com → mail.google.com permanent redirect', async () => {
+  const url = 'https://gmail.com';
+  
+  console.log(`   📄 Fetching ${url}`);
+  console.log(`   💡 This should detect permanent redirect and return content immediately`);
+  
+  const result = await fetchPage({ url });
+  
+  console.log(`   ✅ Result: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+  if (result.success) {
+    console.log(`   🔗 Final URL: ${result.url}`);
+    console.log(`   📄 HTML length: ${result.html?.length || 0} chars`);
+  } else {
+    console.log(`   ❌ Error: ${result.error}`);
+  }
+  
+  assert.strictEqual(result.success, true, 'Should successfully fetch gmail.com');
+  assert.ok(result.url.includes('mail.google.com'), `Should redirect to mail.google.com, got: ${result.url}`);
+  assert.ok(result.html && result.html.length > 0, 'Should return HTML content');
+  assert.ok(result.html.includes('Gmail') || result.html.includes('Google'), 'HTML should contain Gmail or Google content');
+  
+  console.log(`   ✅ Permanent redirect handled correctly (gmail.com → mail.google.com)`);
+});
 
-    await test('Should support removeUnnecessaryHTML parameter', async () => {
-      const url = 'https://eng.ms/docs/products/geneva';
-      
-      console.log(`   📄 Fetching with removeUnnecessaryHTML=true (default)`);
-      const cleanResult = await fetchPage({ url, removeUnnecessaryHTML: true });
-      
-      assert(cleanResult.success, 'Should successfully fetch with removeUnnecessaryHTML=true');
-      assert(cleanResult.html && cleanResult.html.length > 0, 'Should return cleaned HTML');
-      assert(!cleanResult.html.includes('<script'), 'Cleaned HTML should not contain script tags');
-      assert(!cleanResult.html.includes('<style'), 'Cleaned HTML should not contain style tags');
-      assert(!cleanResult.html.includes('class='), 'Cleaned HTML should not contain class attributes');
-      console.log(`   ✅ Cleaned HTML length: ${cleanResult.html.length} chars`);
-      
-      console.log(`   📄 Fetching with removeUnnecessaryHTML=false`);
-      const rawResult = await fetchPage({ url, removeUnnecessaryHTML: false });
-      
-      assert(rawResult.success, 'Should successfully fetch with removeUnnecessaryHTML=false');
-      assert(rawResult.html && rawResult.html.length > 0, 'Should return raw HTML');
-      console.log(`   ✅ Raw HTML length: ${rawResult.html.length} chars`);
-      
-      // Raw HTML should be larger than cleaned HTML
-      assert(rawResult.html.length > cleanResult.html.length, 
-        `Raw HTML (${rawResult.html.length}) should be larger than cleaned (${cleanResult.html.length})`);
-      
-      const reductionPercent = ((rawResult.html.length - cleanResult.html.length) / rawResult.html.length * 100).toFixed(1);
-      console.log(`   📊 Size reduction: ${reductionPercent}% (${rawResult.html.length} → ${cleanResult.html.length} chars)`);
-    });
+await test('Should fetch eng.ms page, extract links, and load them (full Copilot workflow)', async () => {
+  const url = 'https://eng.ms/docs/products/geneva';
+  
+  // Step 1: Fetch initial page (with auth waiting)
+  console.log(`   📄 Step 1: Fetching ${url}`);
+  console.log(`   ⏳ Function will wait up to 10 minutes for authentication...`);
+  console.log(`   💡 Complete login in the browser that opens`);
+  
+  const result = await fetchPage({ url });
+  
+  console.log(`   ✅ Result: ${result.success ? 'SUCCESS' : 'FAILED'}`);
+  if (result.success) {
+    console.log(`   🔗 Final URL: ${result.url}`);
+    console.log(`   📄 HTML length: ${result.html?.length || 0} chars`);
+  } else {
+    console.log(`   ❌ Error: ${result.error}`);
+    console.log(`   💡 Hint: ${result.hint}`);
+  }
+  
+  assert.strictEqual(result.success, true, 'Should successfully fetch page after authentication');
+  assert.ok(result.url.includes('eng.ms'), `URL should be from eng.ms domain, got: ${result.url}`);
+  assert.ok(result.html && result.html.length > 0, 'Should return HTML content');
+  
+  // Step 2: Extract ALL links from HTML, then pick 5 randomly
+  console.log(`\n   📋 Step 2: Extracting all links from HTML...`);
+  
+  const baseUrl = new URL(result.url);
+  const urlPattern = /href=["']([^"']+)["']/g;
+  const allUrls = [];
+  let match;
+  
+  // Static asset extensions to skip
+  const skipExtensions = ['.css', '.js', '.ico', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.woff', '.woff2', '.ttf', '.eot'];
+  
+  // Extract ALL URLs first
+  while ((match = urlPattern.exec(result.html)) !== null) {
+    let foundUrl = match[1];
     
-  } catch (error) {
-    console.error('\n❌ Test suite error:', error.message);
-    testsFailed++;
-  } finally {
-    // Summary
-    console.log('\n' + '='.repeat(50));
-    console.log(`✅ Tests Passed: ${testsPassed}`);
-    console.log(`❌ Tests Failed: ${testsFailed}`);
-    console.log('='.repeat(50));
-    console.log('\n💡 Browser left open for manual inspection');
+    // Skip anchor links
+    if (foundUrl.includes('#')) continue;
     
-    if (testsFailed > 0) {
-      process.exit(1);
+    // Convert relative URLs to absolute
+    if (foundUrl.startsWith('/')) {
+      foundUrl = `${baseUrl.origin}${foundUrl}`;
+    } else if (!foundUrl.startsWith('http')) {
+      continue; // Skip other relative URLs
     }
     
-    // Exit immediately without waiting for browser
-    process.exit(0);
+    // Skip static assets (check path without query string)
+    const urlWithoutQuery = foundUrl.split('?')[0];
+    if (skipExtensions.some(ext => urlWithoutQuery.toLowerCase().endsWith(ext))) continue;
+    
+    // Only include eng.ms URLs (pages)
+    if (foundUrl.includes('eng.ms')) {
+      allUrls.push(foundUrl);
+    }
   }
-}
+  
+  console.log(`   📊 Total page URLs found: ${allUrls.length}`);
+  
+  // Remove duplicates
+  const uniqueUrls = [...new Set(allUrls)];
+  console.log(`   🔗 Unique page URLs: ${uniqueUrls.length}`);
+  
+  // Randomly pick 5 URLs
+  const shuffled = uniqueUrls.sort(() => Math.random() - 0.5);
+  const extractedUrls = shuffled.slice(0, 5);
+  
+  console.log(`   🎲 Randomly selected ${extractedUrls.length} URLs to test:`);
+  extractedUrls.forEach((link, i) => console.log(`      ${i+1}. ${link}`));
+  
+  assert.ok(extractedUrls.length > 0, `Should extract at least one eng.ms URL, found ${extractedUrls.length}`);
+  
+  // Step 3: Load each extracted URL (tab reuse)
+  console.log(`\n   🔄 Step 3: Loading extracted links (using same tab)...`);
+  
+  const linksToTest = extractedUrls.slice(0, Math.min(5, extractedUrls.length));
+  for (let i = 0; i < linksToTest.length; i++) {
+    const link = linksToTest[i];
+    console.log(`   📄 Loading link ${i+1}/${linksToTest.length}: ${link}`);
+    
+    const linkResult = await fetchPage({ url: link });
+    
+    console.log(`   ✅ Loaded: ${linkResult.url}`);
+    assert.strictEqual(linkResult.success, true, `Should successfully load link ${i+1}: ${link}`);
+    assert.ok(linkResult.html && linkResult.html.length > 0, `Link ${i+1} should return HTML content`);
+  }
+});
 
-// Run tests
-runIntegrationTests().catch(error => {
-  console.error('Test suite failed:', error);
-  process.exit(1);
+await test('Should support removeUnnecessaryHTML parameter', async () => {
+  const url = 'https://eng.ms/docs/products/geneva';
+  
+  console.log(`   📄 Fetching with removeUnnecessaryHTML=true (default)`);
+  const cleanResult = await fetchPage({ url, removeUnnecessaryHTML: true });
+  
+  assert.strictEqual(cleanResult.success, true, 'Should successfully fetch with removeUnnecessaryHTML=true');
+  assert.ok(cleanResult.html && cleanResult.html.length > 0, 'Should return cleaned HTML');
+  assert.ok(!cleanResult.html.includes('<script'), 'Cleaned HTML should not contain script tags');
+  assert.ok(!cleanResult.html.includes('<style'), 'Cleaned HTML should not contain style tags');
+  assert.ok(!cleanResult.html.includes('class='), 'Cleaned HTML should not contain class attributes');
+  console.log(`   ✅ Cleaned HTML length: ${cleanResult.html.length} chars`);
+  
+  console.log(`   📄 Fetching with removeUnnecessaryHTML=false`);
+  const rawResult = await fetchPage({ url, removeUnnecessaryHTML: false });
+  
+  assert.strictEqual(rawResult.success, true, 'Should successfully fetch with removeUnnecessaryHTML=false');
+  assert.ok(rawResult.html && rawResult.html.length > 0, 'Should return raw HTML');
+  console.log(`   ✅ Raw HTML length: ${rawResult.html.length} chars`);
+  
+  // Raw HTML should be larger than cleaned HTML
+  assert.ok(rawResult.html.length > cleanResult.html.length, 
+    `Raw HTML (${rawResult.html.length}) should be larger than cleaned (${cleanResult.html.length})`);
+  
+  const reductionPercent = ((rawResult.html.length - cleanResult.html.length) / rawResult.html.length * 100).toFixed(1);
+  console.log(`   📊 Size reduction: ${reductionPercent}% (${rawResult.html.length} → ${cleanResult.html.length} chars)`);
 });
+
+// ============================================================================
+// Summary
+// ============================================================================
+
+console.log('\n' + '='.repeat(50));
+console.log(`Tests passed: ${testsPassed}`);
+console.log(`Tests failed: ${testsFailed}`);
+console.log('='.repeat(50));
+console.log('\n💡 Browser left open for manual inspection');
+
+if (testsFailed > 0) {
+  process.exit(1);
+}
+
+// Exit immediately without waiting for browser
+process.exit(0);