moflo 4.8.31 → 4.8.32

package/src/@claude-flow/shared/dist/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * @claude-flow/shared - Shared Module
- * Common types, events, utilities, and core interfaces for V3 Claude-Flow
- *
- * Based on ADR-002 (DDD) and ADR-006 (Unified Memory Service)
- */
-export * from './types.js';
-export { EventBus } from './events.js';
-export type { IEventBus, EventFilter } from './events.js';
-export type { DomainEvent, AllDomainEvents, AgentSpawnedEvent, AgentStartedEvent, AgentStoppedEvent, AgentFailedEvent, AgentStatusChangedEvent, AgentTaskAssignedEvent, AgentTaskCompletedEvent, TaskCreatedEvent, TaskStartedEvent, TaskCompletedEvent, TaskFailedEvent, TaskBlockedEvent, TaskQueuedEvent, MemoryStoredEvent, MemoryRetrievedEvent, MemoryDeletedEvent, MemoryExpiredEvent, SwarmInitializedEvent, SwarmScaledEvent, SwarmTerminatedEvent, SwarmPhaseChangedEvent, SwarmMilestoneReachedEvent, SwarmErrorEvent, EventStoreConfig, EventSnapshot, EventStoreStats, AgentProjectionState, TaskProjectionState, MemoryProjectionState, AggregateRoot, ReconstructorOptions, } from './events/index.js';
-export { createAgentSpawnedEvent, createAgentStartedEvent, createAgentStoppedEvent, createAgentFailedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createTaskFailedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, createSwarmInitializedEvent, createSwarmScaledEvent, createSwarmTerminatedEvent, EventStore, Projection, AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection, StateReconstructor, createStateReconstructor, AgentAggregate, TaskAggregate, } from './events/index.js';
-export * from './plugin-loader.js';
-export * from './plugin-registry.js';
-export { createEventBus, createOrchestrator, TaskManager, SessionManager, HealthMonitor, LifecycleManager, EventCoordinator, ConfigLoader, loadConfig, ConfigValidator, validateAgentConfig, validateTaskConfig, validateSwarmConfig, validateMemoryConfig, validateMCPServerConfig, validateOrchestratorConfig, validateSystemConfig, defaultAgentConfig, defaultTaskConfig, defaultSwarmConfigCore, defaultMemoryConfig, defaultMCPServerConfig, defaultOrchestratorConfig, defaultSystemConfig, agentTypePresets, mergeWithDefaults, } from './core/index.js';
-export type { LoadedConfig, ConfigSource, ValidationResult, ValidationError, OrchestratorFacadeConfig, OrchestratorComponents, SessionManagerConfig, HealthMonitorConfig, LifecycleManagerConfig, AgentConfig, TaskConfig, SwarmConfig as SwarmConfigSchema, MemoryConfig, MCPServerConfig, OrchestratorConfig, SystemConfig, AgentConfigInput, TaskConfigInput, SwarmConfigInput, MemoryConfigInput, MCPServerConfigInput, OrchestratorConfigInput, SystemConfigInput, ITask, ITaskCreate, ITaskResult, IAgent, IAgentConfig, IEventBus as ICoreEventBus, IMemoryBackend as ICoreMemoryBackend, ISwarmConfig, ISwarmState, ICoordinator, ICoordinationManager, IHealthStatus, IComponentHealth, IHealthMonitor, IMetricsCollector, IOrchestratorMetrics, IOrchestrator, SwarmTopology, CoordinationStatus, } from './core/index.js';
-export * from './hooks/index.js';
-export * from './security/index.js';
-export * from './resilience/index.js';
-export * from './services/index.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/shared/dist/mcp/connection-pool.d.ts

