npm - @ricardodeazambuja/browser-mcp-server - Versions diffs - 1.3.0 → 1.4.0 - Mend

@ricardodeazambuja/browser-mcp-server 1.3.0 → 1.4.0

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 (24) hide show

package/CHANGELOG-v1.4.0.md +8 -0
package/README.md +87 -6
package/package.json +3 -2
package/src/browser.js +2 -0
package/src/cdp.js +58 -0
package/src/index.js +2 -2
package/src/tools/docs.js +798 -0
package/src/tools/index.js +5 -1
package/src/tools/network.js +552 -0
package/src/tools/performance.js +517 -0
package/src/tools/security.js +470 -0
package/src/tools/storage.js +467 -0
package/src/tools/system.js +5 -1
package/src/utils.js +12 -1
package/tests/fixtures/test-network.html +48 -0
package/tests/fixtures/test-performance.html +61 -0
package/tests/fixtures/test-security.html +33 -0
package/tests/fixtures/test-storage.html +76 -0
package/tests/run-all.js +50 -0
package/tests/test-mcp.js +3 -2
package/tests/test-network.js +212 -0
package/tests/test-performance.js +254 -0
package/tests/test-security.js +203 -0
package/tests/test-storage.js +192 -0

package/tests/fixtures/test-storage.html ADDED Viewed

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Storage Test Page</title>
+</head>
+<body>
+    <h1>Storage Test Page</h1>
+    <p>This page creates IndexedDB and Cache Storage for testing.</p>
+    <div id="status"></div>
+    <script>
+        async function setupStorage() {
+            const status = document.getElementById('status');
+            status.innerHTML = 'Setting up storage...<br>';
+            try {
+                // Create IndexedDB
+                const dbRequest = indexedDB.open('testDB', 1);
+                dbRequest.onupgradeneeded = (event) => {
+                    const db = event.target.result;
+                    if (!db.objectStoreNames.contains('users')) {
+                        const objectStore = db.createObjectStore('users', { keyPath: 'id' });
+                        objectStore.createIndex('name', 'name', { unique: false });
+                    }
+                };
+                dbRequest.onsuccess = async (event) => {
+                    const db = event.target.result;
+                    const transaction = db.transaction(['users'], 'readwrite');
+                    const objectStore = transaction.objectStore('users');
+                    // Add some data
+                    objectStore.add({ id: 1, name: 'Alice', email: 'alice@example.com' });
+                    objectStore.add({ id: 2, name: 'Bob', email: 'bob@example.com' });
+                    status.innerHTML += '✓ IndexedDB created and populated<br>';
+                    // Create Cache Storage
+                    if ('caches' in window) {
+                        const cache = await caches.open('test-cache-v1');
+                        await cache.put('/test', new Response('Test data'));
+                        status.innerHTML += '✓ Cache Storage created<br>';
+                    }
+                    // Register Service Worker (if supported)
+                    if ('serviceWorker' in navigator) {
+                        try {
+                            // Note: Service worker registration requires HTTPS or localhost
+                            status.innerHTML += 'Service Worker registration skipped (requires HTTPS)<br>';
+                        } catch (e) {
+                            status.innerHTML += `Service Worker: ${e.message}<br>`;
+                        }
+                    }
+                    status.innerHTML += 'Storage setup complete!';
+                };
+                dbRequest.onerror = (event) => {
+                    status.innerHTML += `✗ IndexedDB error: ${event.target.error}<br>`;
+                };
+            } catch (error) {
+                status.innerHTML += `Error: ${error.message}`;
+            }
+        }
+        // Auto-run after page load
+        window.addEventListener('load', () => {
+            setTimeout(setupStorage, 500);
+        });
+    </script>
+</body>
+</html>

package/tests/run-all.js ADDED Viewed

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+/**
+ * Main Test Runner
+ * Runs all test files in the tests directory
+ */
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const testsDir = __dirname;
+const testFiles = fs.readdirSync(testsDir)
+    .filter(f => f.startsWith('test-') && f.endsWith('.js'))
+    .sort();
+console.log('🚀 Running all Browser MCP Server tests...\n');
+let passed = 0;
+let failed = 0;
+testFiles.forEach(file => {
+    console.log(`\n------------------------------------------------------------`);
+    console.log(`📄 Testing: ${file}`);
+    console.log(`------------------------------------------------------------\n`);
+    const result = spawnSync('node', [path.join(testsDir, file)], {
+        stdio: 'inherit'
+    });
+    if (result.status === 0) {
+        passed++;
+    } else {
+        failed++;
+        console.error(`\n❌ ${file} failed with exit code ${result.status}`);
+    }
+});
+console.log(`\n\n${'='.repeat(60)}`);
+console.log(`📊 Final Test Summary:`);
+console.log(`   ✅ Passed: ${passed}`);
+console.log(`   ❌ Failed: ${failed}`);
+console.log(`${'='.repeat(60)}\n`);
+if (failed > 0) {
+    process.exit(1);
+} else {
+    console.log('🎉 All test suites passed successfully!\n');
+    process.exit(0);
+}

