@deimoscloud/coreai 0.1.0

package/src/adapters/mcp/registry.ts

@@ -0,0 +1,550 @@
+/**
+ * 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);
+}