npm - mcpbrowser - Versions diffs - 0.2.18 → 0.2.21 - Mend

mcpbrowser 0.2.18 → 0.2.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/.github/workflows/test.yml +33 -0
package/README.md +1 -1
package/extension/package.json +1 -1
package/extension/src/extension.js +1 -1
package/package.json +4 -2
package/server.json +1 -1
package/src/mcp-browser.js +185 -68
package/test-mcp.js +63 -0
package/tests/domain-tab-pooling.test.js +329 -0
package/tests/integration.test.js +158 -0
package/tests/mcp-server.test.js +154 -0
package/tests/prepare-html.test.js +307 -0

package/tests/domain-tab-pooling.test.js ADDED Viewed

@@ -0,0 +1,329 @@
+/**
+ * UNIT TESTS - Automated tests using mock objects (NO browser required)
+ * These tests validate domain pooling logic without opening Chrome
+ * Run with: node tests/domain-tab-pooling.test.js
+ */
+// Mock domain pages map and browser
+class MockPage {
+  constructor(url) {
+    this._url = url;
+    this._closed = false;
+    this._content = '';
+  }
+  url() { return this._url; }
+  isClosed() { return this._closed; }
+  close() { this._closed = true; }
+  async bringToFront() {}
+  async goto(url) {
+    this._url = url;
+    // Simulate eng.ms page with multiple same-domain links
+    if (url.includes('eng.ms/docs/products/geneva')) {
+      this._content = `
+        <html>
+          <body>
+            <h1>Geneva Documentation</h1>
+            <a href="https://eng.ms/docs/products/geneva/getting-started">Getting Started</a>
+            <a href="https://eng.ms/docs/products/geneva/configuration">Configuration</a>
+            <a href="https://eng.ms/docs/products/geneva/monitoring">Monitoring</a>
+            <a href="https://eng.ms/docs/products/geneva/alerts">Alerts</a>
+            <a href="https://eng.ms/docs/products/geneva/best-practices">Best Practices</a>
+            <a href="https://external.com/link">External Link</a>
+          </body>
+        </html>
+      `;
+    }
+  }
+  async evaluate(fn) {
+    if (this._content) {
+      return fn.toString().includes('outerHTML') ? this._content : fn();
+    }
+    return fn();
+  }
+}
+class MockBrowser {
+  constructor() {
+    this._pages = [];
+  }
+  async newPage() {
+    const page = new MockPage('about:blank');
+    this._pages.push(page);
+    return page;
+  }
+  async pages() {
+    return this._pages;
+  }
+}
+// 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}`);
+  }
+}
+// Tests
+async function runTests() {
+  console.log('🚀 Starting Domain Tab Pooling Tests\n');
+  await test('Should create new tab for first domain', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    const url = 'https://github.com/user/repo';
+    const hostname = new URL(url).hostname;
+    // No existing page for this domain
+    assert(!domainPages.has(hostname), 'Domain should not exist in map initially');
+    // Create new page
+    const page = await browser.newPage();
+    domainPages.set(hostname, page);
+    assert(domainPages.has(hostname), 'Domain should be added to map');
+    assert(domainPages.get(hostname) === page, 'Correct page should be stored');
+  });
+  await test('Should reuse tab for same domain', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    const hostname = 'github.com';
+    // Create first page for domain
+    const page1 = await browser.newPage();
+    await page1.goto('https://github.com/repo1');
+    domainPages.set(hostname, page1);
+    // Try to fetch another URL from same domain
+    const existingPage = domainPages.get(hostname);
+    assert(existingPage === page1, 'Should return same page for same domain');
+    assert(!existingPage.isClosed(), 'Page should still be open');
+  });
+  await test('Should create new tab for different domain', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    // First domain
+    const page1 = await browser.newPage();
+    await page1.goto('https://github.com/repo');
+    domainPages.set('github.com', page1);
+    // Second domain - should create new tab
+    const hostname2 = 'microsoft.com';
+    assert(!domainPages.has(hostname2), 'Second domain should not exist yet');
+    const page2 = await browser.newPage();
+    await page2.goto('https://microsoft.com/docs');
+    domainPages.set(hostname2, page2);
+    assert(domainPages.has('github.com'), 'First domain should still exist');
+    assert(domainPages.has('microsoft.com'), 'Second domain should now exist');
+    assert(page1 !== page2, 'Should be different page objects');
+    assert(!page1.isClosed(), 'First page should still be open');
+  });
+  await test('Should reuse tab when returning to previous domain', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    // Domain 1
+    const page1 = await browser.newPage();
+    domainPages.set('github.com', page1);
+    // Domain 2
+    const page2 = await browser.newPage();
+    domainPages.set('microsoft.com', page2);
+    // Back to domain 1
+    const reusedPage = domainPages.get('github.com');
+    assert(reusedPage === page1, 'Should reuse original page for domain 1');
+    assert(!reusedPage.isClosed(), 'Reused page should still be open');
+    assert(domainPages.size === 2, 'Should have 2 domains in map');
+  });
+  await test('Should handle closed tabs gracefully', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    const hostname = 'github.com';
+    // Create and store page
+    const page = await browser.newPage();
+    domainPages.set(hostname, page);
+    // Simulate user closing the tab
+    page.close();
+    // Check if page is closed
+    const existingPage = domainPages.get(hostname);
+    if (existingPage && existingPage.isClosed()) {
+      domainPages.delete(hostname);
+    }
+    assert(!domainPages.has(hostname), 'Closed page should be removed from map');
+  });
+  await test('Should extract hostname correctly from URLs', async () => {
+    const testCases = [
+      { url: 'https://github.com/user/repo', expected: 'github.com' },
+      { url: 'https://microsoft.com/docs/page', expected: 'microsoft.com' },
+      { url: 'https://subdomain.example.com/path', expected: 'subdomain.example.com' },
+      { url: 'http://localhost:3000/test', expected: 'localhost' },
+    ];
+    for (const { url, expected } of testCases) {
+      const hostname = new URL(url).hostname;
+      assert(hostname === expected, `Hostname for ${url} should be ${expected}, got ${hostname}`);
+    }
+  });
+  await test('Should handle invalid URLs', async () => {
+    let errorThrown = false;
+    try {
+      new URL('not-a-valid-url');
+    } catch (error) {
+      errorThrown = true;
+    }
+    assert(errorThrown, 'Invalid URL should throw error');
+  });
+  await test('Should clear all pages on browser disconnect', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    // Add multiple domains
+    const page1 = await browser.newPage();
+    domainPages.set('github.com', page1);
+    const page2 = await browser.newPage();
+    domainPages.set('microsoft.com', page2);
+    const page3 = await browser.newPage();
+    domainPages.set('google.com', page3);
+    assert(domainPages.size === 3, 'Should have 3 domains before disconnect');
+    // Simulate browser disconnect
+    domainPages.clear();
+    assert(domainPages.size === 0, 'All domains should be cleared after disconnect');
+  });
+  await test('Should handle multiple requests to same domain', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    const hostname = 'github.com';
+    // First request
+    const page = await browser.newPage();
+    await page.goto('https://github.com/repo1');
+    domainPages.set(hostname, page);
+    // Multiple subsequent requests to same domain
+    for (let i = 2; i <= 5; i++) {
+      const existingPage = domainPages.get(hostname);
+      assert(existingPage === page, `Request ${i} should reuse same page`);
+      await existingPage.goto(`https://github.com/repo${i}`);
+    }
+    assert(domainPages.size === 1, 'Should still have only 1 domain in map');
+  });
+  await test('Should open internal eng.ms page', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    const url = 'https://eng.ms/docs/products/geneva';
+    const hostname = new URL(url).hostname;
+    // First request to eng.ms domain
+    assert(!domainPages.has(hostname), 'eng.ms domain should not exist initially');
+    const page = await browser.newPage();
+    await page.goto(url);
+    domainPages.set(hostname, page);
+    assert(domainPages.has(hostname), 'eng.ms domain should be added to map');
+    assert(page.url() === url, 'Page URL should match requested URL');
+    assert(!page.isClosed(), 'Page should remain open');
+  });
+  await test('Should extract and load 5 URLs from same domain', async () => {
+    const domainPages = new Map();
+    const browser = new MockBrowser();
+    const initialUrl = 'https://eng.ms/docs/products/geneva';
+    const hostname = new URL(initialUrl).hostname;
+    // First: Load the initial page
+    const page = await browser.newPage();
+    await page.goto(initialUrl);
+    domainPages.set(hostname, page);
+    // Extract HTML content
+    const html = await page.evaluate(() => document.documentElement.outerHTML);
+    assert(html.includes('Geneva Documentation'), 'Page should contain Geneva content');
+    // Extract URLs from the same domain
+    const urlPattern = /href="(https:\/\/eng\.ms\/[^"]+)"/g;
+    const extractedUrls = [];
+    let match;
+    while ((match = urlPattern.exec(html)) !== null && extractedUrls.length < 5) {
+      extractedUrls.push(match[1]);
+    }
+    assert(extractedUrls.length === 5, `Should extract 5 URLs, got ${extractedUrls.length}`);
+    // Verify all URLs are from eng.ms domain
+    for (const url of extractedUrls) {
+      const urlHostname = new URL(url).hostname;
+      assert(urlHostname === hostname, `All URLs should be from ${hostname}, got ${urlHostname}`);
+    }
+    // Load each of the 5 URLs and verify tab reuse
+    const reusedPage = domainPages.get(hostname);
+    assert(reusedPage === page, 'Should reuse same page for same domain');
+    for (let i = 0; i < extractedUrls.length; i++) {
+      await reusedPage.goto(extractedUrls[i]);
+      assert(reusedPage.url() === extractedUrls[i], `URL ${i+1} should be loaded: ${extractedUrls[i]}`);
+      assert(!reusedPage.isClosed(), `Page should remain open after loading URL ${i+1}`);
+    }
+    assert(domainPages.size === 1, 'Should still have only 1 domain (eng.ms) in map after all loads');
+  });
+  // 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);
+  }
+}
+// Run tests
+runTests().catch(error => {
+  console.error('Test suite failed:', error);
+  process.exit(1);
+});

