@democratize-quality/mcp-server 1.0.0

package/src/tools/base/ToolRegistry.js

@@ -0,0 +1,269 @@
+const fs = require('fs');
+const path = require('path');
+const config = require('../../config');
+
+/**
+ * Tool Registry - Manages discovery, loading, and registration of tools
+ */
+class ToolRegistry {
+    constructor() {
+        this.tools = new Map(); // toolName -> toolInstance
+        this.definitions = []; // Array of tool definitions for MCP
+        this.config = config;
+    }
+
+    /**
+     * Automatically discovers and loads tools from the tools directory
+     * @param {string} toolsDir - The root tools directory path
+     * @param {boolean} debugMode - Whether to enable debug logging
+     */
+    async discoverTools(toolsDir, debugMode = false) {
+        this.debugMode = debugMode;
+        if (debugMode) {
+            console.error('[ToolRegistry] Starting tool discovery...');
+        }
+        
+        try {
+            await this._scanDirectory(toolsDir);
+            if (debugMode) {
+                console.error(`[ToolRegistry] Discovery complete. Found ${this.tools.size} tools.`);
+            }
+        } catch (error) {
+            console.error('[ToolRegistry] Error during tool discovery:', error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Recursively scans a directory for tool files
+     * @param {string} dir - Directory to scan
+     */
+    async _scanDirectory(dir) {
+        if (!fs.existsSync(dir)) {
+            console.error(`[ToolRegistry] Tools directory not found: ${dir}`);
+            return;
+        }
+
+        const items = fs.readdirSync(dir);
+        
+        for (const item of items) {
+            const itemPath = path.join(dir, item);
+            const stat = fs.statSync(itemPath);
+            
+            if (stat.isDirectory() && item !== 'base') {
+                // Recursively scan subdirectories (except 'base')
+                await this._scanDirectory(itemPath);
+            } else if (stat.isFile() && item.endsWith('.js') && !item.startsWith('index')) {
+                // Load tool files (skip index.js files)
+                await this._loadTool(itemPath);
+            }
+        }
+    }
+
+    /**
+     * Loads a single tool from a file
+     * @param {string} toolPath - Path to the tool file
+     */
+    async _loadTool(toolPath) {
+        try {
+            const ToolClass = require(toolPath);
+            
+            // Validate that it's a proper tool class
+            if (typeof ToolClass !== 'function') {
+                console.warn(`[ToolRegistry] Skipping ${toolPath}: Not a class/function export`);
+                return;
+            }
+            
+            if (!ToolClass.definition) {
+                console.warn(`[ToolRegistry] Skipping ${toolPath}: No tool definition found`);
+                return;
+            }
+            
+            const toolName = ToolClass.getName();
+            
+            // Check feature flags before registering
+            const category = this._getToolCategory(toolName, toolPath);
+            const featureFlag = `enable${category.charAt(0).toUpperCase() + category.slice(1)}Tools`;
+            
+            if (!this.config.isFeatureEnabled(featureFlag)) {
+                if (this.debugMode) {
+                    console.error(`[ToolRegistry] Tool '${toolName}' disabled by feature flag: ${featureFlag}`);
+                }
+                return;
+            }
+            
+            // Create an instance of the tool
+            const toolInstance = new ToolClass();
+            
+            // Check for name conflicts
+            if (this.tools.has(toolName)) {
+                console.warn(`[ToolRegistry] Tool name conflict: '${toolName}' already registered. Skipping ${toolPath}`);
+                return;
+            }
+            
+            // Register the tool
+            this.tools.set(toolName, toolInstance);
+            this.definitions.push(ToolClass.getDefinition());
+            
+            if (this.debugMode) {
+                console.error(`[ToolRegistry] Registered tool: ${toolName}`);
+            }
+            
+        } catch (error) {
+            console.error(`[ToolRegistry] Failed to load tool from ${toolPath}:`, error.message);
+        }
+    }
+
+    /**
+     * Manually registers a tool instance
+     * @param {ToolBase} toolInstance - The tool instance to register
+     */
+    registerTool(toolInstance) {
+        const toolName = toolInstance.constructor.getName();
+        
+        if (this.tools.has(toolName)) {
+            throw new Error(`Tool '${toolName}' is already registered`);
+        }
+        
+        this.tools.set(toolName, toolInstance);
+        this.definitions.push(toolInstance.constructor.getDefinition());
+        
+        console.error(`[ToolRegistry] Manually registered tool: ${toolName}`);
+    }
+
+    /**
+     * Gets a tool instance by name
+     * @param {string} toolName - The name of the tool
+     * @returns {ToolBase|undefined} - The tool instance or undefined if not found
+     */
+    getTool(toolName) {
+        return this.tools.get(toolName);
+    }
+
+    /**
+     * Gets all tool definitions for MCP tools/list response
+     * @returns {Array} - Array of tool definitions
+     */
+    getDefinitions() {
+        return this.definitions;
+    }
+
+    /**
+     * Gets all registered tool names
+     * @returns {Array<string>} - Array of tool names
+     */
+    getToolNames() {
+        return Array.from(this.tools.keys());
+    }
+
+    /**
+     * Checks if a tool is registered
+     * @param {string} toolName - The name of the tool
+     * @returns {boolean} - True if the tool is registered
+     */
+    hasTool(toolName) {
+        return this.tools.has(toolName);
+    }
+
+    /**
+     * Executes a tool by name
+     * @param {string} toolName - The name of the tool to execute
+     * @param {object} parameters - The parameters to pass to the tool
+     * @returns {Promise<object>} - The tool execution result
+     */
+    async executeTool(toolName, parameters) {
+        const tool = this.getTool(toolName);
+        
+        if (!tool) {
+            throw {
+                code: -32601,
+                message: `Tool '${toolName}' not found`,
+                data: { 
+                    available_tools: this.getToolNames(),
+                    requested_tool: toolName 
+                }
+            };
+        }
+        
+        return await tool.run(parameters);
+    }
+
+    /**
+     * Apply feature flags to filter available tools
+     */
+    _applyFeatureFlags() {
+        const toolsToRemove = [];
+        
+        for (const [toolName, toolInstance] of this.tools) {
+            const category = this._getToolCategory(toolName);
+            const featureFlag = `enable${category.charAt(0).toUpperCase() + category.slice(1)}Tools`;
+            
+            if (!this.config.isFeatureEnabled(featureFlag)) {
+                if (this.debugMode) {
+                    console.error(`[ToolRegistry] Tool '${toolName}' disabled by feature flag: ${featureFlag}`);
+                }
+                toolsToRemove.push(toolName);
+            }
+        }
+        
+        // Remove disabled tools
+        for (const toolName of toolsToRemove) {
+            this.tools.delete(toolName);
+            this.definitions = this.definitions.filter(def => def.name !== toolName);
+        }
+    }
+
+    /**
+     * Get tool category from tool name and file path
+     * @param {string} toolName - The tool name
+     * @param {string} toolPath - The tool file path (optional, for better categorization)
+     * @returns {string} - The tool category
+     */
+    _getToolCategory(toolName, toolPath = '') {
+        // Check by tool name prefix first
+        if (toolName.startsWith('api_')) return 'api';
+        if (toolName.startsWith('browser_')) return 'browser';
+        if (toolName.startsWith('file_')) return 'file';
+        if (toolName.startsWith('network_')) return 'network';
+        
+        // Check by file path if tool name doesn't have clear prefix
+        if (toolPath.includes('/api/') || toolPath.includes('\\api\\')) return 'api';
+        if (toolPath.includes('/browser/') || toolPath.includes('\\browser\\')) return 'browser';
+        if (toolPath.includes('/advanced/') || toolPath.includes('\\advanced\\')) return 'advanced';
+        if (toolPath.includes('/file/') || toolPath.includes('\\file\\')) return 'file';
+        if (toolPath.includes('/network/') || toolPath.includes('\\network\\')) return 'network';
+        
+        // Default fallback
+        return 'other';
+    }
+
+    /**
+     * Gets registry statistics
+     * @returns {object} - Registry statistics
+     */
+    getStats() {
+        const categories = {};
+        for (const toolName of this.getToolNames()) {
+            const category = this._getToolCategory(toolName);
+            categories[category] = (categories[category] || 0) + 1;
+        }
+        
+        return {
+            total_tools: this.tools.size,
+            tool_names: this.getToolNames(),
+            definitions_count: this.definitions.length,
+            categories: categories,
+            feature_flags: {
+                enableApiTools: this.config.isFeatureEnabled('enableApiTools'),
+                enableBrowserTools: this.config.isFeatureEnabled('enableBrowserTools'),
+                enableAdvancedTools: this.config.isFeatureEnabled('enableAdvancedTools'),
+                enableFileTools: this.config.isFeatureEnabled('enableFileTools'),
+                enableNetworkTools: this.config.isFeatureEnabled('enableNetworkTools'),
+                enableOtherTools: this.config.isFeatureEnabled('enableOtherTools'),
+                enableDebugMode: this.config.isFeatureEnabled('enableDebugMode')
+            }
+        };
+    }
+}
+
+module.exports = ToolRegistry;

package/src/tools/browser/advanced/browser-console.js

@@ -0,0 +1,384 @@
+const ToolBase = require('../../base/ToolBase');
+const browserService = require('../../../services/browserService');
+
+/**
+ * Console Tool - Monitor and retrieve browser console messages
+ * Inspired by Playwright MCP console capabilities
+ */
+class BrowserConsoleTool extends ToolBase {
+    static definition = {
+        name: "browser_console",
+        description: "Monitor, retrieve, and manage browser console messages including logs, errors, and warnings.",
+        input_schema: {
+            type: "object",
+            properties: {
+                browserId: { 
+                    type: "string", 
+                    description: "The ID of the browser instance" 
+                },
+                action: {
+                    type: "string",
+                    enum: ["get", "clear", "monitor", "stopMonitor"],
+                    description: "Console action to perform"
+                },
+                filter: {
+                    type: "object",
+                    properties: {
+                        level: {
+                            type: "string",
+                            enum: ["log", "info", "warn", "error", "debug", "trace"],
+                            description: "Filter by console message level"
+                        },
+                        text: {
+                            type: "string",
+                            description: "Filter messages containing this text"
+                        },
+                        source: {
+                            type: "string",
+                            description: "Filter by source URL pattern"
+                        }
+                    },
+                    description: "Filter criteria for console messages"
+                },
+                limit: {
+                    type: "number",
+                    default: 100,
+                    description: "Maximum number of messages to return"
+                },
+                realTime: {
+                    type: "boolean",
+                    default: false,
+                    description: "Whether to return real-time console monitoring (for monitor action)"
+                }
+            },
+            required: ["browserId", "action"]
+        },
+        output_schema: {
+            type: "object",
+            properties: {
+                success: { type: "boolean", description: "Whether the operation was successful" },
+                action: { type: "string", description: "The action that was performed" },
+                messages: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            level: { type: "string" },
+                            text: { type: "string" },
+                            url: { type: "string" },
+                            lineNumber: { type: "number" },
+                            timestamp: { type: "string" },
+                            args: { type: "array" },
+                            stackTrace: { type: "array" }
+                        }
+                    },
+                    description: "Array of console messages"
+                },
+                summary: {
+                    type: "object",
+                    properties: {
+                        total: { type: "number" },
+                        errors: { type: "number" },
+                        warnings: { type: "number" },
+                        logs: { type: "number" }
+                    },
+                    description: "Summary of console messages"
+                },
+                monitoring: { type: "boolean", description: "Whether console monitoring is active" },
+                browserId: { type: "string", description: "Browser instance ID" }
+            },
+            required: ["success", "action", "browserId"]
+        }
+    };
+
+    constructor() {
+        super();
+        this.consoleData = new Map(); // browserId -> console messages
+        this.monitoring = new Map(); // browserId -> monitoring state
+    }
+
+    async execute(parameters) {
+        const { 
+            browserId, 
+            action, 
+            filter = {}, 
+            limit = 100, 
+            realTime = false 
+        } = parameters;
+        
+        const browser = browserService.getBrowserInstance(browserId);
+        if (!browser) {
+            throw new Error(`Browser instance '${browserId}' not found`);
+        }
+
+        const client = browser.client;
+        
+        let result = {
+            success: false,
+            action: action,
+            browserId: browserId
+        };
+
+        switch (action) {
+            case 'monitor':
+                await this.startConsoleMonitoring(client, browserId, realTime);
+                result.success = true;
+                result.monitoring = true;
+                result.message = 'Console monitoring started';
+                break;
+                
+            case 'stopMonitor':
+                this.stopConsoleMonitoring(browserId);
+                result.success = true;
+                result.monitoring = false;
+                result.message = 'Console monitoring stopped';
+                break;
+                
+            case 'get':
+                const messages = this.getConsoleMessages(browserId, filter, limit);
+                result.success = true;
+                result.messages = messages.messages;
+                result.summary = messages.summary;
+                result.monitoring = this.monitoring.has(browserId);
+                break;
+                
+            case 'clear':
+                this.clearConsoleMessages(browserId);
+                result.success = true;
+                result.message = 'Console messages cleared';
+                result.monitoring = this.monitoring.has(browserId);
+                break;
+                
+            default:
+                throw new Error(`Unsupported console action: ${action}`);
+        }
+
+        return result;
+    }
+
+    /**
+     * Start monitoring console messages
+     */
+    async startConsoleMonitoring(client, browserId, realTime = false) {
+        // Enable Runtime domain for console events
+        await client.Runtime.enable();
+        
+        // Initialize storage
+        if (!this.consoleData.has(browserId)) {
+            this.consoleData.set(browserId, []);
+        }
+
+        const consoleMessages = this.consoleData.get(browserId);
+        
+        // Set up console event listener
+        const consoleListener = (params) => {
+            const message = this.formatConsoleMessage(params);
+            consoleMessages.push(message);
+            
+            // Keep only last 1000 messages to prevent memory issues
+            if (consoleMessages.length > 1000) {
+                consoleMessages.splice(0, consoleMessages.length - 1000);
+            }
+            
+            if (realTime) {
+                console.log(`[Console:${browserId}] ${message.level.toUpperCase()}: ${message.text}`);
+            }
+        };
+
+        client.Runtime.consoleAPICalled(consoleListener);
+        
+        // Also listen for runtime exceptions
+        const exceptionListener = (params) => {
+            const message = this.formatExceptionMessage(params);
+            consoleMessages.push(message);
+            
+            if (realTime) {
+                console.log(`[Console:${browserId}] ERROR: ${message.text}`);
+            }
+        };
+
+        client.Runtime.exceptionThrown(exceptionListener);
+        
+        // Store monitoring state
+        this.monitoring.set(browserId, {
+            consoleListener,
+            exceptionListener,
+            startTime: Date.now()
+        });
+    }
+
+    /**
+     * Stop monitoring console messages
+     */
+    stopConsoleMonitoring(browserId) {
+        this.monitoring.delete(browserId);
+    }
+
+    /**
+     * Get console messages with filtering
+     */
+    getConsoleMessages(browserId, filter, limit) {
+        const allMessages = this.consoleData.get(browserId) || [];
+        
+        let filteredMessages = [...allMessages];
+        
+        // Apply filters
+        if (filter.level) {
+            filteredMessages = filteredMessages.filter(msg => msg.level === filter.level);
+        }
+        
+        if (filter.text) {
+            const searchText = filter.text.toLowerCase();
+            filteredMessages = filteredMessages.filter(msg => 
+                msg.text.toLowerCase().includes(searchText)
+            );
+        }
+        
+        if (filter.source) {
+            const sourceRegex = new RegExp(filter.source, 'i');
+            filteredMessages = filteredMessages.filter(msg => 
+                msg.url && sourceRegex.test(msg.url)
+            );
+        }
+        
+        // Limit results
+        const messages = filteredMessages.slice(-limit);
+        
+        // Create summary
+        const summary = this.createMessageSummary(filteredMessages);
+        
+        return { messages, summary };
+    }
+
+    /**
+     * Clear console messages
+     */
+    clearConsoleMessages(browserId) {
+        this.consoleData.set(browserId, []);
+    }
+
+    /**
+     * Format console API message
+     */
+    formatConsoleMessage(params) {
+        const level = params.type || 'log';
+        const timestamp = new Date().toISOString();
+        
+        // Extract text from console arguments
+        let text = '';
+        const args = [];
+        
+        if (params.args) {
+            for (const arg of params.args) {
+                if (arg.value !== undefined) {
+                    const value = arg.value;
+                    text += String(value) + ' ';
+                    args.push(value);
+                } else if (arg.description) {
+                    text += arg.description + ' ';
+                    args.push(arg.description);
+                }
+            }
+        }
+        
+        return {
+            level: level,
+            text: text.trim(),
+            timestamp: timestamp,
+            args: args,
+            url: params.executionContextId ? 'unknown' : null,
+            lineNumber: null,
+            stackTrace: params.stackTrace ? this.formatStackTrace(params.stackTrace) : null
+        };
+    }
+
+    /**
+     * Format runtime exception message
+     */
+    formatExceptionMessage(params) {
+        const timestamp = new Date().toISOString();
+        const exceptionDetails = params.exceptionDetails;
+        
+        let text = 'Uncaught ';
+        if (exceptionDetails.exception?.description) {
+            text += exceptionDetails.exception.description;
+        } else if (exceptionDetails.text) {
+            text += exceptionDetails.text;
+        } else {
+            text += 'Error';
+        }
+        
+        return {
+            level: 'error',
+            text: text,
+            timestamp: timestamp,
+            url: exceptionDetails.url || null,
+            lineNumber: exceptionDetails.lineNumber || null,
+            columnNumber: exceptionDetails.columnNumber || null,
+            stackTrace: exceptionDetails.stackTrace ? this.formatStackTrace(exceptionDetails.stackTrace) : null
+        };
+    }
+
+    /**
+     * Format stack trace
+     */
+    formatStackTrace(stackTrace) {
+        if (!stackTrace.callFrames) return null;
+        
+        return stackTrace.callFrames.map(frame => ({
+            functionName: frame.functionName || '<anonymous>',
+            url: frame.url,
+            lineNumber: frame.lineNumber,
+            columnNumber: frame.columnNumber
+        }));
+    }
+
+    /**
+     * Create message summary
+     */
+    createMessageSummary(messages) {
+        const summary = {
+            total: messages.length,
+            errors: 0,
+            warnings: 0,
+            logs: 0,
+            info: 0,
+            debug: 0
+        };
+        
+        messages.forEach(msg => {
+            switch (msg.level) {
+                case 'error':
+                    summary.errors++;
+                    break;
+                case 'warn':
+                    summary.warnings++;
+                    break;
+                case 'log':
+                    summary.logs++;
+                    break;
+                case 'info':
+                    summary.info++;
+                    break;
+                case 'debug':
+                    summary.debug++;
+                    break;
+            }
+        });
+        
+        return summary;
+    }
+
+    /**
+     * Get console monitoring status
+     */
+    getMonitoringStatus(browserId) {
+        return {
+            monitoring: this.monitoring.has(browserId),
+            messageCount: (this.consoleData.get(browserId) || []).length,
+            startTime: this.monitoring.get(browserId)?.startTime
+        };
+    }
+}
+
+module.exports = BrowserConsoleTool;