@@ -1,98 +0,0 @@
-/**
- * V3 MCP Connection Pool Manager
- *
- * High-performance connection pooling for MCP server:
- * - Reusable connections to reduce overhead
- * - Max connections: 10 (configurable)
- * - Idle timeout handling with automatic eviction
- * - Connection health monitoring
- * - Graceful shutdown support
- *
- * Performance Targets:
- * - Connection acquire: <5ms
- * - Connection release: <1ms
- */
-import { EventEmitter } from 'events';
-import { PooledConnection, ConnectionPoolStats, ConnectionPoolConfig, IConnectionPool, ILogger, TransportType } from './types.js';
-/**
- * Connection Pool Manager
- *
- * Manages a pool of reusable connections for optimal performance
- */
-export declare class ConnectionPool extends EventEmitter implements IConnectionPool {
-    private readonly logger;
-    private readonly transportType;
-    private readonly config;
-    private readonly connections;
-    private readonly waitingClients;
-    private evictionTimer?;
-    private connectionCounter;
-    private isShuttingDown;
-    private stats;
-    constructor(config: Partial<ConnectionPoolConfig> | undefined, logger: ILogger, transportType?: TransportType);
-    /**
-     * Initialize minimum number of connections
-     */
-    private initializeMinConnections;
-    /**
-     * Create a new connection
-     */
-    private createConnection;
-    /**
-     * Acquire a connection from the pool
-     */
-    acquire(): Promise<PooledConnection>;
-    /**
-     * Wait for a connection to become available
-     */
-    private waitForConnection;
-    /**
-     * Release a connection back to the pool
-     */
-    release(connection: PooledConnection): void;
-    /**
-     * Destroy a connection (remove from pool)
-     */
-    destroy(connection: PooledConnection): void;
-    /**
-     * Get pool statistics
-     */
-    getStats(): ConnectionPoolStats;
-    /**
-     * Drain the pool (wait for all connections to be released)
-     */
-    drain(): Promise<void>;
-    /**
-     * Clear all connections from the pool
-     */
-    clear(): Promise<void>;
-    /**
-     * Start the eviction timer
-     */
-    private startEvictionTimer;
-    /**
-     * Stop the eviction timer
-     */
-    private stopEvictionTimer;
-    /**
-     * Evict idle connections that have exceeded the timeout
-     */
-    private evictIdleConnections;
-    /**
-     * Record acquire time for statistics
-     */
-    private recordAcquireTime;
-    /**
-     * Get all connections (for debugging/monitoring)
-     */
-    getConnections(): PooledConnection[];
-    /**
-     * Check if pool is healthy
-     */
-    isHealthy(): boolean;
-}
-/**
- * Create a connection pool with default settings
- */
-export declare function createConnectionPool(config: Partial<ConnectionPoolConfig> | undefined, logger: ILogger, transportType?: TransportType): ConnectionPool;
-//# sourceMappingURL=connection-pool.d.ts.map

package/src/@claude-flow/shared/dist/mcp/index.d.ts