package/tests/integration.test.js ADDED Viewed

@@ -0,0 +1,158 @@
+/**
+ * Integration tests - REQUIRES REAL CHROME AND USER AUTHENTICATION
+ * These tests will actually open Chrome browser and require manual login
+ * Run with: node tests/integration.test.js
+ */
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { fetchPage } from '../src/mcp-browser.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 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}`);
+  }
+}
+// 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`);
+      }
+    });
+  } 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');
+    if (testsFailed > 0) {
+      process.exit(1);
+    }
+    // Exit immediately without waiting for browser
+    process.exit(0);
+  }
+}
+// Run tests
+runIntegrationTests().catch(error => {
+  console.error('Test suite failed:', error);
+  process.exit(1);
+});

package/tests/mcp-server.test.js ADDED Viewed

@@ -0,0 +1,154 @@
+import { describe, it } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+describe('MCP Server', () => {
+  it('should start and respond to initialize request', async () => {
+    const mcpProcess = spawn('node', [join(__dirname, '..', 'src', 'mcp-browser.js')], {
+      stdio: ['pipe', 'pipe', 'inherit']
+    });
+    try {
+      const initRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' }
+        }
+      };
+      const response = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('Server did not respond to initialize request within 5 seconds'));
+        }, 5000);
+        let buffer = '';
+        mcpProcess.stdout.on('data', (data) => {
+          buffer += data.toString();
+          const lines = buffer.split('\n');
+          for (const line of lines) {
+            if (line.trim()) {
+              try {
+                const parsed = JSON.parse(line);
+                if (parsed.id === 1) {
+                  clearTimeout(timeout);
+                  resolve(parsed);
+                  return;
+                }
+              } catch (e) {
+                // Not JSON, continue
+              }
+            }
+          }
+        });
+        mcpProcess.on('error', (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+        mcpProcess.on('exit', (code) => {
+          clearTimeout(timeout);
+          reject(new Error(`Server exited with code ${code} before responding`));
+        });
+        mcpProcess.stdin.write(JSON.stringify(initRequest) + '\n');
+      });
+      assert.ok(response.result, 'Initialize response should have result');
+      assert.equal(response.result.protocolVersion, '2024-11-05', 'Protocol version should match');
+      assert.ok(response.result.serverInfo, 'Server info should be present');
+      assert.equal(response.result.serverInfo.name, 'MCPBrowser', 'Server name should be MCPBrowser');
+    } finally {
+      mcpProcess.kill();
+    }
+  });
+  it('should respond to tools/list request', async () => {
+    const mcpProcess = spawn('node', [join(__dirname, '..', 'src', 'mcp-browser.js')], {
+      stdio: ['pipe', 'pipe', 'inherit']
+    });
+    try {
+      // First initialize
+      const initRequest = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'test', version: '1.0' }
+        }
+      };
+      mcpProcess.stdin.write(JSON.stringify(initRequest) + '\n');
+      // Wait a bit for initialization
+      await new Promise(resolve => setTimeout(resolve, 500));
+      // Then request tools list
+      const toolsRequest = {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'tools/list',
+        params: {}
+      };
+      const response = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('Server did not respond to tools/list request within 5 seconds'));
+        }, 5000);
+        let buffer = '';
+        mcpProcess.stdout.on('data', (data) => {
+          buffer += data.toString();
+          const lines = buffer.split('\n');
+          for (const line of lines) {
+            if (line.trim()) {
+              try {
+                const parsed = JSON.parse(line);
+                if (parsed.id === 2) {
+                  clearTimeout(timeout);
+                  resolve(parsed);
+                  return;
+                }
+              } catch (e) {
+                // Not JSON, continue
+              }
+            }
+          }
+        });
+        mcpProcess.on('error', (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+        mcpProcess.stdin.write(JSON.stringify(toolsRequest) + '\n');
+      });
+      assert.ok(response.result, 'Tools/list response should have result');
+      assert.ok(response.result.tools, 'Result should have tools array');
+      assert.ok(Array.isArray(response.result.tools), 'Tools should be an array');
+      assert.ok(response.result.tools.length > 0, 'Should have at least one tool');
+      const fetchTool = response.result.tools.find(t => t.name === 'fetch_webpage_protected');
+      assert.ok(fetchTool, 'Should have fetch_webpage_protected tool');
+      assert.ok(fetchTool.description, 'Tool should have description');
+      assert.ok(fetchTool.inputSchema, 'Tool should have input schema');
+    } finally {
+      mcpProcess.kill();
+    }
+  });
+});