@ricardodeazambuja/browser-mcp-server 1.3.0 → 1.4.0

package/src/tools/storage.js

@@ -0,0 +1,467 @@
+/**
+ * Storage & Service Workers Tools (CDP-based)
+ * IndexedDB, Cache Storage, Service Worker inspection and control
+ */
+
+const { connectToBrowser } = require('../browser');
+const { getCDPSession } = require('../cdp');
+const { debugLog } = require('../utils');
+
+const definitions = [
+    {
+        name: 'browser_storage_get_indexeddb',
+        description: 'Inspect IndexedDB databases and their data (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                databaseName: {
+                    type: 'string',
+                    description: 'Specific database to inspect (optional)'
+                },
+                objectStoreName: {
+                    type: 'string',
+                    description: 'Specific object store to query (optional, requires databaseName)'
+                }
+            },
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_storage_get_cache_storage',
+        description: 'List Cache Storage API caches and their entries (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cacheName: {
+                    type: 'string',
+                    description: 'Specific cache to inspect (optional)'
+                }
+            },
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_storage_delete_cache',
+        description: 'Delete a specific cache from Cache Storage (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cacheName: {
+                    type: 'string',
+                    description: 'Cache name to delete'
+                }
+            },
+            required: ['cacheName'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_storage_get_service_workers',
+        description: 'Get service worker registrations and their state (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_storage_unregister_service_worker',
+        description: 'Unregister a service worker (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                scopeURL: {
+                    type: 'string',
+                    description: 'Scope URL of service worker to unregister'
+                }
+            },
+            required: ['scopeURL'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    }
+];
+
+const handlers = {
+    browser_storage_get_indexeddb: async (args) => {
+        try {
+            const { page } = await connectToBrowser();
+            const cdp = await getCDPSession();
+
+            // Get security origin for current page
+            const origin = await page.evaluate(() => window.location.origin);
+
+            // Request database names
+            const { databaseNames } = await cdp.send('IndexedDB.requestDatabaseNames', {
+                securityOrigin: origin
+            });
+
+            if (databaseNames.length === 0) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: 'No IndexedDB databases found for this origin.\n\nThe page may not be using IndexedDB.'
+                    }]
+                };
+            }
+
+            // If no specific database requested, list all databases
+            if (!args.databaseName) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `📊 IndexedDB Databases:\n\n${JSON.stringify({ origin, databases: databaseNames }, null, 2)}\n\nUse databaseName parameter to inspect a specific database.`
+                    }]
+                };
+            }
+
+            // Get database structure
+            const dbInfo = await cdp.send('IndexedDB.requestDatabase', {
+                securityOrigin: origin,
+                databaseName: args.databaseName
+            });
+
+            if (!args.objectStoreName) {
+                // Return database structure
+                const structure = {
+                    name: dbInfo.databaseWithObjectStores.name,
+                    version: dbInfo.databaseWithObjectStores.version,
+                    objectStores: dbInfo.databaseWithObjectStores.objectStores.map(store => ({
+                        name: store.name,
+                        keyPath: store.keyPath,
+                        autoIncrement: store.autoIncrement,
+                        indexes: store.indexes.map(idx => ({
+                            name: idx.name,
+                            keyPath: idx.keyPath,
+                            unique: idx.unique,
+                            multiEntry: idx.multiEntry
+                        }))
+                    }))
+                };
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `📊 IndexedDB Database Structure:\n\n${JSON.stringify(structure, null, 2)}\n\nUse objectStoreName parameter to query data from a specific object store.`
+                    }]
+                };
+            }
+
+            // Get object store data
+            const { objectStoreDataEntries, hasMore } = await cdp.send('IndexedDB.requestData', {
+                securityOrigin: origin,
+                databaseName: args.databaseName,
+                objectStoreName: args.objectStoreName,
+                indexName: '',
+                skipCount: 0,
+                pageSize: 100
+            });
+
+            const data = {
+                objectStore: args.objectStoreName,
+                entries: objectStoreDataEntries.length,
+                hasMore: hasMore,
+                data: objectStoreDataEntries.map(entry => ({
+                    key: entry.key,
+                    primaryKey: entry.primaryKey,
+                    value: entry.value
+                }))
+            };
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: `📊 IndexedDB Data:\n\n${JSON.stringify(data, null, 2)}\n\nNote: Limited to 100 entries.${hasMore ? ' More entries available.' : ''}`
+                }]
+            };
+        } catch (error) {
+            debugLog(`CDP error in browser_storage_get_indexeddb: ${error.message}`);
+            return {
+                content: [{
+                    type: 'text',
+                    text: `❌ CDP Error: ${error.message}\n\nPossible causes:\n- IndexedDB not accessible\n- Invalid database or object store name\n- CDP session disconnected`
+                }],
+                isError: true
+            };
+        }
+    },
+
+    browser_storage_get_cache_storage: async (args) => {
+        try {
+            const { page } = await connectToBrowser();
+            const cdp = await getCDPSession();
+
+            // Get security origin
+            const origin = await page.evaluate(() => window.location.origin);
+
+            // Request cache names
+            const { caches } = await cdp.send('CacheStorage.requestCacheNames', {
+                securityOrigin: origin
+            });
+
+            if (caches.length === 0) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: 'No Cache Storage caches found for this origin.\n\nThe page may not be using Cache Storage API.'
+                    }]
+                };
+            }
+
+            // If no specific cache requested, list all caches
+            if (!args.cacheName) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `📊 Cache Storage Caches:\n\n${JSON.stringify({ origin, caches: caches.map(c => c.cacheName) }, null, 2)}\n\nUse cacheName parameter to inspect entries in a specific cache.`
+                    }]
+                };
+            }
+
+            // Find the cache ID
+            const cache = caches.find(c => c.cacheName === args.cacheName);
+            if (!cache) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `⚠️ Cache "${args.cacheName}" not found.\n\nAvailable caches:\n${caches.map(c => `  • ${c.cacheName}`).join('\n')}`
+                    }]
+                };
+            }
+
+            // Get cache entries
+            const { cacheDataEntries, returnCount } = await cdp.send('CacheStorage.requestEntries', {
+                cacheId: cache.cacheId,
+                skipCount: 0,
+                pageSize: 50
+            });
+
+            const entries = {
+                cacheName: args.cacheName,
+                entryCount: returnCount,
+                entries: cacheDataEntries.map(entry => ({
+                    requestURL: entry.requestURL,
+                    requestMethod: entry.requestMethod,
+                    responseStatus: entry.responseStatus,
+                    responseStatusText: entry.responseStatusText,
+                    responseType: entry.responseType
+                }))
+            };
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: `📊 Cache Storage Entries:\n\n${JSON.stringify(entries, null, 2)}\n\nNote: Limited to 50 entries.`
+                }]
+            };
+        } catch (error) {
+            debugLog(`CDP error in browser_storage_get_cache_storage: ${error.message}`);
+            return {
+                content: [{
+                    type: 'text',
+                    text: `❌ CDP Error: ${error.message}\n\nPossible causes:\n- Cache Storage not accessible\n- Invalid cache name\n- CDP session disconnected`
+                }],
+                isError: true
+            };
+        }
+    },
+
+    browser_storage_delete_cache: async (args) => {
+        try {
+            const { page } = await connectToBrowser();
+            const cdp = await getCDPSession();
+
+            // Get security origin
+            const origin = await page.evaluate(() => window.location.origin);
+
+            // Request cache names to find the cache ID
+            const { caches } = await cdp.send('CacheStorage.requestCacheNames', {
+                securityOrigin: origin
+            });
+
+            const cache = caches.find(c => c.cacheName === args.cacheName);
+            if (!cache) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `⚠️ Cache "${args.cacheName}" not found.\n\nAvailable caches:\n${caches.map(c => `  • ${c.cacheName}`).join('\n')}`
+                    }]
+                };
+            }
+
+            // Delete the cache
+            await cdp.send('CacheStorage.deleteCache', {
+                cacheId: cache.cacheId
+            });
+
+            debugLog(`Deleted cache: ${args.cacheName}`);
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✅ Cache deleted successfully: ${args.cacheName}`
+                }]
+            };
+        } catch (error) {
+            debugLog(`CDP error in browser_storage_delete_cache: ${error.message}`);
+            return {
+                content: [{
+                    type: 'text',
+                    text: `❌ CDP Error: ${error.message}\n\nFailed to delete cache.`
+                }],
+                isError: true
+            };
+        }
+    },
+
+    browser_storage_get_service_workers: async (args) => {
+        try {
+            const { page } = await connectToBrowser();
+            const cdp = await getCDPSession();
+
+            // Enable ServiceWorker domain
+            await cdp.send('ServiceWorker.enable');
+
+            // Get service worker registrations
+            const { registrations } = await cdp.send('ServiceWorker.getServiceWorker', {});
+
+            if (registrations.length === 0) {
+                await cdp.send('ServiceWorker.disable');
+                return {
+                    content: [{
+                        type: 'text',
+                        text: 'No service workers found.\n\nThe page may not have registered any service workers.'
+                    }]
+                };
+            }
+
+            const workers = registrations.map(reg => ({
+                registrationId: reg.registrationId,
+                scopeURL: reg.scopeURL,
+                isDeleted: reg.isDeleted
+            }));
+
+            await cdp.send('ServiceWorker.disable');
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: `📊 Service Workers:\n\n${JSON.stringify(workers, null, 2)}`
+                }]
+            };
+        } catch (error) {
+            debugLog(`CDP error in browser_storage_get_service_workers: ${error.message}`);
+
+            // Try alternative approach using page.evaluate
+            try {
+                const { page } = await connectToBrowser();
+                const swInfo = await page.evaluate(async () => {
+                    if (!('serviceWorker' in navigator)) {
+                        return { supported: false };
+                    }
+
+                    const registrations = await navigator.serviceWorker.getRegistrations();
+                    return {
+                        supported: true,
+                        registrations: registrations.map(reg => ({
+                            scope: reg.scope,
+                            active: reg.active ? {
+                                scriptURL: reg.active.scriptURL,
+                                state: reg.active.state
+                            } : null,
+                            installing: reg.installing ? {
+                                scriptURL: reg.installing.scriptURL,
+                                state: reg.installing.state
+                            } : null,
+                            waiting: reg.waiting ? {
+                                scriptURL: reg.waiting.scriptURL,
+                                state: reg.waiting.state
+                            } : null
+                        }))
+                    };
+                });
+
+                if (!swInfo.supported) {
+                    return {
+                        content: [{
+                            type: 'text',
+                            text: '⚠️ Service Workers not supported in this browser/context.'
+                        }]
+                    };
+                }
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `📊 Service Workers:\n\n${JSON.stringify(swInfo.registrations, null, 2)}`
+                    }]
+                };
+            } catch (fallbackError) {
+                debugLog(`Fallback error in browser_storage_get_service_workers: ${fallbackError.message}`);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `❌ Error: ${error.message}\n\nCould not retrieve service worker information.`
+                    }],
+                    isError: true
+                };
+            }
+        }
+    },
+
+    browser_storage_unregister_service_worker: async (args) => {
+        try {
+            const { page } = await connectToBrowser();
+
+            // Use page.evaluate to unregister via JavaScript API
+            const result = await page.evaluate(async (scopeURL) => {
+                if (!('serviceWorker' in navigator)) {
+                    return { success: false, error: 'Service Workers not supported' };
+                }
+
+                const registrations = await navigator.serviceWorker.getRegistrations();
+                const registration = registrations.find(reg => reg.scope === scopeURL);
+
+                if (!registration) {
+                    return { success: false, error: 'Service worker not found for scope: ' + scopeURL };
+                }
+
+                const unregistered = await registration.unregister();
+                return { success: unregistered };
+            }, args.scopeURL);
+
+            if (!result.success) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: `⚠️ ${result.error}`
+                    }]
+                };
+            }
+
+            debugLog(`Unregistered service worker: ${args.scopeURL}`);
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✅ Service worker unregistered successfully\n\nScope: ${args.scopeURL}`
+                }]
+            };
+        } catch (error) {
+            debugLog(`Error in browser_storage_unregister_service_worker: ${error.message}`);
+            return {
+                content: [{
+                    type: 'text',
+                    text: `❌ Error: ${error.message}\n\nFailed to unregister service worker.`
+                }],
+                isError: true
+            };
+        }
+    }
+};
+
+module.exports = { definitions, handlers };