@@ -1,69 +0,0 @@
-/**
- * V3 MCP Module
- *
- * Optimized MCP (Model Context Protocol) implementation for Claude-Flow V3
- *
- * Features:
- * - High-performance server with <400ms startup
- * - Connection pooling with max 10 connections
- * - Multiple transport support (stdio, http, websocket, in-process)
- * - Fast tool registry with <10ms registration
- * - Session management with timeout handling
- * - Comprehensive metrics and monitoring
- *
- * Performance Targets:
- * - Server startup: <400ms
- * - Tool registration: <10ms
- * - Tool execution: <50ms overhead
- * - Connection acquire: <5ms
- *
- * @module @claude-flow/mcp
- * @version 3.0.0
- */
-export type { JsonRpcVersion, RequestId, MCPMessage, MCPRequest, MCPResponse, MCPNotification, MCPError, TransportType, AuthMethod, AuthConfig, LoadBalancerConfig, ConnectionPoolConfig, MCPServerConfig, SessionState, MCPSession, MCPClientInfo, MCPCapabilities, MCPProtocolVersion, MCPInitializeParams, MCPInitializeResult, JSONSchema, ToolContext, ToolHandler, MCPTool, ToolCallResult, ToolRegistrationOptions, RequestHandler, NotificationHandler, TransportHealthStatus, ITransport, ConnectionState, PooledConnection, ConnectionPoolStats, IConnectionPool, ToolCallMetrics, MCPServerMetrics, SessionMetrics, MCPEventType, MCPEvent, EventHandler, LogLevel, ILogger, } from './types.js';
-import type { MCPServerConfig, ILogger } from './types.js';
-export { ErrorCodes, MCPServerError } from './types.js';
-import { MCPServer, createMCPServer } from './server.js';
-export { MCPServer, createMCPServer };
-export type { IMCPServer } from './server.js';
-export { ToolRegistry, createToolRegistry, defineTool } from './tool-registry.js';
-import { SessionManager, createSessionManager } from './session-manager.js';
-export { SessionManager, createSessionManager };
-export type { SessionConfig } from './session-manager.js';
-export { ConnectionPool, createConnectionPool } from './connection-pool.js';
-export { createTransport, createInProcessTransport, TransportManager, createTransportManager, DEFAULT_TRANSPORT_CONFIGS, StdioTransport, HttpTransport, WebSocketTransport, } from './transport/index.js';
-export type { TransportConfig, StdioTransportConfig, HttpTransportConfig, WebSocketTransportConfig, } from './transport/index.js';
-/**
- * Quick start function to create and configure an MCP server
- *
- * @example
- * ```typescript
- * import { quickStart } from '@claude-flow/mcp';
- *
- * const server = await quickStart({
- *   transport: 'stdio',
- *   name: 'My MCP Server',
- * });
- *
- * // Register custom tools
- * server.registerTool({
- *   name: 'my-tool',
- *   description: 'My custom tool',
- *   inputSchema: { type: 'object', properties: {} },
- *   handler: async () => ({ result: 'success' }),
- * });
- *
- * // Start server
- * await server.start();
- * ```
- */
-export declare function quickStart(config: Partial<MCPServerConfig>, logger?: ILogger): Promise<MCPServer>;
-/**
- * Module version
- */
-export declare const VERSION = "3.0.0";
-/**
- * Module name
- */
-export declare const MODULE_NAME = "@claude-flow/mcp";
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/shared/dist/mcp/server.d.ts

