claude-flow-novice 1.5.12 → 1.5.14

package/.claude-flow-novice/dist/mcp/client.js

@@ -0,0 +1,201 @@
+/**
+ * MCP Client for Model Context Protocol
+ */ import { EventEmitter } from 'node:events';
+import { logger } from '../core/logger.js';
+import { RecoveryManager } from './recovery/index.js';
+export class MCPClient extends EventEmitter {
+    transport;
+    timeout;
+    connected = false;
+    recoveryManager;
+    pendingRequests = new Map();
+    constructor(config){
+        super();
+        this.transport = config.transport;
+        this.timeout = config.timeout || 30000;
+        // Initialize recovery manager if enabled
+        if (config.enableRecovery) {
+            this.recoveryManager = new RecoveryManager(this, config.mcpConfig || {}, logger, config.recoveryConfig);
+            this.setupRecoveryHandlers();
+        }
+    }
+    async connect() {
+        try {
+            await this.transport.connect();
+            this.connected = true;
+            logger.info('MCP Client connected');
+            // Start recovery manager if enabled
+            if (this.recoveryManager) {
+                await this.recoveryManager.start();
+            }
+            this.emit('connected');
+        } catch (error) {
+            logger.error('Failed to connect MCP client', error);
+            this.connected = false;
+            // Trigger recovery if enabled
+            if (this.recoveryManager) {
+                await this.recoveryManager.forceRecovery();
+            }
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (this.connected) {
+            // Stop recovery manager first
+            if (this.recoveryManager) {
+                await this.recoveryManager.stop();
+            }
+            await this.transport.disconnect();
+            this.connected = false;
+            logger.info('MCP Client disconnected');
+            this.emit('disconnected');
+        }
+    }
+    async request(method, params) {
+        const request = {
+            jsonrpc: '2.0',
+            method,
+            params,
+            id: Math.random().toString(36).slice(2)
+        };
+        // If recovery manager is enabled, let it handle the request
+        if (this.recoveryManager && !this.connected) {
+            await this.recoveryManager.handleRequest(request);
+        }
+        if (!this.connected) {
+            throw new Error('Client not connected');
+        }
+        // Create promise for tracking the request
+        const requestPromise = new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                this.pendingRequests.delete(request.id);
+                reject(new Error(`Request timeout: ${method}`));
+            }, this.timeout);
+            this.pendingRequests.set(request.id, {
+                resolve,
+                reject,
+                timer
+            });
+        });
+        try {
+            const response = await this.transport.sendRequest(request);
+            // Clear pending request
+            const pending = this.pendingRequests.get(request.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(request.id);
+            }
+            if ('error' in response) {
+                throw new Error(response.error);
+            }
+            return response.result;
+        } catch (error) {
+            // Clear pending request on error
+            const pending = this.pendingRequests.get(request.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(request.id);
+            }
+            throw error;
+        }
+    }
+    async notify(method, params) {
+        // Special handling for heartbeat notifications
+        if (method === 'heartbeat') {
+            // Always allow heartbeat notifications for recovery
+            const notification = {
+                jsonrpc: '2.0',
+                method,
+                params
+            };
+            if (this.transport.sendNotification) {
+                await this.transport.sendNotification(notification);
+            }
+            return;
+        }
+        if (!this.connected) {
+            throw new Error('Client not connected');
+        }
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params
+        };
+        if (this.transport.sendNotification) {
+            await this.transport.sendNotification(notification);
+        } else {
+            throw new Error('Transport does not support notifications');
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    /**
+   * Get recovery status if recovery is enabled
+   */ getRecoveryStatus() {
+        return this.recoveryManager?.getStatus();
+    }
+    /**
+   * Force a recovery attempt
+   */ async forceRecovery() {
+        if (!this.recoveryManager) {
+            throw new Error('Recovery not enabled');
+        }
+        return this.recoveryManager.forceRecovery();
+    }
+    setupRecoveryHandlers() {
+        if (!this.recoveryManager) {
+            return;
+        }
+        // Handle recovery events
+        this.recoveryManager.on('recoveryStart', ({ trigger })=>{
+            logger.info('Recovery started', {
+                trigger
+            });
+            this.emit('recoveryStart', {
+                trigger
+            });
+        });
+        this.recoveryManager.on('recoveryComplete', ({ success, duration })=>{
+            if (success) {
+                logger.info('Recovery completed successfully', {
+                    duration
+                });
+                this.connected = true;
+                this.emit('recoverySuccess', {
+                    duration
+                });
+            } else {
+                logger.error('Recovery failed');
+                this.emit('recoveryFailed', {
+                    duration
+                });
+            }
+        });
+        this.recoveryManager.on('fallbackActivated', (state)=>{
+            logger.warn('Fallback mode activated', state);
+            this.emit('fallbackActivated', state);
+        });
+        this.recoveryManager.on('healthChange', (newStatus, oldStatus)=>{
+            this.emit('healthChange', newStatus, oldStatus);
+        });
+    }
+    /**
+   * Cleanup resources
+   */ async cleanup() {
+        // Clear all pending requests
+        for (const [id, pending] of this.pendingRequests){
+            clearTimeout(pending.timer);
+            pending.reject(new Error('Client cleanup'));
+        }
+        this.pendingRequests.clear();
+        // Cleanup recovery manager
+        if (this.recoveryManager) {
+            await this.recoveryManager.cleanup();
+        }
+        // Disconnect if connected
+        await this.disconnect();
+    }
+}
+
+//# sourceMappingURL=client.js.map

