mcp-rubber-duck 1.1.0

package/src/services/approval.ts

@@ -0,0 +1,225 @@
+import { logger } from '../utils/logger.js';
+import { SafeLogger } from '../utils/safe-logger.js';
+import { randomUUID } from 'crypto';
+
+export interface ApprovalRequest {
+  id: string;
+  timestamp: number;
+  duckName: string;
+  mcpServer: string;
+  toolName: string;
+  arguments: Record<string, unknown>;
+  status: 'pending' | 'approved' | 'denied' | 'expired';
+  approvedBy?: string;
+  deniedReason?: string;
+  expiresAt: number;
+}
+
+export type ApprovalStatus = 'pending' | 'approved' | 'denied' | 'expired';
+
+export class ApprovalService {
+  private pendingApprovals: Map<string, ApprovalRequest> = new Map();
+  private approvalTimeout: number;
+  private cleanupInterval: NodeJS.Timeout | null = null;
+  private approvedToolsForSession: Set<string> = new Set();
+
+  constructor(approvalTimeoutSeconds: number = 300) {
+    this.approvalTimeout = approvalTimeoutSeconds * 1000; // Convert to milliseconds
+    this.startCleanupTimer();
+  }
+
+  createApprovalRequest(
+    duckName: string,
+    mcpServer: string,
+    toolName: string,
+    args: Record<string, unknown>
+  ): ApprovalRequest {
+    const id = randomUUID();
+    const now = Date.now();
+    
+    const request: ApprovalRequest = {
+      id,
+      timestamp: now,
+      duckName,
+      mcpServer,
+      toolName,
+      arguments: args,
+      status: 'pending',
+      expiresAt: now + this.approvalTimeout,
+    };
+
+    this.pendingApprovals.set(id, request);
+    
+    const safeMessage = SafeLogger.createApprovalMessage(duckName, mcpServer, toolName, args);
+    logger.info(`Created approval request ${id} for ${duckName} to call ${mcpServer}:${toolName}`);
+    SafeLogger.debug(`Approval request details:`, { id, duckName, mcpServer, toolName, safeMessage });
+    
+    return request;
+  }
+
+  getApprovalRequest(id: string): ApprovalRequest | undefined {
+    const request = this.pendingApprovals.get(id);
+    
+    // Check if expired
+    if (request && Date.now() > request.expiresAt && request.status === 'pending') {
+      request.status = 'expired';
+      logger.info(`Approval request ${id} has expired`);
+    }
+    
+    return request;
+  }
+
+  getApprovalStatus(id: string): ApprovalStatus | undefined {
+    const request = this.getApprovalRequest(id);
+    return request?.status;
+  }
+
+  approveRequest(id: string, approvedBy: string = 'user'): boolean {
+    const request = this.getApprovalRequest(id);
+    
+    if (!request) {
+      logger.warn(`Approval request ${id} not found`);
+      return false;
+    }
+    
+    if (request.status !== 'pending') {
+      logger.warn(`Approval request ${id} is not pending (status: ${request.status})`);
+      return false;
+    }
+    
+    if (Date.now() > request.expiresAt) {
+      request.status = 'expired';
+      logger.warn(`Approval request ${id} has expired`);
+      return false;
+    }
+    
+    request.status = 'approved';
+    request.approvedBy = approvedBy;
+    
+    // Mark tool as approved for this session
+    const sessionKey = this.createSessionKey(request.duckName, request.mcpServer, request.toolName);
+    this.approvedToolsForSession.add(sessionKey);
+    
+    logger.info(`Approval request ${id} approved by ${approvedBy} - tool ${sessionKey} now approved for session`);
+    return true;
+  }
+
+  denyRequest(id: string, reason?: string): boolean {
+    const request = this.getApprovalRequest(id);
+    
+    if (!request) {
+      logger.warn(`Approval request ${id} not found`);
+      return false;
+    }
+    
+    if (request.status !== 'pending') {
+      logger.warn(`Approval request ${id} is not pending (status: ${request.status})`);
+      return false;
+    }
+    
+    request.status = 'denied';
+    request.deniedReason = reason;
+    
+    logger.info(`Approval request ${id} denied${reason ? `: ${reason}` : ''}`);
+    return true;
+  }
+
+  getPendingApprovals(): ApprovalRequest[] {
+    // Clean up expired requests first
+    this.cleanupExpired();
+    
+    return Array.from(this.pendingApprovals.values())
+      .filter(request => request.status === 'pending');
+  }
+
+  getAllApprovals(): ApprovalRequest[] {
+    // Clean up expired requests first
+    this.cleanupExpired();
+    
+    return Array.from(this.pendingApprovals.values());
+  }
+
+  getApprovalsByDuck(duckName: string): ApprovalRequest[] {
+    return Array.from(this.pendingApprovals.values())
+      .filter(request => request.duckName === duckName);
+  }
+
+  cleanupExpired(): number {
+    const now = Date.now();
+    let cleanedUp = 0;
+    
+    for (const [id, request] of this.pendingApprovals.entries()) {
+      if (now > request.expiresAt && request.status === 'pending') {
+        request.status = 'expired';
+        logger.debug(`Marked approval request ${id} as expired`);
+        cleanedUp++;
+      }
+    }
+    
+    return cleanedUp;
+  }
+
+  private startCleanupTimer(): void {
+    // Clean up expired requests every minute
+    this.cleanupInterval = setInterval(() => {
+      const cleaned = this.cleanupExpired();
+      if (cleaned > 0) {
+        logger.debug(`Cleaned up ${cleaned} expired approval requests`);
+      }
+    }, 60000);
+  }
+
+  shutdown(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+
+  // Session-based approval methods
+  private createSessionKey(duckName: string, mcpServer: string, toolName: string): string {
+    return `${duckName}:${mcpServer}:${toolName}`;
+  }
+
+  isToolApprovedForSession(duckName: string, mcpServer: string, toolName: string): boolean {
+    const sessionKey = this.createSessionKey(duckName, mcpServer, toolName);
+    return this.approvedToolsForSession.has(sessionKey);
+  }
+
+  markToolAsApprovedForSession(duckName: string, mcpServer: string, toolName: string): void {
+    const sessionKey = this.createSessionKey(duckName, mcpServer, toolName);
+    this.approvedToolsForSession.add(sessionKey);
+    logger.info(`Tool ${sessionKey} marked as approved for session`);
+  }
+
+  clearSessionApprovals(): void {
+    const count = this.approvedToolsForSession.size;
+    this.approvedToolsForSession.clear();
+    logger.info(`Cleared ${count} session approvals`);
+  }
+
+  getSessionApprovals(): string[] {
+    return Array.from(this.approvedToolsForSession);
+  }
+
+  // For debugging/admin purposes
+  getStats(): {
+    total: number;
+    pending: number;
+    approved: number;
+    denied: number;
+    expired: number;
+  } {
+    this.cleanupExpired();
+    
+    const all = Array.from(this.pendingApprovals.values());
+    
+    return {
+      total: all.length,
+      pending: all.filter(r => r.status === 'pending').length,
+      approved: all.filter(r => r.status === 'approved').length,
+      denied: all.filter(r => r.status === 'denied').length,
+      expired: all.filter(r => r.status === 'expired').length,
+    };
+  }
+}

package/src/services/cache.ts

@@ -0,0 +1,79 @@
+import NodeCache from 'node-cache';
+import { createHash } from 'crypto';
+import { logger } from '../utils/logger.js';
+
+export class ResponseCache {
+  private cache: NodeCache;
+
+  constructor(ttlSeconds: number = 300) {
+    this.cache = new NodeCache({
+      stdTTL: ttlSeconds,
+      checkperiod: ttlSeconds * 0.2,
+      useClones: false,
+    });
+
+    this.cache.on('expired', (key) => {
+      logger.debug(`Cache expired for key: ${key}`);
+    });
+  }
+
+  generateKey(provider: string, prompt: string, options?: Record<string, unknown>): string {
+    const data = JSON.stringify({ provider, prompt, options });
+    return createHash('sha256').update(data).digest('hex');
+  }
+
+  get<T>(key: string): T | undefined {
+    return this.cache.get<T>(key);
+  }
+
+  set<T>(key: string, value: T, ttl?: number): boolean {
+    if (ttl !== undefined) {
+      return this.cache.set(key, value, ttl);
+    } else {
+      return this.cache.set(key, value);
+    }
+  }
+
+  has(key: string): boolean {
+    return this.cache.has(key);
+  }
+
+  delete(key: string): number {
+    return this.cache.del(key);
+  }
+
+  flush(): void {
+    this.cache.flushAll();
+    logger.debug('Cache flushed');
+  }
+
+  getStats() {
+    const stats = this.cache.getStats();
+    return {
+      keys: this.cache.keys().length,
+      hits: stats.hits,
+      misses: stats.misses,
+      hitRate: stats.hits / (stats.hits + stats.misses) || 0,
+    };
+  }
+
+  // Helper method for caching provider responses
+  async getOrSet<T>(
+    key: string,
+    fetcher: () => Promise<T>,
+    ttl?: number
+  ): Promise<{ value: T; cached: boolean }> {
+    const cached = this.get<T>(key);
+    
+    if (cached !== undefined) {
+      logger.debug(`Cache hit for key: ${key}`);
+      return { value: cached, cached: true };
+    }
+
+    logger.debug(`Cache miss for key: ${key}`);
+    const value = await fetcher();
+    this.set(key, value, ttl);
+    
+    return { value, cached: false };
+  }
+}

package/src/services/conversation.ts

@@ -0,0 +1,146 @@
+import { Conversation, ConversationMessage } from '../config/types.js';
+import { logger } from '../utils/logger.js';
+
+export class ConversationManager {
+  private conversations: Map<string, Conversation> = new Map();
+  private maxConversationSize = 50; // Maximum messages per conversation
+
+  createConversation(id: string, provider: string): Conversation {
+    const conversation: Conversation = {
+      id,
+      messages: [],
+      provider,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    this.conversations.set(id, conversation);
+    logger.debug(`Created new conversation: ${id}`);
+    return conversation;
+  }
+
+  getConversation(id: string): Conversation | undefined {
+    return this.conversations.get(id);
+  }
+
+  addMessage(
+    conversationId: string,
+    message: ConversationMessage
+  ): Conversation {
+    const conversation = this.conversations.get(conversationId);
+    
+    if (!conversation) {
+      throw new Error(`Conversation ${conversationId} not found`);
+    }
+
+    conversation.messages.push(message);
+    conversation.updatedAt = new Date();
+
+    // Trim conversation if too long
+    if (conversation.messages.length > this.maxConversationSize) {
+      const toRemove = conversation.messages.length - this.maxConversationSize;
+      conversation.messages = conversation.messages.slice(toRemove);
+      logger.debug(`Trimmed ${toRemove} messages from conversation ${conversationId}`);
+    }
+
+    this.conversations.set(conversationId, conversation);
+    return conversation;
+  }
+
+  switchProvider(conversationId: string, newProvider: string): Conversation {
+    const conversation = this.conversations.get(conversationId);
+    
+    if (!conversation) {
+      throw new Error(`Conversation ${conversationId} not found`);
+    }
+
+    conversation.provider = newProvider;
+    conversation.updatedAt = new Date();
+    
+    // Add a system message noting the provider switch
+    conversation.messages.push({
+      role: 'system',
+      content: `Switched to ${newProvider} duck`,
+      timestamp: new Date(),
+      provider: newProvider,
+    });
+
+    this.conversations.set(conversationId, conversation);
+    return conversation;
+  }
+
+  listConversations(): Array<{
+    id: string;
+    provider: string;
+    messageCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+  }> {
+    return Array.from(this.conversations.values()).map(conv => ({
+      id: conv.id,
+      provider: conv.provider,
+      messageCount: conv.messages.length,
+      createdAt: conv.createdAt,
+      updatedAt: conv.updatedAt,
+    }));
+  }
+
+  deleteConversation(id: string): boolean {
+    const deleted = this.conversations.delete(id);
+    if (deleted) {
+      logger.debug(`Deleted conversation: ${id}`);
+    }
+    return deleted;
+  }
+
+  clearOldConversations(maxAge: number = 24 * 60 * 60 * 1000) {
+    const now = Date.now();
+    let deleted = 0;
+
+    for (const [id, conversation] of this.conversations) {
+      if (now - conversation.updatedAt.getTime() > maxAge) {
+        this.conversations.delete(id);
+        deleted++;
+      }
+    }
+
+    if (deleted > 0) {
+      logger.info(`Cleared ${deleted} old conversations`);
+    }
+  }
+
+  getConversationContext(id: string, maxMessages?: number): ConversationMessage[] {
+    const conversation = this.conversations.get(id);
+    
+    if (!conversation) {
+      return [];
+    }
+
+    const messages = conversation.messages;
+    
+    if (maxMessages && messages.length > maxMessages) {
+      return messages.slice(-maxMessages);
+    }
+
+    return messages;
+  }
+
+  clearAll(): { conversationsCleared: number; messagesCleared: number } {
+    let totalMessages = 0;
+    
+    // Count total messages across all conversations
+    for (const conversation of this.conversations.values()) {
+      totalMessages += conversation.messages.length;
+    }
+    
+    const conversationsCleared = this.conversations.size;
+    this.conversations.clear();
+    
+    logger.info(`Cleared ${conversationsCleared} conversations with ${totalMessages} total messages`);
+    
+    return {
+      conversationsCleared,
+      messagesCleared: totalMessages,
+    };
+  }
+}