@@ -1,166 +0,0 @@
-/**
- * V3 MCP Server Implementation
- *
- * Optimized MCP server with:
- * - Connection pooling for efficient resource usage
- * - Fast tool registration (<10ms)
- * - Optimized request routing (<50ms overhead)
- * - Multiple transport support (stdio, http, websocket, in-process)
- * - Session management with timeout handling
- * - Comprehensive metrics and monitoring
- *
- * Performance Targets:
- * - Server startup: <400ms
- * - Tool registration: <10ms
- * - Tool execution: <50ms overhead
- */
-import { EventEmitter } from 'events';
-import { MCPServerConfig, MCPSession, MCPTool, MCPServerMetrics, ILogger } from './types.js';
-/**
- * MCP Server Interface
- */
-export interface IMCPServer {
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    registerTool(tool: MCPTool): boolean;
-    registerTools(tools: MCPTool[]): {
-        registered: number;
-        failed: string[];
-    };
-    getHealthStatus(): Promise<{
-        healthy: boolean;
-        error?: string;
-        metrics?: Record<string, number>;
-    }>;
-    getMetrics(): MCPServerMetrics;
-    getSessions(): MCPSession[];
-    getSession(sessionId: string): MCPSession | undefined;
-    terminateSession(sessionId: string): boolean;
-}
-/**
- * V3 MCP Server
- */
-export declare class MCPServer extends EventEmitter implements IMCPServer {
-    private readonly logger;
-    private readonly orchestrator?;
-    private readonly swarmCoordinator?;
-    private readonly config;
-    private readonly toolRegistry;
-    private readonly sessionManager;
-    private readonly connectionPool?;
-    private readonly transportManager;
-    private transport?;
-    private running;
-    private startTime?;
-    private startupDuration?;
-    private currentSession?;
-    private readonly serverInfo;
-    private readonly protocolVersion;
-    private readonly capabilities;
-    private requestStats;
-    constructor(config: Partial<MCPServerConfig>, logger: ILogger, orchestrator?: unknown | undefined, swarmCoordinator?: unknown | undefined);
-    /**
-     * Start the MCP server
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the MCP server
-     */
-    stop(): Promise<void>;
-    /**
-     * Register a tool
-     */
-    registerTool(tool: MCPTool): boolean;
-    /**
-     * Register multiple tools
-     */
-    registerTools(tools: MCPTool[]): {
-        registered: number;
-        failed: string[];
-    };
-    /**
-     * Unregister a tool
-     */
-    unregisterTool(name: string): boolean;
-    /**
-     * Get health status
-     */
-    getHealthStatus(): Promise<{
-        healthy: boolean;
-        error?: string;
-        metrics?: Record<string, number>;
-    }>;
-    /**
-     * Get server metrics
-     */
-    getMetrics(): MCPServerMetrics;
-    /**
-     * Get all sessions
-     */
-    getSessions(): MCPSession[];
-    /**
-     * Get session by ID
-     */
-    getSession(sessionId: string): MCPSession | undefined;
-    /**
-     * Terminate a session
-     */
-    terminateSession(sessionId: string): boolean;
-    /**
-     * Handle incoming request
-     */
-    private handleRequest;
-    /**
-     * Handle notification
-     */
-    private handleNotification;
-    /**
-     * Handle initialize request
-     */
-    private handleInitialize;
-    /**
-     * Route request to appropriate handler
-     */
-    private routeRequest;
-    /**
-     * Handle tools/list request
-     */
-    private handleToolsList;
-    /**
-     * Handle tools/call request
-     */
-    private handleToolsCall;
-    /**
-     * Handle direct tool execution (backwards compatibility)
-     */
-    private handleToolExecution;
-    /**
-     * Handle resources/list request
-     */
-    private handleResourcesList;
-    /**
-     * Handle prompts/list request
-     */
-    private handlePromptsList;
-    /**
-     * Get or create current session
-     */
-    private getOrCreateSession;
-    /**
-     * Create error response
-     */
-    private createErrorResponse;
-    /**
-     * Register built-in tools
-     */
-    private registerBuiltInTools;
-    /**
-     * Setup event handlers
-     */
-    private setupEventHandlers;
-}
-/**
- * Create an MCP server instance
- */
-export declare function createMCPServer(config: Partial<MCPServerConfig>, logger: ILogger, orchestrator?: unknown, swarmCoordinator?: unknown): MCPServer;
-//# sourceMappingURL=server.d.ts.map

package/src/@claude-flow/shared/dist/mcp/session-manager.d.ts

