mcp-rubber-duck 1.5.1 → 1.6.0

package/tests/tools/list-ducks.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { listDucksTool } from '../../src/tools/list-ducks.js';
+import { ProviderManager } from '../../src/providers/manager.js';
+import { HealthMonitor } from '../../src/services/health.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/providers/manager.js');
+jest.mock('../../src/services/health.js');
+
+describe('listDucksTool', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+  let mockHealthMonitor: jest.Mocked<HealthMonitor>;
+
+  const mockProviders = [
+    {
+      name: 'openai',
+      info: {
+        nickname: 'OpenAI Duck',
+        model: 'gpt-4',
+        baseURL: 'https://api.openai.com/v1',
+        hasApiKey: true,
+      },
+    },
+    {
+      name: 'groq',
+      info: {
+        nickname: 'Groq Duck',
+        model: 'llama-3.1-70b',
+        baseURL: 'https://api.groq.com/openai/v1',
+        hasApiKey: true,
+      },
+    },
+  ];
+
+  beforeEach(() => {
+    mockProviderManager = {
+      getAllProviders: jest.fn().mockReturnValue(mockProviders),
+    } as unknown as jest.Mocked<ProviderManager>;
+
+    mockHealthMonitor = {
+      performHealthChecks: jest.fn(),
+    } as unknown as jest.Mocked<HealthMonitor>;
+  });
+
+  it('should list all ducks without health check', async () => {
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {});
+
+    expect(mockProviderManager.getAllProviders).toHaveBeenCalled();
+    expect(mockHealthMonitor.performHealthChecks).not.toHaveBeenCalled();
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('Found 2 duck(s)');
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('Groq Duck');
+  });
+
+  it('should list ducks with health check when requested', async () => {
+    mockHealthMonitor.performHealthChecks.mockResolvedValue([
+      {
+        provider: 'openai',
+        healthy: true,
+        latency: 150,
+        lastCheck: new Date(),
+      },
+      {
+        provider: 'groq',
+        healthy: false,
+        lastCheck: new Date(),
+        error: 'Connection failed',
+      },
+    ]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {
+      check_health: true,
+    });
+
+    expect(mockHealthMonitor.performHealthChecks).toHaveBeenCalled();
+    expect(result.content[0].text).toContain('Healthy');
+    expect(result.content[0].text).toContain('Unhealthy');
+    expect(result.content[0].text).toContain('150ms');
+    expect(result.content[0].text).toContain('Connection failed');
+  });
+
+  it('should show unknown status emoji for unchecked providers', async () => {
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {
+      check_health: false,
+    });
+
+    // Without health check, status should be unknown (❓)
+    expect(result.content[0].text).toContain('❓');
+  });
+
+  it('should show healthy count in summary', async () => {
+    mockHealthMonitor.performHealthChecks.mockResolvedValue([
+      {
+        provider: 'openai',
+        healthy: true,
+        latency: 150,
+        lastCheck: new Date(),
+      },
+      {
+        provider: 'groq',
+        healthy: true,
+        latency: 80,
+        lastCheck: new Date(),
+      },
+    ]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {
+      check_health: true,
+    });
+
+    expect(result.content[0].text).toContain('2/2 ducks are healthy');
+  });
+
+  it('should handle empty provider list', async () => {
+    mockProviderManager.getAllProviders.mockReturnValue([]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {});
+
+    expect(result.content[0].text).toContain('Found 0 duck(s)');
+    expect(result.content[0].text).toContain('0/0 ducks are healthy');
+  });
+
+  it('should display provider without API key correctly', async () => {
+    mockProviderManager.getAllProviders.mockReturnValue([
+      {
+        name: 'ollama',
+        info: {
+          nickname: 'Ollama Duck',
+          model: 'llama3',
+          baseURL: 'http://localhost:11434/v1',
+          hasApiKey: false,
+        },
+      },
+    ]);
+
+    const result = await listDucksTool(mockProviderManager, mockHealthMonitor, {});
+
+    expect(result.content[0].text).toContain('Not required');
+  });
+});