package/src/tools/system.js

@@ -104,6 +104,10 @@ const handlers = {
             browserProfile = process.env.MCP_BROWSER_PROFILE || `${os.tmpdir()}/chrome-mcp-profile`;
         }
 
+        // Get dynamic tool count (loaded at runtime to avoid circular dependency)
+        const { tools } = require('./index');
+        const toolCount = tools.length;
+
         return {
             content: [{
                 type: 'text',
@@ -113,7 +117,7 @@ const handlers = {
                     `✅ Chrome: Port 9222\n` +
                     `✅ Profile: ${browserProfile}\n` +
                     `✅ Current page: ${url}\n\n` +
-                    `All 37 browser tools are ready to use!`
+                    `All ${toolCount} browser tools are ready to use!`
             }]
         };
     },

package/src/utils.js

@@ -4,6 +4,16 @@
 
 const fs = require('fs');
 const os = require('os');
+const path = require('path');
+
+// Get version from package.json
+let version = 'unknown';
+try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+    version = pkg.version;
+} catch (error) {
+    // Fallback if package.json cannot be read
+}
 
 // Log file location
 const logFile = `${os.tmpdir()}/mcp-browser-server.log`;
@@ -116,5 +126,6 @@ module.exports = {
     loadPlaywright,
     getPlaywrightPath,
     findChromeExecutable,
-    logFile
+    logFile,
+    version
 };

