mcp-rubber-duck 1.1.0

package/src/services/mcp-client-manager.ts

@@ -0,0 +1,362 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { logger } from '../utils/logger.js';
+import { SafeLogger } from '../utils/safe-logger.js';
+
+export interface MCPServerConfig {
+  name: string;
+  type: 'stdio' | 'http';
+  command?: string;  // for stdio
+  args?: string[];   // for stdio
+  url?: string;      // for http
+  apiKey?: string;   // for http auth
+  enabled?: boolean;
+  retryAttempts?: number; // Number of retry attempts (default: 3)
+  retryDelay?: number;    // Initial retry delay in ms (default: 1000)
+}
+
+export interface MCPTool {
+  serverName: string;
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export class MCPClientManager {
+  private clients: Map<string, Client> = new Map();
+  private configs: MCPServerConfig[] = [];
+  private connectionStatus: Map<string, 'connected' | 'connecting' | 'disconnected' | 'error'> = new Map();
+  private retryInfo: Map<string, { attempts: number; lastAttempt: number }> = new Map();
+
+  constructor(configs: MCPServerConfig[] = []) {
+    this.configs = configs.filter(config => config.enabled !== false);
+  }
+
+  async initialize(): Promise<void> {
+    logger.info(`Initializing MCP Client Manager with ${this.configs.length} servers`);
+    
+    const connectionPromises = this.configs.map(config => this.connectToServer(config));
+    
+    // Connect to all servers in parallel, but don't fail if some fail
+    const results = await Promise.allSettled(connectionPromises);
+    
+    let successCount = 0;
+    results.forEach((result, index) => {
+      const serverName = this.configs[index].name;
+      if (result.status === 'fulfilled') {
+        successCount++;
+        logger.info(`Successfully connected to MCP server: ${serverName}`);
+      } else {
+        logger.error(`Failed to connect to MCP server ${serverName}:`, result.reason);
+        this.connectionStatus.set(serverName, 'error');
+      }
+    });
+    
+    logger.info(`MCP Client Manager initialized: ${successCount}/${this.configs.length} servers connected`);
+  }
+
+  private async connectToServer(config: MCPServerConfig): Promise<Client> {
+    const { name, type } = config;
+    const maxRetries = config.retryAttempts ?? 3;
+    const initialDelay = config.retryDelay ?? 1000;
+    
+    if (this.clients.has(name)) {
+      logger.warn(`MCP server ${name} already connected`);
+      return this.clients.get(name)!;
+    }
+    
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        this.connectionStatus.set(name, 'connecting');
+        this.retryInfo.set(name, { attempts: attempt, lastAttempt: Date.now() });
+        
+        if (attempt > 0) {
+          const delay = initialDelay * Math.pow(2, attempt - 1); // Exponential backoff
+          logger.info(`Retrying connection to MCP server ${name} (attempt ${attempt}/${maxRetries}) after ${delay}ms`);
+          await this.sleep(delay);
+        }
+        
+        // Create client
+        const client = new Client({
+          name: 'mcp-rubber-duck',
+          version: '1.0.0',
+        }, {
+          capabilities: {
+            tools: {},
+          },
+        });
+        
+        // Create transport based on type
+        let transport;
+        if (type === 'stdio') {
+          if (!config.command) {
+            throw new Error(`stdio server ${name} requires command`);
+          }
+          
+          transport = new StdioClientTransport({
+            command: config.command,
+            args: config.args || [],
+          });
+        } else if (type === 'http') {
+          if (!config.url) {
+            throw new Error(`http server ${name} requires url`);
+          }
+          
+          // HTTP transport using StreamableHTTPClientTransport
+          const url = new URL(config.url);
+          const transportOptions: { requestInit?: { headers?: Record<string, string> } } = {};
+          
+          if (config.apiKey) {
+            transportOptions.requestInit = {
+              headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+              },
+            };
+          }
+          
+          transport = new StreamableHTTPClientTransport(url, transportOptions);
+        } else {
+          throw new Error(`Unsupported transport type: ${String(type)}`);
+        }
+        
+        // Connect to server with timeout
+        const connectTimeout = new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Connection timeout')), 30000)
+        );
+        
+        await Promise.race([
+          client.connect(transport),
+          connectTimeout
+        ]);
+        
+        this.clients.set(name, client);
+        this.connectionStatus.set(name, 'connected');
+        this.retryInfo.delete(name); // Clear retry info on success
+        
+        logger.info(`Connected to MCP server: ${name} (${type}) after ${attempt} retries`);
+        return client;
+        
+      } catch (error: unknown) {
+        logger.warn(`Failed to connect to MCP server ${name} (attempt ${attempt + 1}/${maxRetries + 1}):`, error instanceof Error ? error.message : String(error));
+        
+        if (attempt === maxRetries) {
+          this.connectionStatus.set(name, 'error');
+          this.retryInfo.set(name, { attempts: attempt + 1, lastAttempt: Date.now() });
+          logger.error(`All retry attempts exhausted for MCP server ${name}`);
+          throw error;
+        }
+      }
+    }
+    
+    throw new Error(`Failed to connect to MCP server ${name} after ${maxRetries + 1} attempts`);
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  async disconnectAll(): Promise<void> {
+    logger.info('Disconnecting all MCP clients');
+    
+    const disconnectPromises = Array.from(this.clients.entries()).map(async ([name, client]) => {
+      try {
+        await client.close();
+        this.connectionStatus.set(name, 'disconnected');
+        logger.info(`Disconnected from MCP server: ${name}`);
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Error disconnecting from MCP server ${name}:`, errorMessage);
+      }
+    });
+    
+    await Promise.allSettled(disconnectPromises);
+    
+    this.clients.clear();
+    logger.info('All MCP clients disconnected');
+  }
+
+  getClient(serverName: string): Client | undefined {
+    const client = this.clients.get(serverName);
+    const status = this.connectionStatus.get(serverName);
+    
+    if (!client || status !== 'connected') {
+      return undefined;
+    }
+    
+    return client;
+  }
+
+  getConnectionStatus(serverName: string): 'connected' | 'connecting' | 'disconnected' | 'error' | 'unknown' {
+    return this.connectionStatus.get(serverName) || 'unknown';
+  }
+
+  getConnectedServers(): string[] {
+    return Array.from(this.clients.keys()).filter(name => 
+      this.connectionStatus.get(name) === 'connected'
+    );
+  }
+
+  async listAllTools(): Promise<MCPTool[]> {
+    const allTools: MCPTool[] = [];
+    
+    for (const [serverName, client] of this.clients.entries()) {
+      if (this.connectionStatus.get(serverName) !== 'connected') {
+        continue;
+      }
+      
+      try {
+        const toolsResult = await client.listTools();
+        
+        if (toolsResult.tools) {
+          const serverTools = toolsResult.tools.map(tool => ({
+            serverName,
+            name: tool.name,
+            description: tool.description || '',
+            inputSchema: tool.inputSchema,
+          }));
+          
+          allTools.push(...serverTools);
+          logger.debug(`Listed ${serverTools.length} tools from ${serverName}`);
+        }
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`Failed to list tools from ${serverName}:`, errorMessage);
+      }
+    }
+    
+    logger.debug(`Total MCP tools available: ${allTools.length}`);
+    return allTools;
+  }
+
+  async listServerTools(serverName: string): Promise<MCPTool[]> {
+    const client = this.getClient(serverName);
+    if (!client) {
+      throw new Error(`MCP server ${serverName} not connected`);
+    }
+    
+    try {
+      const toolsResult = await client.listTools();
+      
+      if (!toolsResult.tools) {
+        return [];
+      }
+      
+      return toolsResult.tools.map(tool => ({
+        serverName,
+        name: tool.name,
+        description: tool.description || '',
+        inputSchema: tool.inputSchema,
+      }));
+    } catch (error: unknown) {
+      logger.error(`Failed to list tools from ${serverName}:`, error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  }
+
+  async callTool(serverName: string, toolName: string, args: Record<string, unknown>): Promise<unknown> {
+    const client = this.getClient(serverName);
+    if (!client) {
+      throw new Error(`MCP server ${serverName} not connected`);
+    }
+    
+    try {
+      SafeLogger.debug(`Calling MCP tool ${serverName}:${toolName} with args:`, args);
+      
+      const result = await client.callTool({
+        name: toolName,
+        arguments: args,
+      });
+      
+      SafeLogger.debug(`MCP tool ${serverName}:${toolName} returned:`, result);
+      return result;
+      
+    } catch (error: unknown) {
+      logger.error(`Failed to call MCP tool ${serverName}:${toolName}:`, error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  }
+
+  // Health check for all connected servers
+  async healthCheck(): Promise<Record<string, boolean>> {
+    const healthStatus: Record<string, boolean> = {};
+    
+    for (const [serverName, client] of this.clients.entries()) {
+      try {
+        // Try to list tools as a health check
+        await client.listTools();
+        healthStatus[serverName] = true;
+        this.connectionStatus.set(serverName, 'connected');
+      } catch (error: unknown) {
+        healthStatus[serverName] = false;
+        this.connectionStatus.set(serverName, 'error');
+        logger.warn(`Health check failed for MCP server ${serverName}:`, error instanceof Error ? error.message : String(error));
+      }
+    }
+    
+    return healthStatus;
+  }
+
+  // Get status of all servers
+  getStatus(): Record<string, {
+    status: string;
+    type: string;
+    toolCount?: number;
+    retryAttempts?: number;
+    lastAttempt?: number;
+  }> {
+    const status: Record<string, {
+      status: string;
+      type: string;
+      retryAttempts?: number;
+      lastAttempt?: number;
+    }> = {};
+    
+    this.configs.forEach(config => {
+      const retryInfo = this.retryInfo.get(config.name);
+      status[config.name] = {
+        status: this.connectionStatus.get(config.name) || 'unknown',
+        type: config.type,
+        ...(retryInfo && {
+          retryAttempts: retryInfo.attempts,
+          lastAttempt: retryInfo.lastAttempt,
+        }),
+      };
+    });
+    
+    return status;
+  }
+
+  // Get retry information for a specific server
+  getRetryInfo(serverName: string): { attempts: number; lastAttempt: number } | undefined {
+    return this.retryInfo.get(serverName);
+  }
+
+  // Retry connection for a specific server
+  async retryConnection(serverName: string): Promise<boolean> {
+    const config = this.configs.find(c => c.name === serverName);
+    if (!config) {
+      logger.error(`Server config not found for ${serverName}`);
+      return false;
+    }
+
+    try {
+      // Disconnect first if connected
+      const existingClient = this.clients.get(serverName);
+      if (existingClient) {
+        await existingClient.close();
+        this.clients.delete(serverName);
+      }
+
+      // Reset retry info
+      this.retryInfo.delete(serverName);
+      
+      // Attempt to connect
+      await this.connectToServer(config);
+      return true;
+    } catch (error: unknown) {
+      logger.error(`Manual retry failed for ${serverName}:`, error instanceof Error ? error.message : String(error));
+      return false;
+    }
+  }
+}

package/src/tools/approve-mcp-request.ts

@@ -0,0 +1,126 @@
+import { ApprovalService } from '../services/approval.js';
+
+export function approveMCPRequestTool(
+  approvalService: ApprovalService,
+  args: Record<string, unknown>
+) {
+  const { approval_id, decision, reason } = args as {
+    approval_id?: string;
+    decision?: string;
+    reason?: string;
+  };
+
+  if (!approval_id || !decision) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: '❌ Missing required parameters: approval_id and decision are required',
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  if (!['approve', 'deny'].includes(decision)) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: '❌ Decision must be either "approve" or "deny"',
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  try {
+    // Get the request details before processing
+    const request = approvalService.getApprovalRequest(approval_id);
+    
+    if (!request) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `❌ Approval request ${approval_id} not found`,
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    if (request.status !== 'pending') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `❌ Request ${approval_id} is not pending (status: ${request.status})`,
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    let success = false;
+    let message = '';
+
+    if (decision === 'approve') {
+      success = approvalService.approveRequest(approval_id);
+      if (success) {
+        message = `✅ Approved: ${request.duckName} can now call ${request.mcpServer}:${request.toolName}`;
+      } else {
+        message = `❌ Failed to approve request ${approval_id}`;
+      }
+    } else {
+      success = approvalService.denyRequest(approval_id, reason);
+      if (success) {
+        message = `❌ Denied: ${request.duckName} cannot call ${request.mcpServer}:${request.toolName}`;
+        if (reason) {
+          message += `\nReason: ${reason}`;
+        }
+      } else {
+        message = `❌ Failed to deny request ${approval_id}`;
+      }
+    }
+
+    // Add request details for context
+    const detailsLines = [
+      message,
+      '',
+      '📋 **Request Details:**',
+      `- Duck: ${request.duckName}`,
+      `- MCP Server: ${request.mcpServer}`,
+      `- Tool: ${request.toolName}`,
+      `- Arguments: \`${JSON.stringify(request.arguments)}\``,
+      `- Request ID: \`${request.id}\``,
+    ];
+
+    // Add next steps
+    if (decision === 'approve') {
+      detailsLines.push('');
+      detailsLines.push('💡 The duck can now retry their request with the approval.');
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: detailsLines.join('\n'),
+        },
+      ],
+      isError: !success,
+    };
+
+  } catch (error: unknown) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `❌ Error processing approval: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+}

package/src/tools/ask-duck.ts

@@ -0,0 +1,74 @@
+import { ProviderManager } from '../providers/manager.js';
+import { ResponseCache } from '../services/cache.js';
+import { formatDuckResponse } from '../utils/ascii-art.js';
+import { logger } from '../utils/logger.js';
+
+export async function askDuckTool(
+  providerManager: ProviderManager,
+  cache: ResponseCache,
+  args: Record<string, unknown>
+) {
+  const { prompt, provider, model, temperature } = args as {
+    prompt?: string;
+    provider?: string;
+    model?: string;
+    temperature?: number;
+  };
+
+  if (!prompt) {
+    throw new Error('Prompt is required');
+  }
+
+  // Validate model if provided
+  if (model && provider) {
+    const isValid = providerManager.validateModel(provider, model);
+    if (!isValid) {
+      logger.warn(`Model ${model} may not be valid for provider ${provider}`);
+    }
+  }
+
+  // Generate cache key
+  const cacheKey = cache.generateKey(
+    provider || 'default',
+    prompt,
+    { model, temperature }
+  );
+
+  // Try to get cached response
+  const { value: response, cached } = await cache.getOrSet(
+    cacheKey,
+    async () => {
+      return await providerManager.askDuck(provider, prompt, {
+        model,
+        temperature,
+      });
+    }
+  );
+
+  // Format the response
+  const formattedResponse = formatDuckResponse(
+    response.nickname,
+    response.content,
+    response.model
+  );
+
+  // Add usage info if available
+  let usageInfo = '';
+  if (response.usage) {
+    usageInfo = `\n\n📊 Tokens used: ${response.usage.total_tokens} (${response.usage.prompt_tokens} prompt, ${response.usage.completion_tokens} completion)`;
+  }
+
+  // Add cache and latency info
+  const metaInfo = `\n⏱️ Latency: ${response.latency}ms | ${cached ? '💾 Cached' : '🔄 Fresh'}`;
+
+  logger.info(`Duck ${response.nickname} responded to query ${cached ? '(cached)' : ''}`);
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: formattedResponse + usageInfo + metaInfo,
+      },
+    ],
+  };
+}

package/src/tools/chat-duck.ts

@@ -0,0 +1,82 @@
+import { ProviderManager } from '../providers/manager.js';
+import { ConversationManager } from '../services/conversation.js';
+import { formatDuckResponse } from '../utils/ascii-art.js';
+import { logger } from '../utils/logger.js';
+
+export async function chatDuckTool(
+  providerManager: ProviderManager,
+  conversationManager: ConversationManager,
+  args: Record<string, unknown>
+) {
+  const { conversation_id, message, provider, model } = args as {
+    conversation_id?: string;
+    message?: string;
+    provider?: string;
+    model?: string;
+  };
+
+  if (!conversation_id || !message) {
+    throw new Error('conversation_id and message are required');
+  }
+
+  // Get or create conversation
+  let conversation = conversationManager.getConversation(conversation_id);
+  
+  if (!conversation) {
+    // Create new conversation with specified or default provider
+    const providerName = provider || providerManager.getProviderNames()[0];
+    conversation = conversationManager.createConversation(conversation_id, providerName);
+    logger.info(`Created new conversation: ${conversation_id} with ${providerName}`);
+  } else if (provider && provider !== conversation.provider) {
+    // Switch provider if requested
+    conversation = conversationManager.switchProvider(conversation_id, provider);
+    logger.info(`Switched conversation ${conversation_id} to ${provider}`);
+  }
+
+  // Add user message to conversation
+  conversationManager.addMessage(conversation_id, {
+    role: 'user',
+    content: message,
+    timestamp: new Date(),
+  });
+
+  // Get conversation context
+  const messages = conversationManager.getConversationContext(conversation_id);
+
+  // Get response from provider
+  const providerToUse = provider || conversation.provider;
+  const response = await providerManager.askDuck(providerToUse, '', {
+    messages,
+    model,
+  });
+
+  // Add assistant response to conversation
+  conversationManager.addMessage(conversation_id, {
+    role: 'assistant',
+    content: response.content,
+    timestamp: new Date(),
+    provider: providerToUse,
+  });
+
+  // Format response
+  const formattedResponse = formatDuckResponse(
+    response.nickname,
+    response.content,
+    response.model
+  );
+
+  // Add conversation info
+  const conversationInfo = `\n\n💬 Conversation: ${conversation_id} | Messages: ${messages.length + 1}`;
+  const latencyInfo = `\n⏱️ Latency: ${response.latency}ms`;
+
+  logger.info(`Duck ${response.nickname} responded in conversation ${conversation_id}`);
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: formattedResponse + conversationInfo + latencyInfo,
+      },
+    ],
+  };
+}

package/src/tools/clear-conversations.ts

@@ -0,0 +1,24 @@
+import { ConversationManager } from '../services/conversation.js';
+import { logger } from '../utils/logger.js';
+
+export function clearConversationsTool(
+  conversationManager: ConversationManager,
+  _args: Record<string, unknown>
+) {
+  const result = conversationManager.clearAll();
+  
+  logger.info(`User cleared ${result.conversationsCleared} conversations`);
+  
+  const message = result.conversationsCleared === 0 
+    ? '🧹 No conversations to clear - memory is already empty!'
+    : `🧹 Cleared ${result.conversationsCleared} conversation${result.conversationsCleared === 1 ? '' : 's'} (${result.messagesCleared} message${result.messagesCleared === 1 ? '' : 's'})`;
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `${message}\n\n🦆 All ducks now have a fresh start! Previous conversation context has been removed.`,
+      },
+    ],
+  };
+}