@deimoscloud/coreai 0.1.9 → 0.1.10

package/src/adapters/mcp/registry.ts

@@ -1,550 +0,0 @@
-/**
- * MCP Server Registry
- *
- * Central registry for managing MCP server connections.
- * Handles discovery, connection lifecycle, and provides access to connected servers.
- */
-
-import { EventEmitter } from 'events';
-import type { McpServerDefinition, McpServerInfo, McpTool, McpResource } from './types.js';
-import { McpError } from './types.js';
-import type { McpClientOptions } from './client.js';
-import { McpClient } from './client.js';
-import type { DiscoveryOptions } from './discovery.js';
-import { discoverMcpServers } from './discovery.js';
-import type { ToolMapping } from './mapper.js';
-import { getMappingsForServer, groupMappingsByAdapter } from './mapper.js';
-
-/**
- * Registry entry for a server
- */
-export interface ServerEntry {
-  /**
-   * Server definition from config
-   */
-  definition: McpServerDefinition;
-
-  /**
-   * MCP client instance (null if not connected)
-   */
-  client: McpClient | null;
-
-  /**
-   * Current connection status
-   */
-  status: ServerStatus;
-
-  /**
-   * Server info (available after connection)
-   */
-  info: McpServerInfo | null;
-
-  /**
-   * Available tools (cached after connection)
-   */
-  tools: McpTool[];
-
-  /**
-   * Available resources (cached after connection)
-   */
-  resources: McpResource[];
-
-  /**
-   * Tool mappings for adapter interfaces
-   */
-  mappings: ToolMapping[];
-
-  /**
-   * Last error if connection failed
-   */
-  lastError: Error | null;
-
-  /**
-   * Timestamp of last connection attempt
-   */
-  lastAttempt: Date | null;
-}
-
-/**
- * Server connection status
- */
-export type ServerStatus = 'disconnected' | 'connecting' | 'connected' | 'error' | 'disabled';
-
-/**
- * Registry events
- */
-export interface RegistryEvents {
-  /**
-   * Emitted when a server connects
-   */
-  serverConnected: (name: string, info: McpServerInfo) => void;
-
-  /**
-   * Emitted when a server disconnects
-   */
-  serverDisconnected: (name: string) => void;
-
-  /**
-   * Emitted when a server connection fails
-   */
-  serverError: (name: string, error: Error) => void;
-
-  /**
-   * Emitted when server list changes
-   */
-  serversChanged: (servers: string[]) => void;
-}
-
-/**
- * Options for the registry
- */
-export interface RegistryOptions {
-  /**
-   * Client options to use for all connections
-   */
-  clientOptions?: McpClientOptions;
-
-  /**
-   * Discovery options
-   */
-  discoveryOptions?: DiscoveryOptions;
-
-  /**
-   * Whether to auto-connect on discovery
-   */
-  autoConnect?: boolean;
-
-  /**
-   * Maximum retry attempts for failed connections
-   */
-  maxRetries?: number;
-
-  /**
-   * Delay between retries in milliseconds
-   */
-  retryDelay?: number;
-}
-
-const DEFAULT_OPTIONS: Required<RegistryOptions> = {
-  clientOptions: {},
-  discoveryOptions: {},
-  autoConnect: false,
-  maxRetries: 3,
-  retryDelay: 1000,
-};
-
-/**
- * MCP Server Registry
- *
- * Manages MCP server connections and provides centralized access to
- * connected servers, their tools, and adapter mappings.
- */
-export class McpRegistry extends EventEmitter {
-  private servers = new Map<string, ServerEntry>();
-  private options: Required<RegistryOptions>;
-
-  constructor(options?: RegistryOptions) {
-    super();
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-  }
-
-  /**
-   * Discover and register MCP servers from config files
-   */
-  async discover(): Promise<string[]> {
-    const definitions = discoverMcpServers(this.options.discoveryOptions);
-    const registered: string[] = [];
-
-    for (const definition of definitions) {
-      if (!this.servers.has(definition.name)) {
-        this.registerServer(definition);
-        registered.push(definition.name);
-      }
-    }
-
-    if (registered.length > 0) {
-      this.emit('serversChanged', this.getServerNames());
-    }
-
-    if (this.options.autoConnect) {
-      await this.connectAll();
-    }
-
-    return registered;
-  }
-
-  /**
-   * Register a server definition manually
-   */
-  registerServer(definition: McpServerDefinition): void {
-    if (this.servers.has(definition.name)) {
-      throw new McpError(
-        `Server "${definition.name}" is already registered`,
-        'invalid_config',
-        definition.name
-      );
-    }
-
-    const entry: ServerEntry = {
-      definition,
-      client: null,
-      status: definition.enabled === false ? 'disabled' : 'disconnected',
-      info: null,
-      tools: [],
-      resources: [],
-      mappings: [],
-      lastError: null,
-      lastAttempt: null,
-    };
-
-    this.servers.set(definition.name, entry);
-    this.emit('serversChanged', this.getServerNames());
-  }
-
-  /**
-   * Unregister a server
-   */
-  async unregisterServer(name: string): Promise<void> {
-    const entry = this.servers.get(name);
-    if (!entry) {
-      return;
-    }
-
-    if (entry.status === 'connected' && entry.client) {
-      await entry.client.disconnect();
-    }
-
-    this.servers.delete(name);
-    this.emit('serversChanged', this.getServerNames());
-  }
-
-  /**
-   * Connect to a specific server
-   */
-  async connect(name: string): Promise<McpServerInfo> {
-    const entry = this.servers.get(name);
-    if (!entry) {
-      throw new McpError(`Server "${name}" is not registered`, 'server_not_found', name);
-    }
-
-    if (entry.status === 'disabled') {
-      throw new McpError(`Server "${name}" is disabled`, 'invalid_config', name);
-    }
-
-    if (entry.status === 'connected' && entry.info) {
-      return entry.info;
-    }
-
-    return this.doConnect(entry);
-  }
-
-  /**
-   * Disconnect from a specific server
-   */
-  async disconnect(name: string): Promise<void> {
-    const entry = this.servers.get(name);
-    if (!entry) {
-      return;
-    }
-
-    if (entry.client) {
-      await entry.client.disconnect();
-      entry.client = null;
-    }
-
-    entry.status = entry.definition.enabled === false ? 'disabled' : 'disconnected';
-    entry.info = null;
-    entry.tools = [];
-    entry.resources = [];
-    entry.mappings = [];
-
-    this.emit('serverDisconnected', name);
-  }
-
-  /**
-   * Connect to all registered servers
-   */
-  async connectAll(): Promise<Map<string, McpServerInfo | Error>> {
-    const results = new Map<string, McpServerInfo | Error>();
-
-    const promises = Array.from(this.servers.entries())
-      .filter(([, entry]) => entry.status !== 'disabled')
-      .map(async ([name]) => {
-        try {
-          const info = await this.connect(name);
-          results.set(name, info);
-        } catch (error) {
-          results.set(name, error instanceof Error ? error : new Error(String(error)));
-        }
-      });
-
-    await Promise.all(promises);
-    return results;
-  }
-
-  /**
-   * Disconnect from all servers
-   */
-  async disconnectAll(): Promise<void> {
-    const promises = Array.from(this.servers.keys()).map((name) => this.disconnect(name));
-    await Promise.all(promises);
-  }
-
-  /**
-   * Get a connected client by server name
-   */
-  getClient(name: string): McpClient | null {
-    const entry = this.servers.get(name);
-    return entry?.client ?? null;
-  }
-
-  /**
-   * Get server entry by name
-   */
-  getServer(name: string): ServerEntry | undefined {
-    return this.servers.get(name);
-  }
-
-  /**
-   * Get all registered server names
-   */
-  getServerNames(): string[] {
-    return Array.from(this.servers.keys());
-  }
-
-  /**
-   * Get all connected server names
-   */
-  getConnectedServers(): string[] {
-    return Array.from(this.servers.entries())
-      .filter(([, entry]) => entry.status === 'connected')
-      .map(([name]) => name);
-  }
-
-  /**
-   * Get all server entries
-   */
-  getAllServers(): Map<string, ServerEntry> {
-    return new Map(this.servers);
-  }
-
-  /**
-   * Get tools from a connected server
-   */
-  getTools(name: string): McpTool[] {
-    const entry = this.servers.get(name);
-    return entry?.tools ?? [];
-  }
-
-  /**
-   * Get all tools from all connected servers
-   */
-  getAllTools(): Map<string, McpTool[]> {
-    const result = new Map<string, McpTool[]>();
-    for (const [name, entry] of this.servers) {
-      if (entry.status === 'connected' && entry.tools.length > 0) {
-        result.set(name, entry.tools);
-      }
-    }
-    return result;
-  }
-
-  /**
-   * Get tool mappings for a server
-   */
-  getMappings(name: string): ToolMapping[] {
-    const entry = this.servers.get(name);
-    return entry?.mappings ?? [];
-  }
-
-  /**
-   * Get all mappings grouped by adapter type
-   */
-  getAllMappingsByAdapter(): Map<string, Map<string, ToolMapping[]>> {
-    const result = new Map<string, Map<string, ToolMapping[]>>();
-
-    for (const [serverName, entry] of this.servers) {
-      if (entry.mappings.length > 0) {
-        const grouped = groupMappingsByAdapter(entry.mappings);
-        for (const [adapterType, mappings] of grouped) {
-          let adapterMap = result.get(adapterType);
-          if (!adapterMap) {
-            adapterMap = new Map();
-            result.set(adapterType, adapterMap);
-          }
-          adapterMap.set(serverName, mappings);
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Find servers that provide a specific adapter type
-   */
-  findServersForAdapter(
-    adapterType: 'issue_tracker' | 'git' | 'documentation' | 'state'
-  ): string[] {
-    const servers: string[] = [];
-
-    for (const [name, entry] of this.servers) {
-      if (entry.status === 'connected') {
-        const hasAdapter = entry.mappings.some((m) => m.adapterType === adapterType);
-        if (hasAdapter) {
-          servers.push(name);
-        }
-      }
-    }
-
-    return servers;
-  }
-
-  /**
-   * Call a tool on a connected server
-   */
-  async callTool(
-    serverName: string,
-    toolName: string,
-    args?: Record<string, unknown>
-  ): Promise<unknown> {
-    const entry = this.servers.get(serverName);
-    if (!entry) {
-      throw new McpError(
-        `Server "${serverName}" is not registered`,
-        'server_not_found',
-        serverName
-      );
-    }
-
-    if (entry.status !== 'connected' || !entry.client) {
-      throw new McpError(
-        `Server "${serverName}" is not connected`,
-        'connection_closed',
-        serverName
-      );
-    }
-
-    return entry.client.callTool(toolName, args);
-  }
-
-  /**
-   * Get registry status summary
-   */
-  getStatus(): RegistryStatus {
-    const servers: Record<string, ServerStatusSummary> = {};
-
-    for (const [name, entry] of this.servers) {
-      const summary: ServerStatusSummary = {
-        status: entry.status,
-        toolCount: entry.tools.length,
-        resourceCount: entry.resources.length,
-        mappingCount: entry.mappings.length,
-      };
-      if (entry.lastError?.message) {
-        summary.lastError = entry.lastError.message;
-      }
-      servers[name] = summary;
-    }
-
-    return {
-      totalServers: this.servers.size,
-      connectedServers: this.getConnectedServers().length,
-      servers,
-    };
-  }
-
-  /**
-   * Internal: perform connection with retries
-   */
-  private async doConnect(entry: ServerEntry, attempt = 1): Promise<McpServerInfo> {
-    const name = entry.definition.name;
-    entry.status = 'connecting';
-    entry.lastAttempt = new Date();
-
-    try {
-      // Create client if needed
-      if (!entry.client) {
-        entry.client = new McpClient(name, entry.definition.config, this.options.clientOptions);
-      }
-
-      // Connect
-      await entry.client.connect();
-
-      // Get server info
-      const info = entry.client.getServerInfo();
-      if (!info) {
-        throw new McpError(`Failed to get server info for "${name}"`, 'protocol_error', name);
-      }
-
-      // Cache tools and resources
-      if (info.capabilities?.tools) {
-        entry.tools = await entry.client.listTools();
-      }
-      if (info.capabilities?.resources) {
-        entry.resources = await entry.client.listResources();
-      }
-
-      // Generate mappings
-      entry.mappings = getMappingsForServer(name, entry.tools);
-
-      // Update status
-      entry.status = 'connected';
-      entry.info = info;
-      entry.lastError = null;
-
-      this.emit('serverConnected', name, info);
-      return info;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      entry.lastError = err;
-
-      // Retry if we haven't exceeded max retries
-      if (attempt < this.options.maxRetries) {
-        await this.delay(this.options.retryDelay);
-        return this.doConnect(entry, attempt + 1);
-      }
-
-      // Mark as error status
-      entry.status = 'error';
-      entry.client = null;
-
-      this.emit('serverError', name, err);
-      throw err;
-    }
-  }
-
-  /**
-   * Internal: delay helper
-   */
-  private delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-}
-
-/**
- * Server status summary
- */
-export interface ServerStatusSummary {
-  status: ServerStatus;
-  toolCount: number;
-  resourceCount: number;
-  mappingCount: number;
-  lastError?: string;
-}
-
-/**
- * Registry status
- */
-export interface RegistryStatus {
-  totalServers: number;
-  connectedServers: number;
-  servers: Record<string, ServerStatusSummary>;
-}
-
-/**
- * Create a new registry with default options
- */
-export function createRegistry(options?: RegistryOptions): McpRegistry {
-  return new McpRegistry(options);
-}