@ricardodeazambuja/browser-mcp-server 1.0.3 → 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

@@ -0,0 +1,196 @@
+const os = require('os');
+const { connectToBrowser, getBrowserState } = require('../browser');
+const { getPlaywrightPath } = require('../utils');
+
+const definitions = [
+    {
+        name: 'browser_health_check',
+        description: 'Check if the browser is running and accessible on port 9222 (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_wait',
+        description: 'Pause execution for a duration (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ms: { type: 'number', description: 'Milliseconds to wait' }
+            },
+            required: ['ms'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_resize_window',
+        description: 'Resize the browser window (useful for testing responsiveness) (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                width: { type: 'number', description: 'Window width in pixels' },
+                height: { type: 'number', description: 'Window height in pixels' }
+            },
+            required: ['width', 'height'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_wait_for_selector',
+        description: 'Wait for an element to appear on the page (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                selector: { type: 'string', description: 'Playwright selector to wait for' },
+                timeout: { type: 'number', description: 'Timeout in milliseconds', default: 30000 }
+            },
+            required: ['selector'],
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_start_video_recording',
+        description: 'Start recording browser session as video (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to save the video file' }
+            },
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    },
+    {
+        name: 'browser_stop_video_recording',
+        description: 'Stop video recording and save the file (see browser_docs)',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+            $schema: 'http://json-schema.org/draft-07/schema#'
+        }
+    }
+];
+
+const handlers = {
+    browser_health_check: async (args) => {
+        // connectToBrowser called inside executeTool usually, but here we check state
+        const { browser, page } = getBrowserState();
+
+        // We try to connect if not connected
+        if (!browser) {
+            // If getting here via executeTool, connectToBrowser was already called
+            // If somehow not, we call it
+            await connectToBrowser();
+        }
+
+        const state = getBrowserState();
+        const url = state.page ? await state.page.url() : 'Unknown';
+
+        const isConnected = state.browser && state.browser.isConnected && state.browser.isConnected();
+        const mode = isConnected ? 'Connected to existing Chrome (Antigravity)' : 'Launched standalone Chrome';
+
+        // Determine profile path based on mode
+        let browserProfile;
+        if (isConnected) {
+            browserProfile = `${process.env.HOME}/.gemini/antigravity-browser-profile`;
+        } else {
+            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',
+                text: `✅ Browser automation is fully functional!\n\n` +
+                    `Mode: ${mode}\n` +
+                    `✅ Playwright: ${getPlaywrightPath() || 'loaded'}\n` +
+                    `✅ Chrome: Port 9222\n` +
+                    `✅ Profile: ${browserProfile}\n` +
+                    `✅ Current page: ${url}\n\n` +
+                    `All ${toolCount} browser tools are ready to use!`
+            }]
+        };
+    },
+
+    browser_wait: async (args) => {
+        await new Promise(resolve => setTimeout(resolve, args.ms));
+        return { content: [{ type: 'text', text: `Waited for ${args.ms}ms` }] };
+    },
+
+    browser_resize_window: async (args) => {
+        const { page } = await connectToBrowser();
+        await page.setViewportSize({
+            width: args.width,
+            height: args.height
+        });
+        return {
+            content: [{
+                type: 'text',
+                text: `Resized window to ${args.width}x${args.height}`
+            }]
+        };
+    },
+
+    browser_wait_for_selector: async (args) => {
+        const { page } = await connectToBrowser();
+        await page.waitForSelector(args.selector, {
+            timeout: args.timeout || 30000
+        });
+        return {
+            content: [{
+                type: 'text',
+                text: `Element ${args.selector} appeared`
+            }]
+        };
+    },
+
+    browser_start_video_recording: async (args) => {
+        const { context } = await connectToBrowser();
+        const videoPath = args.path || `${os.tmpdir()}/browser-recording-${Date.now()}.webm`;
+        await context.tracing.start({
+            screenshots: true,
+            snapshots: true
+        });
+        // Start video recording using Playwright's video feature
+        if (!context._options || !context._options.recordVideo) {
+            // Note: Video recording needs to be set when creating context
+            // For existing context, we'll use screenshots as fallback
+            return {
+                content: [{
+                    type: 'text',
+                    text: 'Started session tracing (screenshots). For full video, context needs recordVideo option at creation.'
+                }]
+            };
+        }
+        return {
+            content: [{
+                type: 'text',
+                text: `Started video recording to ${videoPath}`
+            }]
+        };
+    },
+
+    browser_stop_video_recording: async (args) => {
+        const { context } = await connectToBrowser();
+        const tracePath = `${os.tmpdir()}/trace-${Date.now()}.zip`;
+        await context.tracing.stop({ path: tracePath });
+        return {
+            content: [{
+                type: 'text',
+                text: `Stopped recording. Trace saved to ${tracePath}. Use 'playwright show-trace ${tracePath}' to view.`
+            }]
+        };
+    }
+};
+
+module.exports = { definitions, handlers };