claude-flow-tbowman01
Version:
Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)
212 lines • 6.52 kB
JavaScript
/**
* 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, // 1 hour
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