package/tests/test-mcp.js CHANGED Viewed

@@ -51,6 +51,7 @@ async function runTests() {
   const responses = new Map();
   let testsCompleted = 0;
+  let toolCount = 0;
   const totalTests = 3;
   rl.on('line', (line) => {
@@ -75,7 +76,7 @@ async function runTests() {
         } else if (response.id === 2) {
           // Tools list response
-          const toolCount = response.result.tools.length;
+          toolCount = response.result.tools.length;
           console.log(`   ✅ Received ${toolCount} tools:`);
           response.result.tools.forEach(tool => {
             console.log(`      - ${tool.name}`);
@@ -102,7 +103,7 @@ async function runTests() {
             console.log(`\n✅ All tests passed! (${testsCompleted}/${totalTests})`);
             console.log('\n📊 Test Summary:');
             console.log('   ✅ MCP Protocol initialization');
-            console.log('   ✅ Tools listing (37 tools)');
+            console.log(`   ✅ Tools listing (${toolCount} tools)`);
             console.log('   ✅ Browser automation (health check)');

package/tests/test-network.js ADDED Viewed

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * Network Tools Test Suite
+ * Tests network monitoring, HAR export, and request blocking
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+const readline = require('readline');
+const serverPath = path.join(__dirname, '..', 'src', 'index.js');
+const proc = spawn('node', [serverPath], { stdio: ['pipe', 'pipe', 'pipe'] });
+proc.stderr.on('data', (data) => {
+    // Suppress stderr for cleaner test output
+});
+proc.on('error', (err) => {
+    console.error('Server error:', err);
+    process.exit(1);
+});
+const rl = readline.createInterface({ input: proc.stdout, terminal: false });
+let messageId = 1;
+let testStep = 0;
+function sendRequest(method, params) {
+    const request = { jsonrpc: '2.0', id: messageId++, method, params };
+    proc.stdin.write(JSON.stringify(request) + '\n');
+}
+console.log('🌐 Network Tools Test Suite\n');
+rl.on('line', (line) => {
+    try {
+        const response = JSON.parse(line);
+        if (response.method === 'notifications/resources/list_changed') return;
+        if (response.error) {
+            console.error('❌ Error:', response.error.message);
+            process.exit(1);
+        }
+        if (response.result && response.id) {
+            handleResponse(response);
+        }
+    } catch (e) {
+        // Ignore non-JSON lines
+    }
+});
+function handleResponse(response) {
+    const currentTest = steps[testStep];
+    if (!currentTest) return;
+    console.log(`➡️  ${currentTest.name}`);
+    try {
+        currentTest.verify(response);
+        console.log(`   ✅ Passed\n`);
+    } catch (err) {
+        console.error(`   ❌ Failed: ${err.message}`);
+        process.exit(1);
+    }
+    testStep++;
+    if (testStep < steps.length) {
+        setTimeout(() => {
+            sendRequest(steps[testStep].method, steps[testStep].params());
+        }, 500);
+    } else {
+        console.log('🎉 All network tests passed!');
+        proc.kill();
+        process.exit(0);
+    }
+}
+const steps = [
+    {
+        name: 'Initialize',
+        method: 'initialize',
+        params: () => ({
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'network-test', version: '1.0.0' }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Start Network Monitoring',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_net_start_monitoring',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            // Accept success, already active, or CDP error
+            if (!text.includes('monitoring started') && !text.includes('already active') && !text.includes('CDP Error')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Navigate to Network Test Page',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_navigate',
+            arguments: { url: 'file://' + path.join(__dirname, 'fixtures', 'test-network.html') }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Wait for Network Requests',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_wait',
+            arguments: { ms: 3000 }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Get Network Requests',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_net_get_requests',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            // Accept success, not active, or CDP error
+            if (!text.includes('totalCaptured') && !text.includes('not active') && !text.includes('CDP Error')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Export HAR',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_net_export_har',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            // Accept HAR export, not active warning, or error
+            if (!text.includes('HAR') && !text.includes('No network data') && !text.includes('Error')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Stop Network Monitoring',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_net_stop_monitoring',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            // Accept stopped message, not active, or error
+            if (!text.includes('stopped') && !text.includes('not active') && !text.includes('Error')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Set Request Blocking',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_net_set_request_blocking',
+            arguments: { patterns: ['*.jpg', '*.png'] }
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            // Accept success or error
+            if (!text.includes('blocking enabled') && !text.includes('Error')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Emulate Network Conditions',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_net_emulate_conditions',
+            arguments: {
+                offline: false,
+                latency: 100,
+                downloadThroughput: 1000000,
+                uploadThroughput: 500000
+            }
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            // Accept success or error
+            if (!text.includes('conditions applied') && !text.includes('Error')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    }
+];
+// Start tests
+setTimeout(() => sendRequest(steps[0].method, steps[0].params()), 500);
+// Timeout after 60 seconds
+setTimeout(() => {
+    console.error('\n❌ Test timeout');
+    proc.kill();
+    process.exit(1);
+}, 60000);

package/tests/test-performance.js ADDED Viewed

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * Performance Tools Test Suite
+ * Tests CPU profiling, heap snapshots, metrics, and code coverage
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+const readline = require('readline');
+const serverPath = path.join(__dirname, '..', 'src', 'index.js');
+const proc = spawn('node', [serverPath], { stdio: ['pipe', 'pipe', 'pipe'] });
+proc.stderr.on('data', (data) => {
+    // Suppress stderr for cleaner test output
+});
+proc.on('error', (err) => {
+    console.error('Server error:', err);
+    process.exit(1);
+});
+const rl = readline.createInterface({ input: proc.stdout, terminal: false });
+let messageId = 1;
+let testStep = 0;
+function sendRequest(method, params) {
+    const request = { jsonrpc: '2.0', id: messageId++, method, params };
+    proc.stdin.write(JSON.stringify(request) + '\n');
+}
+console.log('🔬 Performance Tools Test Suite\n');
+rl.on('line', (line) => {
+    try {
+        const response = JSON.parse(line);
+        if (response.method === 'notifications/resources/list_changed') return;
+        if (response.error) {
+            console.error('❌ Error:', response.error.message);
+            process.exit(1);
+        }
+        if (response.result && response.id) {
+            handleResponse(response);
+        }
+    } catch (e) {
+        // Ignore non-JSON lines
+    }
+});
+function handleResponse(response) {
+    const currentTest = steps[testStep];
+    if (!currentTest) return;
+    console.log(`➡️  ${currentTest.name}`);
+    try {
+        currentTest.verify(response);
+        console.log(`   ✅ Passed\n`);
+    } catch (err) {
+        console.error(`   ❌ Failed: ${err.message}`);
+        process.exit(1);
+    }
+    testStep++;
+    if (testStep < steps.length) {
+        setTimeout(() => {
+            sendRequest(steps[testStep].method, steps[testStep].params());
+        }, 500);
+    } else {
+        console.log('🎉 All performance tests passed!');
+        proc.kill();
+        process.exit(0);
+    }
+}
+const steps = [
+    {
+        name: 'Initialize',
+        method: 'initialize',
+        params: () => ({
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'performance-test', version: '1.0.0' }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Navigate to Performance Test Page',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_navigate',
+            arguments: { url: 'file://' + path.join(__dirname, 'fixtures', 'test-performance.html') }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Wait for Page Load',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_wait',
+            arguments: { ms: 1000 }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Start CPU Profiling',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_perf_start_profile',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            if (res.result.isError) {
+                throw new Error('CPU profiling failed: ' + text);
+            }
+            if (!text.includes('profiling started') && !text.includes('already active')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Wait for Execution',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_wait',
+            arguments: { ms: 2000 }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Stop CPU Profiling',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_perf_stop_profile',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            if (res.result.isError) {
+                throw new Error('Stop CPU profiling failed: ' + text);
+            }
+            if (!text.includes('totalNodes') && !text.includes('not active')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Get Heap Usage',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_perf_get_heap_usage',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            if (res.result.isError) {
+                throw new Error('Get heap usage failed: ' + text);
+            }
+            if (!text.includes('usedSize')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Get Runtime Metrics',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_perf_get_metrics',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            if (res.result.isError) {
+                throw new Error('Get runtime metrics failed: ' + text);
+            }
+            if (!text.includes('Nodes') && !text.includes('JSHeap')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Get Performance Metrics',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_perf_get_performance_metrics',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            if (res.result.isError) {
+                throw new Error('Get performance metrics failed: ' + text);
+            }
+            if (!text.includes('navigation')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Start Code Coverage',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_perf_start_coverage',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            if (res.result.isError) {
+                throw new Error('Start code coverage failed: ' + text);
+            }
+            if (!text.includes('coverage started') && !text.includes('already active')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    },
+    {
+        name: 'Wait for Coverage Collection',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_wait',
+            arguments: { ms: 1000 }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Stop Code Coverage',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_perf_stop_coverage',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const text = res.result.content[0].text;
+            if (res.result.isError) {
+                throw new Error('Stop code coverage failed: ' + text);
+            }
+            if (!text.includes('javascript') && !text.includes('not active')) {
+                throw new Error('Unexpected response: ' + text.substring(0, 100));
+            }
+        }
+    }
+];
+// Start tests
+setTimeout(() => sendRequest(steps[0].method, steps[0].params()), 500);
+// Timeout after 60 seconds
+setTimeout(() => {
+    console.error('\n❌ Test timeout');
+    proc.kill();
+    process.exit(1);
+}, 60000);