@ricardodeazambuja/browser-mcp-server 1.0.3 → 1.4.0

package/tests/test-media-tools.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+/**
+ * Media Awareness Test Suite
+ * Tests browser_get_media_summary, browser_control_media, browser_get_audio_analysis
+ */
+
+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) => {
+    console.error(data.toString().trim());
+});
+
+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('🌐 Media Awareness 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 media tests passed!');
+        proc.kill();
+        process.exit(0);
+    }
+}
+
+const steps = [
+    {
+        name: 'Initialize',
+        method: 'initialize',
+        params: () => ({
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'test-suite', version: '1.0.0' }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Navigate to Local Media Test',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_navigate',
+            arguments: { url: 'file://' + path.join(__dirname, 'fixtures', 'test-media.html') }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Wait for Audio Element',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_wait_for_selector',
+            arguments: { selector: 'audio', timeout: 10000 }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Get Media Summary',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_get_media_summary',
+            arguments: {}
+        }),
+        verify: (res) => {
+            const summary = JSON.parse(res.result.content[0].text);
+            console.log(`      Found ${summary.length} media element(s)`);
+            if (!Array.isArray(summary)) throw new Error('Result is not an array');
+        }
+    },
+    {
+        name: 'Play Media',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_control_media',
+            arguments: { selector: 'audio', action: 'play' }
+        }),
+        verify: (res) => {
+            const result = JSON.parse(res.result.content[0].text);
+            if (result.status !== 'playing') throw new Error('Failed to play');
+        }
+    },
+    {
+        name: 'Wait for Playback',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_wait',
+            arguments: { ms: 1000 }
+        }),
+        verify: () => { }
+    },
+    {
+        name: 'Analyze Audio',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_get_audio_analysis',
+            arguments: { durationMs: 500 }
+        }),
+        verify: (res) => {
+            const analysis = JSON.parse(res.result.content[0].text);
+            if (typeof analysis.averageVolume !== 'number') throw new Error('Invalid analysis');
+        }
+    },
+    {
+        name: 'Pause Media',
+        method: 'tools/call',
+        params: () => ({
+            name: 'browser_control_media',
+            arguments: { selector: 'audio', action: 'pause' }
+        }),
+        verify: (res) => {
+            const result = JSON.parse(res.result.content[0].text);
+            if (result.status !== 'paused') throw new Error('Failed to pause');
+        }
+    }
+];
+
+// Start tests
+setTimeout(() => sendRequest(steps[0].method, steps[0].params()), 500);

package/tests/test-network.js

@@ -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

@@ -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);