@@ -1,136 +0,0 @@
-/**
- * V3 MCP Session Manager
- *
- * Manages MCP sessions with:
- * - Session lifecycle management
- * - Authentication integration
- * - Session timeout handling
- * - Concurrent session support
- * - Session metrics and monitoring
- *
- * Performance Targets:
- * - Session creation: <5ms
- * - Session lookup: <1ms
- * - Session cleanup: <10ms
- */
-import { EventEmitter } from 'events';
-import { MCPSession, SessionState, SessionMetrics, MCPInitializeParams, TransportType, ILogger } from './types.js';
-/**
- * Session configuration
- */
-export interface SessionConfig {
-    maxSessions?: number;
-    sessionTimeout?: number;
-    cleanupInterval?: number;
-    enableMetrics?: boolean;
-}
-/**
- * Session Manager
- *
- * Handles creation, tracking, and cleanup of MCP sessions
- */
-export declare class SessionManager extends EventEmitter {
-    private readonly logger;
-    private readonly sessions;
-    private readonly config;
-    private cleanupTimer?;
-    private sessionCounter;
-    private totalCreated;
-    private totalClosed;
-    private totalExpired;
-    constructor(logger: ILogger, config?: SessionConfig);
-    /**
-     * Create a new session
-     */
-    createSession(transport: TransportType): MCPSession;
-    /**
-     * Initialize a session with client information
-     */
-    initializeSession(sessionId: string, params: MCPInitializeParams): MCPSession | undefined;
-    /**
-     * Authenticate a session
-     */
-    authenticateSession(sessionId: string): boolean;
-    /**
-     * Get a session by ID
-     */
-    getSession(sessionId: string): MCPSession | undefined;
-    /**
-     * Check if session exists
-     */
-    hasSession(sessionId: string): boolean;
-    /**
-     * Get all active sessions
-     */
-    getActiveSessions(): MCPSession[];
-    /**
-     * Update session activity timestamp
-     */
-    updateActivity(sessionId: string): boolean;
-    /**
-     * Set session state
-     */
-    setState(sessionId: string, state: SessionState): boolean;
-    /**
-     * Set session metadata
-     */
-    setMetadata(sessionId: string, key: string, value: unknown): boolean;
-    /**
-     * Get session metadata
-     */
-    getMetadata(sessionId: string, key: string): unknown;
-    /**
-     * Close a session
-     */
-    closeSession(sessionId: string, reason?: string): boolean;
-    /**
-     * Remove a session (alias for closeSession)
-     */
-    removeSession(sessionId: string): boolean;
-    /**
-     * Get session metrics
-     */
-    getSessionMetrics(): SessionMetrics;
-    /**
-     * Get detailed statistics
-     */
-    getStats(): {
-        total: number;
-        byState: Record<SessionState, number>;
-        byTransport: Record<TransportType, number>;
-        totalCreated: number;
-        totalClosed: number;
-        totalExpired: number;
-        oldestSession?: Date;
-        newestSession?: Date;
-    };
-    /**
-     * Clean up expired sessions
-     */
-    cleanupExpiredSessions(): number;
-    /**
-     * Start cleanup timer
-     */
-    private startCleanupTimer;
-    /**
-     * Stop cleanup timer
-     */
-    private stopCleanupTimer;
-    /**
-     * Generate a unique session ID
-     */
-    private generateSessionId;
-    /**
-     * Clear all sessions
-     */
-    clearAll(): void;
-    /**
-     * Destroy the session manager
-     */
-    destroy(): void;
-}
-/**
- * Create a session manager
- */
-export declare function createSessionManager(logger: ILogger, config?: SessionConfig): SessionManager;
-//# sourceMappingURL=session-manager.d.ts.map

package/src/@claude-flow/shared/dist/mcp/tool-registry.d.ts