package/tests/fixtures/test-network.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Network Test Page</title>
+</head>
+<body>
+    <h1>Network Test Page</h1>
+    <p>This page makes multiple network requests for testing.</p>
+    <div id="status"></div>
+
+    <script>
+        async function makeNetworkRequests() {
+            const status = document.getElementById('status');
+            status.innerHTML = 'Making network requests...<br>';
+
+            try {
+                // Make multiple fetch requests
+                const urls = [
+                    'https://jsonplaceholder.typicode.com/posts/1',
+                    'https://jsonplaceholder.typicode.com/posts/2',
+                    'https://jsonplaceholder.typicode.com/users/1'
+                ];
+
+                for (const url of urls) {
+                    try {
+                        const response = await fetch(url);
+                        const data = await response.json();
+                        status.innerHTML += `✓ Fetched: ${url}<br>`;
+                    } catch (e) {
+                        status.innerHTML += `✗ Failed: ${url} - ${e.message}<br>`;
+                    }
+                }
+
+                status.innerHTML += 'Network requests completed!';
+            } catch (error) {
+                status.innerHTML += `Error: ${error.message}`;
+            }
+        }
+
+        // Auto-run after page load
+        window.addEventListener('load', () => {
+            setTimeout(makeNetworkRequests, 500);
+        });
+    </script>
+</body>
+</html>