package/tests/tools/list-models.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { listModelsTool } from '../../src/tools/list-models.js';
+import { ProviderManager } from '../../src/providers/manager.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/providers/manager.js');
+
+describe('listModelsTool', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+
+  const mockProviders = [
+    {
+      name: 'openai',
+      info: {
+        nickname: 'OpenAI Duck',
+        model: 'gpt-4',
+        baseURL: 'https://api.openai.com/v1',
+        hasApiKey: true,
+      },
+    },
+    {
+      name: 'groq',
+      info: {
+        nickname: 'Groq Duck',
+        model: 'llama-3.1-70b-versatile',
+        baseURL: 'https://api.groq.com/openai/v1',
+        hasApiKey: true,
+      },
+    },
+  ];
+
+  const mockOpenAIModels = [
+    { id: 'gpt-4', description: 'Most capable model', context_window: 8192 },
+    { id: 'gpt-3.5-turbo', owned_by: 'openai', context_window: 4096 },
+  ];
+
+  const mockGroqModels = [
+    { id: 'llama-3.1-70b-versatile', description: 'Versatile large model' },
+    { id: 'llama-3.1-8b-instant', description: 'Fast small model' },
+  ];
+
+  beforeEach(() => {
+    mockProviderManager = {
+      getAllProviders: jest.fn().mockReturnValue(mockProviders),
+      getAvailableModels: jest.fn().mockImplementation((provider) => {
+        if (provider === 'openai') return Promise.resolve(mockOpenAIModels);
+        if (provider === 'groq') return Promise.resolve(mockGroqModels);
+        return Promise.resolve([]);
+      }),
+    } as unknown as jest.Mocked<ProviderManager>;
+  });
+
+  it('should list models for all providers by default', async () => {
+    const result = await listModelsTool(mockProviderManager, {});
+
+    expect(mockProviderManager.getAllProviders).toHaveBeenCalled();
+    expect(mockProviderManager.getAvailableModels).toHaveBeenCalledTimes(2);
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('Groq Duck');
+  });
+
+  it('should list models for specific provider', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      provider: 'openai',
+    });
+
+    expect(mockProviderManager.getAvailableModels).toHaveBeenCalledWith('openai');
+    expect(mockProviderManager.getAvailableModels).toHaveBeenCalledTimes(1);
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).not.toContain('Groq Duck');
+  });
+
+  it('should throw error for unknown provider', async () => {
+    await expect(
+      listModelsTool(mockProviderManager, { provider: 'unknown' })
+    ).rejects.toThrow('Provider "unknown" not found');
+  });
+
+  it('should display model details', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      provider: 'openai',
+    });
+
+    expect(result.content[0].text).toContain('gpt-4');
+    expect(result.content[0].text).toContain('Most capable model');
+    expect(result.content[0].text).toContain('8192 tokens');
+  });
+
+  it('should mark default model', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      provider: 'openai',
+    });
+
+    expect(result.content[0].text).toContain('gpt-4');
+    expect(result.content[0].text).toContain('(default)');
+  });
+
+  it('should display owned_by when no description', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      provider: 'openai',
+    });
+
+    expect(result.content[0].text).toContain('by openai');
+  });
+
+  it('should handle empty models list', async () => {
+    mockProviderManager.getAvailableModels.mockResolvedValue([]);
+
+    const result = await listModelsTool(mockProviderManager, {
+      provider: 'openai',
+    });
+
+    expect(result.content[0].text).toContain('No models available');
+  });
+
+  it('should handle provider errors gracefully', async () => {
+    mockProviderManager.getAvailableModels.mockImplementation((provider) => {
+      if (provider === 'openai') return Promise.resolve(mockOpenAIModels);
+      return Promise.reject(new Error('Connection failed'));
+    });
+
+    const result = await listModelsTool(mockProviderManager, {});
+
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('Failed to fetch models');
+  });
+
+  it('should show cached indicator when not fetching latest', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      fetch_latest: false,
+    });
+
+    expect(result.content[0].text).toContain('Using cached/configured models');
+  });
+
+  it('should show fetch indicator when fetching latest', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      fetch_latest: true,
+    });
+
+    expect(result.content[0].text).toContain('Fetched from API');
+  });
+
+  it('should display context window when available', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      provider: 'openai',
+    });
+
+    expect(result.content[0].text).toContain('8192 tokens');
+    expect(result.content[0].text).toContain('4096 tokens');
+  });
+
+  it('should handle models without context window', async () => {
+    const result = await listModelsTool(mockProviderManager, {
+      provider: 'groq',
+    });
+
+    // Groq models don't have context_window in mock
+    expect(result.content[0].text).toContain('llama-3.1-70b-versatile');
+    expect(result.content[0].text).not.toContain('tokens]');
+  });
+});