@@ -1,178 +0,0 @@
-/**
- * V3 MCP Tool Registry
- *
- * High-performance tool management with:
- * - Fast O(1) lookup using Map
- * - Category-based organization
- * - Tool validation on registration
- * - Dynamic registration/unregistration
- * - Caching for frequently used tools
- *
- * Performance Targets:
- * - Tool registration: <10ms
- * - Tool lookup: <1ms
- * - Tool validation: <5ms
- */
-import { EventEmitter } from 'events';
-import { MCPTool, JSONSchema, ToolHandler, ToolContext, ToolCallResult, ToolRegistrationOptions, ILogger } from './types.js';
-/**
- * Tool metadata for enhanced lookup
- */
-interface ToolMetadata {
-    tool: MCPTool;
-    registeredAt: Date;
-    callCount: number;
-    lastCalled?: Date;
-    avgExecutionTime: number;
-    errorCount: number;
-}
-/**
- * Tool search options
- */
-interface ToolSearchOptions {
-    category?: string;
-    tags?: string[];
-    deprecated?: boolean;
-    cacheable?: boolean;
-}
-/**
- * Tool Registry
- *
- * Manages registration, lookup, and execution of MCP tools
- */
-export declare class ToolRegistry extends EventEmitter {
-    private readonly logger;
-    private readonly tools;
-    private readonly categoryIndex;
-    private readonly tagIndex;
-    private defaultContext?;
-    private totalRegistrations;
-    private totalLookups;
-    private totalExecutions;
-    constructor(logger: ILogger);
-    /**
-     * Register a tool
-     */
-    register(tool: MCPTool, options?: ToolRegistrationOptions): boolean;
-    /**
-     * Register multiple tools at once
-     */
-    registerBatch(tools: MCPTool[], options?: ToolRegistrationOptions): {
-        registered: number;
-        failed: string[];
-    };
-    /**
-     * Unregister a tool
-     */
-    unregister(name: string): boolean;
-    /**
-     * Get a tool by name
-     */
-    getTool(name: string): MCPTool | undefined;
-    /**
-     * Check if a tool exists
-     */
-    hasTool(name: string): boolean;
-    /**
-     * Get tool count
-     */
-    getToolCount(): number;
-    /**
-     * Get all tool names
-     */
-    getToolNames(): string[];
-    /**
-     * List all tools with metadata
-     */
-    listTools(): Array<{
-        name: string;
-        description: string;
-        category?: string;
-        tags?: string[];
-        deprecated?: boolean;
-    }>;
-    /**
-     * Search tools by criteria
-     */
-    search(options: ToolSearchOptions): MCPTool[];
-    /**
-     * Get tools by category
-     */
-    getByCategory(category: string): MCPTool[];
-    /**
-     * Get tools by tag
-     */
-    getByTag(tag: string): MCPTool[];
-    /**
-     * Get all categories
-     */
-    getCategories(): string[];
-    /**
-     * Get all tags
-     */
-    getTags(): string[];
-    /**
-     * Execute a tool
-     */
-    execute(name: string, input: Record<string, unknown>, context?: ToolContext): Promise<ToolCallResult>;
-    /**
-     * Set default execution context
-     */
-    setDefaultContext(context: ToolContext): void;
-    /**
-     * Get tool metadata
-     */
-    getMetadata(name: string): ToolMetadata | undefined;
-    /**
-     * Get registry statistics
-     */
-    getStats(): {
-        totalTools: number;
-        totalCategories: number;
-        totalTags: number;
-        totalRegistrations: number;
-        totalLookups: number;
-        totalExecutions: number;
-        topTools: Array<{
-            name: string;
-            calls: number;
-        }>;
-    };
-    /**
-     * Validate a tool definition
-     */
-    validateTool(tool: MCPTool): {
-        valid: boolean;
-        errors: string[];
-    };
-    /**
-     * Validate JSON Schema
-     */
-    private validateSchema;
-    /**
-     * Update average execution time
-     */
-    private updateAverageExecutionTime;
-    /**
-     * Clear all tools
-     */
-    clear(): void;
-}
-/**
- * Create a tool registry
- */
-export declare function createToolRegistry(logger: ILogger): ToolRegistry;
-/**
- * Helper to create a tool definition
- */
-export declare function defineTool<TInput = Record<string, unknown>, TOutput = unknown>(name: string, description: string, inputSchema: JSONSchema, handler: ToolHandler<TInput, TOutput>, options?: {
-    category?: string;
-    tags?: string[];
-    version?: string;
-    deprecated?: boolean;
-    cacheable?: boolean;
-    cacheTTL?: number;
-    timeout?: number;
-}): MCPTool<TInput, TOutput>;
-export {};
-//# sourceMappingURL=tool-registry.d.ts.map