package/tests/fixtures/test-performance.html

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Performance Test Page</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            padding: 20px;
+        }
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Performance Test Page</h1>
+        <p>This page is used for testing CPU profiling and performance metrics.</p>
+        <button id="heavy-compute">Run Heavy Computation</button>
+        <div id="output"></div>
+    </div>
+
+    <script>
+        // Heavy computation for CPU profiling test
+        function fibonacci(n) {
+            if (n <= 1) return n;
+            return fibonacci(n - 1) + fibonacci(n - 2);
+        }
+
+        function performHeavyComputation() {
+            const start = Date.now();
+            const result = fibonacci(35);
+            const duration = Date.now() - start;
+            document.getElementById('output').innerHTML =
+                `Computed fibonacci(35) = ${result} in ${duration}ms`;
+        }
+
+        // Auto-run computation for testing
+        document.getElementById('heavy-compute').addEventListener('click', performHeavyComputation);
+
+        // Run automatically after a short delay
+        setTimeout(performHeavyComputation, 100);
+
+        // Create some DOM nodes for metrics testing
+        for (let i = 0; i < 100; i++) {
+            const div = document.createElement('div');
+            div.textContent = `Node ${i}`;
+            div.style.display = 'none';
+            document.body.appendChild(div);
+        }
+
+        // Add event listeners for metrics testing
+        for (let i = 0; i < 50; i++) {
+            document.body.addEventListener('click', () => {});
+        }
+    </script>
+</body>
+</html>

package/tests/fixtures/test-security.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self' 'unsafe-inline'">
+    <title>Security Test Page</title>
+</head>
+<body>
+    <h1>Security Test Page</h1>
+    <p>This page is used for testing security features.</p>
+    <div id="status"></div>
+
+    <script>
+        // This inline script is allowed by CSP
+        document.getElementById('status').innerHTML = 'Page loaded successfully';
+
+        // Attempt to trigger CSP violation by trying to load external script
+        // (This will be blocked and create a CSP violation)
+        try {
+            const script = document.createElement('script');
+            script.src = 'https://example.com/external.js';
+            document.head.appendChild(script);
+        } catch (e) {
+            console.log('CSP blocked external script');
+        }
+
+        // Log security info
+        console.log('Page protocol:', window.location.protocol);
+        console.log('Page origin:', window.location.origin);
+    </script>
+</body>
+</html>