package/.claude-flow-novice/dist/mcp/index.js

@@ -0,0 +1,192 @@
+/**
+ * MCP (Model Context Protocol) Module
+ * Export all MCP components for easy integration
+ */ // Core MCP Server
+export { MCPServer } from './server.js';
+// Lifecycle Management
+export { MCPLifecycleManager, LifecycleState } from './lifecycle-manager.js';
+// Tool Registry and Management
+export { ToolRegistry } from './tools.js';
+// Protocol Management
+export { MCPProtocolManager } from './protocol-manager.js';
+// Authentication and Authorization
+export { AuthManager, Permissions } from './auth.js';
+// Performance Monitoring
+export { MCPPerformanceMonitor } from './performance-monitor.js';
+// Orchestration Integration
+export { MCPOrchestrationIntegration } from './orchestration-integration.js';
+export { StdioTransport } from './transports/stdio.js';
+export { HttpTransport } from './transports/http.js';
+// Request Routing
+export { RequestRouter } from './router.js';
+// Session Management
+export { SessionManager } from './session-manager.js';
+// Load Balancing
+export { LoadBalancer, RequestQueue } from './load-balancer.js';
+// Tool Implementations
+export { createClaudeFlowTools } from './claude-flow-tools.js';
+export { createSwarmTools } from './swarm-tools.js';
+/**
+ * MCP Integration Factory
+ * Provides a simple way to create a complete MCP integration
+ */ export class MCPIntegrationFactory {
+    /**
+   * Create a complete MCP integration with all components
+   */ static async createIntegration(config) {
+        const { mcpConfig, orchestrationConfig = {}, components = {}, logger } = config;
+        const integration = new MCPOrchestrationIntegration(mcpConfig, {
+            enabledIntegrations: {
+                orchestrator: true,
+                swarm: true,
+                agents: true,
+                resources: true,
+                memory: true,
+                monitoring: true,
+                terminals: true
+            },
+            autoStart: true,
+            healthCheckInterval: 30000,
+            reconnectAttempts: 3,
+            reconnectDelay: 5000,
+            enableMetrics: true,
+            enableAlerts: true,
+            ...orchestrationConfig
+        }, components, logger);
+        return integration;
+    }
+    /**
+   * Create a standalone MCP server (without orchestration integration)
+   */ static async createStandaloneServer(config) {
+        const { mcpConfig, logger, enableLifecycleManagement = true, enablePerformanceMonitoring = true } = config;
+        const eventBus = new (await import('node:events')).EventEmitter();
+        const server = new MCPServer(mcpConfig, eventBus, logger);
+        let lifecycleManager;
+        let performanceMonitor;
+        if (enableLifecycleManagement) {
+            lifecycleManager = new MCPLifecycleManager(mcpConfig, logger, ()=>server);
+        }
+        if (enablePerformanceMonitoring) {
+            performanceMonitor = new MCPPerformanceMonitor(logger);
+        }
+        return {
+            server,
+            lifecycleManager,
+            performanceMonitor
+        };
+    }
+    /**
+   * Create a development/testing MCP setup
+   */ static async createDevelopmentSetup(logger) {
+        const mcpConfig = {
+            transport: 'stdio',
+            enableMetrics: true,
+            auth: {
+                enabled: false,
+                method: 'token'
+            }
+        };
+        const { server, lifecycleManager, performanceMonitor } = await this.createStandaloneServer({
+            mcpConfig,
+            logger,
+            enableLifecycleManagement: true,
+            enablePerformanceMonitoring: true
+        });
+        const protocolManager = new MCPProtocolManager(logger);
+        return {
+            server,
+            lifecycleManager: lifecycleManager,
+            performanceMonitor: performanceMonitor,
+            protocolManager
+        };
+    }
+}
+/**
+ * Default MCP configuration for common use cases
+ */ export const DefaultMCPConfigs = {
+    /**
+   * Development configuration with stdio transport
+   */ development: {
+        transport: 'stdio',
+        enableMetrics: true,
+        auth: {
+            enabled: false,
+            method: 'token'
+        }
+    },
+    /**
+   * Production configuration with HTTP transport and authentication
+   */ production: {
+        transport: 'http',
+        host: '0.0.0.0',
+        port: 3000,
+        tlsEnabled: true,
+        enableMetrics: true,
+        auth: {
+            enabled: true,
+            method: 'token'
+        },
+        loadBalancer: {
+            enabled: true,
+            maxRequestsPerSecond: 100,
+            maxConcurrentRequests: 50
+        },
+        sessionTimeout: 3600000,
+        maxSessions: 1000
+    },
+    /**
+   * Testing configuration with minimal features
+   */ testing: {
+        transport: 'stdio',
+        enableMetrics: false,
+        auth: {
+            enabled: false,
+            method: 'token'
+        }
+    }
+};
+/**
+ * MCP Utility Functions
+ */ export const MCPUtils = {
+    /**
+   * Validate MCP protocol version
+   */ isValidProtocolVersion (version) {
+        return typeof version.major === 'number' && typeof version.minor === 'number' && typeof version.patch === 'number' && version.major > 0;
+    },
+    /**
+   * Compare two protocol versions
+   */ compareVersions (a, b) {
+        if (a.major !== b.major) return a.major - b.major;
+        if (a.minor !== b.minor) return a.minor - b.minor;
+        return a.patch - b.patch;
+    },
+    /**
+   * Format protocol version as string
+   */ formatVersion (version) {
+        return `${version.major}.${version.minor}.${version.patch}`;
+    },
+    /**
+   * Parse protocol version from string
+   */ parseVersion (versionString) {
+        const parts = versionString.split('.').map((p)=>parseInt(p, 10));
+        if (parts.length !== 3 || parts.some((p)=>isNaN(p))) {
+            throw new Error(`Invalid version string: ${versionString}`);
+        }
+        return {
+            major: parts[0],
+            minor: parts[1],
+            patch: parts[2]
+        };
+    },
+    /**
+   * Generate a random session ID
+   */ generateSessionId () {
+        return `mcp_session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+    },
+    /**
+   * Generate a random request ID
+   */ generateRequestId () {
+        return `mcp_req_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+    }
+};
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/mcp/integrate-wrapper.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { ClaudeCodeMCPWrapper } from './claude-code-wrapper.js';
+/**
+ * Integration script that connects the Claude-Flow MCP wrapper
+ * to the Claude Code MCP server
+ */ export class MCPIntegration {
+    claudeCodeClient;
+    wrapper;
+    constructor(){
+        this.wrapper = new ClaudeCodeMCPWrapper();
+    }
+    async connectToClaudeCode() {
+        try {
+            // Start Claude Code MCP server process
+            const claudeCodeProcess = spawn('npx', [
+                '-y',
+                '@anthropic/claude-code',
+                'mcp'
+            ], {
+                stdio: [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ]
+            });
+            const transport = new StdioClientTransport({
+                command: 'npx',
+                args: [
+                    '-y',
+                    '@anthropic/claude-code',
+                    'mcp'
+                ]
+            });
+            this.claudeCodeClient = new Client({
+                name: 'claude-flow-wrapper-client',
+                version: '1.0.0'
+            }, {
+                capabilities: {}
+            });
+            await this.claudeCodeClient.connect(transport);
+            // Inject the client into the wrapper
+            this.wrapper.claudeCodeMCP = this.claudeCodeClient;
+            console.log('Connected to Claude Code MCP server');
+        } catch (error) {
+            console.error('Failed to connect to Claude Code MCP:', error);
+            throw error;
+        }
+    }
+    async start() {
+        // Connect to Claude Code MCP
+        await this.connectToClaudeCode();
+        // Start the wrapper server
+        await this.wrapper.run();
+    }
+}
+// Update the wrapper to use the real Claude Code MCP client
+export function injectClaudeCodeClient(wrapper, client) {
+    // Override the forwardToClaudeCode method
+    wrapper.forwardToClaudeCode = async function(toolName, args) {
+        try {
+            const result = await client.callTool(toolName, args);
+            return result;
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error calling Claude Code tool ${toolName}: ${error instanceof Error ? error.message : String(error)}`
+                    }
+                ],
+                isError: true
+            };
+        }
+    };
+}
+// Main execution
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const integration = new MCPIntegration();
+    integration.start().catch(console.error);
+}
+
+//# sourceMappingURL=integrate-wrapper.js.map