package/tests/tools/mcp-status.test.ts

@@ -0,0 +1,330 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { mcpStatusTool } from '../../src/tools/mcp-status.js';
+import { MCPClientManager } from '../../src/services/mcp-client-manager.js';
+import { ApprovalService } from '../../src/services/approval.js';
+import { FunctionBridge } from '../../src/services/function-bridge.js';
+
+// Mock dependencies
+jest.mock('../../src/utils/logger');
+jest.mock('../../src/services/mcp-client-manager.js');
+jest.mock('../../src/services/approval.js');
+jest.mock('../../src/services/function-bridge.js');
+
+describe('mcpStatusTool', () => {
+  let mockMcpManager: jest.Mocked<MCPClientManager>;
+  let mockApprovalService: jest.Mocked<ApprovalService>;
+  let mockFunctionBridge: jest.Mocked<FunctionBridge>;
+
+  const mockServerStatus = {
+    filesystem: {
+      type: 'stdio',
+      status: 'connected',
+    },
+    database: {
+      type: 'sse',
+      status: 'connecting',
+    },
+  };
+
+  const mockTools = [
+    { name: 'read_file', serverName: 'filesystem' },
+    { name: 'write_file', serverName: 'filesystem' },
+    { name: 'query', serverName: 'database' },
+  ];
+
+  const mockApprovalStats = {
+    total: 10,
+    pending: 2,
+    approved: 5,
+    denied: 2,
+    expired: 1,
+  };
+
+  const mockBridgeStats = {
+    trustedToolCount: 5,
+    totalCalls: 100,
+    successfulCalls: 95,
+  };
+
+  beforeEach(() => {
+    mockMcpManager = {
+      getStatus: jest.fn().mockReturnValue(mockServerStatus),
+      getConnectedServers: jest.fn().mockReturnValue(['filesystem', 'database']),
+      listAllTools: jest.fn().mockResolvedValue(mockTools),
+    } as unknown as jest.Mocked<MCPClientManager>;
+
+    mockApprovalService = {
+      getStats: jest.fn().mockReturnValue(mockApprovalStats),
+      getPendingApprovals: jest.fn().mockReturnValue([]),
+    } as unknown as jest.Mocked<ApprovalService>;
+
+    mockFunctionBridge = {
+      getStats: jest.fn().mockReturnValue(mockBridgeStats),
+    } as unknown as jest.Mocked<FunctionBridge>;
+  });
+
+  describe('overview section', () => {
+    it('should display MCP Bridge status header', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('MCP Bridge Status');
+    });
+
+    it('should display connected servers count', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('Connected Servers: 2');
+    });
+
+    it('should display available tools count', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('Available Tools: 3');
+    });
+
+    it('should display trusted tools count', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('Trusted Tools: 5');
+    });
+  });
+
+  describe('server details section', () => {
+    it('should display server status with icons', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('🟢'); // connected
+      expect(result.content[0].text).toContain('🟡'); // connecting
+      expect(result.content[0].text).toContain('filesystem');
+      expect(result.content[0].text).toContain('database');
+    });
+
+    it('should display server type and status', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('stdio');
+      expect(result.content[0].text).toContain('Status: connected');
+      expect(result.content[0].text).toContain('Status: connecting');
+    });
+
+    it('should display tool count per server', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('Tools: 2'); // filesystem
+      expect(result.content[0].text).toContain('Tools: 1'); // database
+    });
+
+    it('should display tool names for small tool lists', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('read_file');
+      expect(result.content[0].text).toContain('write_file');
+    });
+
+    it('should truncate long tool lists with count', async () => {
+      mockMcpManager.listAllTools.mockResolvedValue([
+        { name: 'tool1', serverName: 'server1' },
+        { name: 'tool2', serverName: 'server1' },
+        { name: 'tool3', serverName: 'server1' },
+        { name: 'tool4', serverName: 'server1' },
+        { name: 'tool5', serverName: 'server1' },
+      ]);
+      mockMcpManager.getStatus.mockReturnValue({
+        server1: { type: 'stdio', status: 'connected' },
+      });
+
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('+2 more');
+    });
+
+    it('should handle disconnected server', async () => {
+      mockMcpManager.getStatus.mockReturnValue({
+        broken: { type: 'stdio', status: 'disconnected' },
+      });
+
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('🔴');
+    });
+
+    it('should show message when no servers configured', async () => {
+      mockMcpManager.getStatus.mockReturnValue({});
+      mockMcpManager.listAllTools.mockResolvedValue([]);
+      mockMcpManager.getConnectedServers.mockReturnValue([]);
+
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('No MCP servers configured');
+    });
+  });
+
+  describe('approval statistics section', () => {
+    it('should display all approval statistics', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('Total Requests: 10');
+      expect(result.content[0].text).toContain('Pending: 2');
+      expect(result.content[0].text).toContain('Approved: 5');
+      expect(result.content[0].text).toContain('Denied: 2');
+      expect(result.content[0].text).toContain('Expired: 1');
+    });
+  });
+
+  describe('pending approvals section', () => {
+    it('should display pending approvals when they exist', async () => {
+      const now = Date.now();
+      mockApprovalService.getPendingApprovals.mockReturnValue([
+        {
+          id: 'approval-1',
+          duckName: 'TestDuck',
+          mcpServer: 'filesystem',
+          toolName: 'read_file',
+          arguments: {},
+          status: 'pending' as const,
+          timestamp: now - 30000,
+          expiresAt: now + 30000,
+        },
+      ]);
+
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('Pending Approvals');
+      expect(result.content[0].text).toContain('TestDuck');
+      expect(result.content[0].text).toContain('filesystem:read_file');
+      expect(result.content[0].text).toMatch(/\d+s ago/);
+    });
+
+    it('should not display pending section when no pending approvals', async () => {
+      mockApprovalService.getStats.mockReturnValue({
+        ...mockApprovalStats,
+        pending: 0,
+      });
+
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).not.toContain('Pending Approvals:');
+    });
+  });
+
+  describe('commands section', () => {
+    it('should display available commands', async () => {
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.content[0].text).toContain('Commands');
+      expect(result.content[0].text).toContain('get_pending_approvals');
+      expect(result.content[0].text).toContain('approve_mcp_request');
+      expect(result.content[0].text).toContain('ask_duck');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle exceptions gracefully', async () => {
+      mockMcpManager.getStatus.mockImplementation(() => {
+        throw new Error('Connection failed');
+      });
+
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('Failed to get MCP status');
+      expect(result.content[0].text).toContain('Connection failed');
+    });
+
+    it('should handle non-Error exceptions', async () => {
+      mockMcpManager.getStatus.mockImplementation(() => {
+        throw 'Unknown failure';
+      });
+
+      const result = await mcpStatusTool(
+        mockMcpManager,
+        mockApprovalService,
+        mockFunctionBridge,
+        {}
+      );
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain('Unknown failure');
+    });
+  });
+});