mcp-rubber-duck 1.5.1 → 1.6.0

package/tests/config.test.ts

@@ -4,6 +4,474 @@ import { ConfigManager } from '../src/config/config';
 // Mock logger to avoid console noise during tests
 jest.mock('../src/utils/logger');
 
+describe('ConfigManager - Default Providers', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    jest.clearAllMocks();
+    // Clear all provider keys
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    delete process.env.GROQ_API_KEY;
+    delete process.env.OLLAMA_BASE_URL;
+    delete process.env.ENABLE_OLLAMA;
+    Object.keys(process.env).forEach(key => {
+      if (key.startsWith('CUSTOM_')) delete process.env[key];
+    });
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should create OpenAI provider when API key is set', () => {
+    process.env.OPENAI_API_KEY = 'sk-test-key';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.openai).toBeDefined();
+    expect(providers.openai.api_key).toBe('sk-test-key');
+    expect(providers.openai.base_url).toBe('https://api.openai.com/v1');
+    expect(providers.openai.nickname).toBe('GPT Duck');
+  });
+
+  it('should use custom OpenAI model and nickname from env', () => {
+    process.env.OPENAI_API_KEY = 'sk-test-key';
+    process.env.OPENAI_DEFAULT_MODEL = 'gpt-4-turbo';
+    process.env.OPENAI_NICKNAME = 'Custom GPT Duck';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.openai.default_model).toBe('gpt-4-turbo');
+    expect(providers.openai.nickname).toBe('Custom GPT Duck');
+  });
+
+  it('should create Gemini provider when API key is set', () => {
+    process.env.GEMINI_API_KEY = 'gemini-test-key';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.gemini).toBeDefined();
+    expect(providers.gemini.api_key).toBe('gemini-test-key');
+    expect(providers.gemini.nickname).toBe('Gemini Duck');
+  });
+
+  it('should use custom Gemini model and nickname from env', () => {
+    process.env.GEMINI_API_KEY = 'gemini-test-key';
+    process.env.GEMINI_DEFAULT_MODEL = 'gemini-pro';
+    process.env.GEMINI_NICKNAME = 'Custom Gemini Duck';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.gemini.default_model).toBe('gemini-pro');
+    expect(providers.gemini.nickname).toBe('Custom Gemini Duck');
+  });
+
+  it('should create Groq provider when API key is set', () => {
+    process.env.GROQ_API_KEY = 'gsk-test-key';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.groq).toBeDefined();
+    expect(providers.groq.api_key).toBe('gsk-test-key');
+    expect(providers.groq.nickname).toBe('Groq Duck');
+  });
+
+  it('should use custom Groq model and nickname from env', () => {
+    process.env.GROQ_API_KEY = 'gsk-test-key';
+    process.env.GROQ_DEFAULT_MODEL = 'custom-groq-model';
+    process.env.GROQ_NICKNAME = 'Fast Groq Duck';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.groq.default_model).toBe('custom-groq-model');
+    expect(providers.groq.nickname).toBe('Fast Groq Duck');
+  });
+
+  it('should create Ollama provider when OLLAMA_BASE_URL is set', () => {
+    process.env.OPENAI_API_KEY = 'dummy'; // Need at least one provider
+    process.env.OLLAMA_BASE_URL = 'http://localhost:11434/v1';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.ollama).toBeDefined();
+    expect(providers.ollama.api_key).toBe('not-needed');
+    expect(providers.ollama.base_url).toBe('http://localhost:11434/v1');
+    expect(providers.ollama.nickname).toBe('Local Duck');
+  });
+
+  it('should create Ollama provider when ENABLE_OLLAMA is true', () => {
+    process.env.OPENAI_API_KEY = 'dummy'; // Need at least one provider
+    process.env.ENABLE_OLLAMA = 'true';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.ollama).toBeDefined();
+    expect(providers.ollama.base_url).toBe('http://localhost:11434/v1');
+  });
+
+  it('should use custom Ollama model and nickname from env', () => {
+    process.env.OPENAI_API_KEY = 'dummy';
+    process.env.ENABLE_OLLAMA = 'true';
+    process.env.OLLAMA_DEFAULT_MODEL = 'mistral';
+    process.env.OLLAMA_NICKNAME = 'My Local Duck';
+
+    const configManager = new ConfigManager();
+    const providers = configManager.getAllProviders();
+
+    expect(providers.ollama.default_model).toBe('mistral');
+    expect(providers.ollama.nickname).toBe('My Local Duck');
+  });
+});
+
+describe('ConfigManager - MCP Bridge Config', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    jest.clearAllMocks();
+    // Clear MCP-related env vars
+    Object.keys(process.env).forEach(key => {
+      if (key.startsWith('MCP_')) delete process.env[key];
+      if (key.startsWith('CUSTOM_')) delete process.env[key];
+    });
+    delete process.env.OPENAI_API_KEY;
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should enable MCP bridge when MCP_BRIDGE_ENABLED=true', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.enabled).toBe(true);
+  });
+
+  it('should disable MCP bridge when MCP_BRIDGE_ENABLED=false', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'false';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.enabled).toBe(false);
+  });
+
+  it('should set approval mode from environment', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+    process.env.MCP_APPROVAL_MODE = 'always';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.approval_mode).toBe('always');
+  });
+
+  it('should set approval timeout from environment', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+    process.env.MCP_APPROVAL_TIMEOUT = '120';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.approval_timeout).toBe(120);
+  });
+
+  it('should parse trusted tools from environment', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+    process.env.MCP_TRUSTED_TOOLS = 'tool1, tool2, tool3';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.trusted_tools).toEqual(['tool1', 'tool2', 'tool3']);
+  });
+
+  it('should parse trusted tools by server from environment', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+    process.env.MCP_TRUSTED_TOOLS_FILESYSTEM = 'read_file,write_file';
+
+    const configManager = new ConfigManager();
+    const trustedByServer = configManager.getConfig().mcp_bridge?.trusted_tools_by_server;
+    expect(trustedByServer?.filesystem).toEqual(['read_file', 'write_file']);
+  });
+
+  it('should handle wildcard trusted tools for server', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+    process.env.MCP_TRUSTED_TOOLS_INTERNAL_API = '*';
+
+    const configManager = new ConfigManager();
+    const trustedByServer = configManager.getConfig().mcp_bridge?.trusted_tools_by_server;
+    expect(trustedByServer?.['internal-api']).toEqual(['*']);
+  });
+
+  it('should auto-enable MCP bridge when MCP_SERVER_ env vars exist', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_TEST_TYPE = 'stdio';
+    process.env.MCP_SERVER_TEST_COMMAND = '/usr/bin/test-server';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.enabled).toBe(true);
+  });
+
+  it('should set approval mode to trusted', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+    process.env.MCP_APPROVAL_MODE = 'trusted';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.approval_mode).toBe('trusted');
+  });
+
+  it('should set approval mode to never', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_BRIDGE_ENABLED = 'true';
+    process.env.MCP_APPROVAL_MODE = 'never';
+
+    const configManager = new ConfigManager();
+    expect(configManager.getConfig().mcp_bridge?.approval_mode).toBe('never');
+  });
+});
+
+describe('ConfigManager - MCP Server Config from Environment', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    jest.clearAllMocks();
+    Object.keys(process.env).forEach(key => {
+      if (key.startsWith('MCP_')) delete process.env[key];
+    });
+    delete process.env.OPENAI_API_KEY;
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should configure stdio MCP server from environment', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_FILESYSTEM_TYPE = 'stdio';
+    process.env.MCP_SERVER_FILESYSTEM_COMMAND = 'npx @modelcontextprotocol/server-filesystem';
+    process.env.MCP_SERVER_FILESYSTEM_ARGS = '/home/user,/tmp';
+
+    const configManager = new ConfigManager();
+    const servers = configManager.getConfig().mcp_bridge?.mcp_servers;
+
+    expect(servers).toBeDefined();
+    expect(servers?.length).toBeGreaterThan(0);
+    const fsServer = servers?.find(s => s.name === 'filesystem');
+    expect(fsServer).toBeDefined();
+    expect(fsServer?.type).toBe('stdio');
+    expect(fsServer?.command).toBe('npx @modelcontextprotocol/server-filesystem');
+    expect(fsServer?.args).toEqual(['/home/user', '/tmp']);
+  });
+
+  it('should configure http MCP server from environment', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_MYAPI_TYPE = 'http';
+    process.env.MCP_SERVER_MYAPI_URL = 'https://api.example.com/mcp';
+    process.env.MCP_SERVER_MYAPI_API_KEY = 'server-api-key';
+
+    const configManager = new ConfigManager();
+    const servers = configManager.getConfig().mcp_bridge?.mcp_servers;
+
+    const httpServer = servers?.find(s => s.name === 'myapi');
+    expect(httpServer).toBeDefined();
+    expect(httpServer?.type).toBe('http');
+    expect(httpServer?.url).toBe('https://api.example.com/mcp');
+    expect(httpServer?.apiKey).toBe('server-api-key');
+  });
+
+  it('should skip stdio server without command', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_NOCOMMAND_TYPE = 'stdio';
+    // Missing COMMAND
+
+    const configManager = new ConfigManager();
+    const servers = configManager.getConfig().mcp_bridge?.mcp_servers;
+
+    const nocommandServer = servers?.find(s => s.name === 'nocommand');
+    expect(nocommandServer).toBeUndefined();
+  });
+
+  it('should skip http server without URL', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_NOURL_TYPE = 'http';
+    // Missing URL
+
+    const configManager = new ConfigManager();
+    const servers = configManager.getConfig().mcp_bridge?.mcp_servers;
+
+    const nourlServer = servers?.find(s => s.name === 'nourl');
+    expect(nourlServer).toBeUndefined();
+  });
+
+  it('should handle disabled MCP server', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_DISABLED_TYPE = 'stdio';
+    process.env.MCP_SERVER_DISABLED_COMMAND = 'some-command';
+    process.env.MCP_SERVER_DISABLED_ENABLED = 'false';
+
+    const configManager = new ConfigManager();
+    const servers = configManager.getConfig().mcp_bridge?.mcp_servers;
+
+    const disabledServer = servers?.find(s => s.name === 'disabled');
+    expect(disabledServer?.enabled).toBe(false);
+  });
+
+  it('should configure retry settings from environment', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_RETRYTEST_TYPE = 'stdio';
+    process.env.MCP_SERVER_RETRYTEST_COMMAND = 'test-command';
+    process.env.MCP_SERVER_RETRYTEST_RETRY_ATTEMPTS = '5';
+    process.env.MCP_SERVER_RETRYTEST_RETRY_DELAY = '2000';
+
+    const configManager = new ConfigManager();
+    const servers = configManager.getConfig().mcp_bridge?.mcp_servers;
+
+    const retryServer = servers?.find(s => s.name === 'retrytest');
+    expect(retryServer?.retryAttempts).toBe(5);
+    expect(retryServer?.retryDelay).toBe(2000);
+  });
+
+  it('should convert server names to lowercase with hyphens', () => {
+    process.env.OPENAI_API_KEY = 'test-key';
+    process.env.MCP_SERVER_MY_FANCY_SERVER_TYPE = 'stdio';
+    process.env.MCP_SERVER_MY_FANCY_SERVER_COMMAND = 'fancy-command';
+
+    const configManager = new ConfigManager();
+    const servers = configManager.getConfig().mcp_bridge?.mcp_servers;
+
+    const fancyServer = servers?.find(s => s.name === 'my-fancy-server');
+    expect(fancyServer).toBeDefined();
+  });
+});
+
+describe('ConfigManager - Public Methods', () => {
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    jest.clearAllMocks();
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    Object.keys(process.env).forEach(key => {
+      if (key.startsWith('CUSTOM_')) delete process.env[key];
+    });
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('getProvider', () => {
+    it('should return specific provider by name', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.GEMINI_API_KEY = 'gemini-key';
+
+      const configManager = new ConfigManager();
+      const provider = configManager.getProvider('openai');
+
+      expect(provider).toBeDefined();
+      expect(provider.api_key).toBe('openai-key');
+    });
+
+    it('should return undefined for non-existent provider', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+
+      const configManager = new ConfigManager();
+      const provider = configManager.getProvider('nonexistent');
+
+      expect(provider).toBeUndefined();
+    });
+  });
+
+  describe('getDefaultProvider', () => {
+    it('should return the default provider', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.DEFAULT_PROVIDER = 'openai';
+
+      const configManager = new ConfigManager();
+      const provider = configManager.getDefaultProvider();
+
+      expect(provider).toBeDefined();
+      expect(provider.api_key).toBe('openai-key');
+    });
+
+    it('should use first provider as default when none specified', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+      // No DEFAULT_PROVIDER set
+
+      const configManager = new ConfigManager();
+      const provider = configManager.getDefaultProvider();
+
+      expect(provider).toBeDefined();
+      expect(provider.api_key).toBe('openai-key');
+    });
+  });
+
+  describe('updateConfig', () => {
+    it('should update config with partial updates', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+
+      const configManager = new ConfigManager();
+      const originalTemp = configManager.getConfig().default_temperature;
+
+      configManager.updateConfig({ default_temperature: 0.99 });
+
+      expect(configManager.getConfig().default_temperature).toBe(0.99);
+      expect(configManager.getConfig().default_temperature).not.toBe(originalTemp);
+    });
+
+    it('should preserve existing config when updating', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+
+      const configManager = new ConfigManager();
+      configManager.updateConfig({ log_level: 'debug' });
+
+      expect(configManager.getConfig().log_level).toBe('debug');
+      expect(configManager.getConfig().providers.openai).toBeDefined();
+    });
+  });
+
+  describe('environment overrides', () => {
+    it('should override default_provider from environment', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.GEMINI_API_KEY = 'gemini-key';
+      process.env.DEFAULT_PROVIDER = 'gemini';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().default_provider).toBe('gemini');
+    });
+
+    it('should override default_temperature from environment', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.DEFAULT_TEMPERATURE = '0.9';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().default_temperature).toBe(0.9);
+    });
+
+    it('should override log_level from environment', () => {
+      process.env.OPENAI_API_KEY = 'openai-key';
+      process.env.LOG_LEVEL = 'debug';
+
+      const configManager = new ConfigManager();
+      expect(configManager.getConfig().log_level).toBe('debug');
+    });
+  });
+});
+
 describe('ConfigManager - Custom Providers', () => {
   let originalEnv: NodeJS.ProcessEnv;
 

package/tests/consensus.test.ts

@@ -121,6 +121,16 @@ describe('ConsensusService', () => {
       expect(result.choice).toBe('');
     });
 
+    it('should handle malformed JSON that looks like JSON', () => {
+      // This matches the JSON regex but fails JSON.parse
+      const response = '{"choice": Option A, confidence: 80}'; // Invalid JSON - missing quotes
+
+      const result = service.parseVote(response, 'provider1', 'Duck 1', options);
+      // Should fallback and try to extract from text
+      expect(result.choice).toBe('Option A');
+      expect(result.confidence).toBe(50); // Default fallback confidence
+    });
+
     it('should parse string confidence values', () => {
       const response = JSON.stringify({
         choice: 'Option A',

package/tests/conversation.test.ts

@@ -305,4 +305,90 @@ describe('ConversationManager', () => {
       expect(conversation!.provider).toBe('groq');
     });
   });
+
+  describe('clearOldConversations', () => {
+    it('should not delete recent conversations', () => {
+      conversationManager.createConversation('test-1', 'openai');
+      conversationManager.createConversation('test-2', 'groq');
+
+      // Clear with default maxAge (24 hours)
+      conversationManager.clearOldConversations();
+
+      // Both conversations should still exist
+      expect(conversationManager.getConversation('test-1')).toBeDefined();
+      expect(conversationManager.getConversation('test-2')).toBeDefined();
+    });
+
+    it('should delete conversations older than maxAge', () => {
+      // Create conversations with mocked old dates
+      const oldDate = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000); // 2 days ago
+
+      conversationManager.createConversation('old-1', 'openai');
+      conversationManager.createConversation('recent-1', 'groq');
+
+      // Manually set the updatedAt to simulate old conversation
+      const oldConversation = conversationManager.getConversation('old-1')!;
+      oldConversation.updatedAt = oldDate;
+
+      // Clear with 24 hour maxAge
+      conversationManager.clearOldConversations(24 * 60 * 60 * 1000);
+
+      // Old conversation should be deleted
+      expect(conversationManager.getConversation('old-1')).toBeUndefined();
+      // Recent conversation should still exist
+      expect(conversationManager.getConversation('recent-1')).toBeDefined();
+    });
+
+    it('should delete multiple old conversations', () => {
+      const oldDate = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
+
+      conversationManager.createConversation('old-1', 'openai');
+      conversationManager.createConversation('old-2', 'groq');
+      conversationManager.createConversation('recent-1', 'gemini');
+
+      const old1 = conversationManager.getConversation('old-1')!;
+      const old2 = conversationManager.getConversation('old-2')!;
+      old1.updatedAt = oldDate;
+      old2.updatedAt = oldDate;
+
+      conversationManager.clearOldConversations();
+
+      expect(conversationManager.getConversation('old-1')).toBeUndefined();
+      expect(conversationManager.getConversation('old-2')).toBeUndefined();
+      expect(conversationManager.getConversation('recent-1')).toBeDefined();
+      expect(conversationManager.listConversations()).toHaveLength(1);
+    });
+
+    it('should handle empty conversation list', () => {
+      // Should not throw
+      expect(() => conversationManager.clearOldConversations()).not.toThrow();
+    });
+
+    it('should use custom maxAge parameter', () => {
+      conversationManager.createConversation('test-1', 'openai');
+
+      const conv = conversationManager.getConversation('test-1')!;
+      // Set updatedAt to 1 hour ago
+      conv.updatedAt = new Date(Date.now() - 60 * 60 * 1000);
+
+      // Clear with 30 minute maxAge (should delete)
+      conversationManager.clearOldConversations(30 * 60 * 1000);
+
+      expect(conversationManager.getConversation('test-1')).toBeUndefined();
+    });
+
+    it('should not delete conversations exactly at maxAge boundary', () => {
+      conversationManager.createConversation('test-1', 'openai');
+
+      const conv = conversationManager.getConversation('test-1')!;
+      // Set to exactly maxAge ago (should NOT be deleted as condition is >)
+      const maxAge = 60 * 60 * 1000;
+      conv.updatedAt = new Date(Date.now() - maxAge);
+
+      conversationManager.clearOldConversations(maxAge);
+
+      // Should still exist (edge case: equal time is not "older than")
+      expect(conversationManager.getConversation('test-1')).toBeDefined();
+    });
+  });
 });