Add comprehensive WebSocket, context, performance, and security modules

- Introduced WebSocket client for real-time Home Assistant event streaming
- Created context management system for tracking resource relationships and state
- Implemented performance monitoring and optimization utilities
- Added security middleware with token validation, rate limiting, and input sanitization
- Extended tool registry with enhanced tool registration and execution capabilities
- Expanded test coverage for new modules and added comprehensive test scenarios
- Improved type safety and added robust error handling across new modules

src/tools/index.ts

@@ -0,0 +1,181 @@
+import { Tool } from 'litemcp';
+import { z } from 'zod';
+
+// Tool category types
+export enum ToolCategory {
+    DEVICE_CONTROL = 'device_control',
+    SYSTEM_MANAGEMENT = 'system_management',
+    AUTOMATION = 'automation',
+    MONITORING = 'monitoring',
+    SECURITY = 'security'
+}
+
+// Tool priority levels
+export enum ToolPriority {
+    HIGH = 'high',
+    MEDIUM = 'medium',
+    LOW = 'low'
+}
+
+// Tool metadata interface
+export interface ToolMetadata {
+    category: ToolCategory;
+    priority: ToolPriority;
+    requiresAuth: boolean;
+    rateLimit?: {
+        windowMs: number;
+        max: number;
+    };
+    caching?: {
+        enabled: boolean;
+        ttl: number;
+    };
+}
+
+// Enhanced tool interface
+export interface EnhancedTool extends Tool {
+    metadata: ToolMetadata;
+    validate?: (params: any) => Promise<boolean>;
+    preExecute?: (params: any) => Promise<void>;
+    postExecute?: (result: any) => Promise<void>;
+}
+
+// Tool registry for managing and organizing tools
+export class ToolRegistry {
+    private tools: Map<string, EnhancedTool> = new Map();
+    private categories: Map<ToolCategory, Set<string>> = new Map();
+    private cache: Map<string, { data: any; timestamp: number }> = new Map();
+
+    constructor() {
+        // Initialize categories
+        Object.values(ToolCategory).forEach(category => {
+            this.categories.set(category, new Set());
+        });
+    }
+
+    // Register a new tool
+    public registerTool(tool: EnhancedTool): void {
+        this.tools.set(tool.name, tool);
+        this.categories.get(tool.metadata.category)?.add(tool.name);
+    }
+
+    // Get tool by name
+    public getTool(name: string): EnhancedTool | undefined {
+        return this.tools.get(name);
+    }
+
+    // Get all tools in a category
+    public getToolsByCategory(category: ToolCategory): EnhancedTool[] {
+        const toolNames = this.categories.get(category);
+        if (!toolNames) return [];
+        return Array.from(toolNames).map(name => this.tools.get(name)!);
+    }
+
+    // Execute a tool with validation and hooks
+    public async executeTool(name: string, params: any): Promise<any> {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            throw new Error(`Tool ${name} not found`);
+        }
+
+        // Check cache if enabled
+        if (tool.metadata.caching?.enabled) {
+            const cacheKey = `${name}:${JSON.stringify(params)}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached && Date.now() - cached.timestamp < tool.metadata.caching.ttl) {
+                return cached.data;
+            }
+        }
+
+        // Validate parameters
+        if (tool.validate) {
+            const isValid = await tool.validate(params);
+            if (!isValid) {
+                throw new Error('Invalid parameters');
+            }
+        }
+
+        // Pre-execution hook
+        if (tool.preExecute) {
+            await tool.preExecute(params);
+        }
+
+        // Execute tool
+        const result = await tool.execute(params);
+
+        // Post-execution hook
+        if (tool.postExecute) {
+            await tool.postExecute(result);
+        }
+
+        // Update cache if enabled
+        if (tool.metadata.caching?.enabled) {
+            const cacheKey = `${name}:${JSON.stringify(params)}`;
+            this.cache.set(cacheKey, {
+                data: result,
+                timestamp: Date.now()
+            });
+        }
+
+        return result;
+    }
+
+    // Clean up expired cache entries
+    public cleanCache(): void {
+        const now = Date.now();
+        for (const [key, value] of this.cache.entries()) {
+            const tool = this.tools.get(key.split(':')[0]);
+            if (tool?.metadata.caching?.ttl && now - value.timestamp > tool.metadata.caching.ttl) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
+
+// Create and export the global tool registry
+export const toolRegistry = new ToolRegistry();
+
+// Tool decorator for easy registration
+export function registerTool(metadata: ToolMetadata) {
+    return function (target: any) {
+        const tool: EnhancedTool = new target();
+        tool.metadata = metadata;
+        toolRegistry.registerTool(tool);
+    };
+}
+
+// Example usage:
+@registerTool({
+    category: ToolCategory.DEVICE_CONTROL,
+    priority: ToolPriority.HIGH,
+    requiresAuth: true,
+    caching: {
+        enabled: true,
+        ttl: 5000 // 5 seconds
+    }
+})
+export class LightControlTool implements EnhancedTool {
+    name = 'light_control';
+    description = 'Control light devices';
+    parameters = z.object({
+        command: z.enum(['turn_on', 'turn_off', 'toggle']),
+        entity_id: z.string(),
+        brightness: z.number().min(0).max(255).optional(),
+        color_temp: z.number().optional(),
+        rgb_color: z.tuple([z.number(), z.number(), z.number()]).optional()
+    });
+
+    async validate(params: any): Promise<boolean> {
+        try {
+            this.parameters.parse(params);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async execute(params: any): Promise<any> {
+        // Implementation here
+        return { success: true };
+    }
+}