fss-link 1.0.40 → 1.0.45

package/dist/ui/commands/mcpCommand.test.ts

@@ -0,0 +1,1057 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { mcpCommand } from './mcpCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import {
+  MCPServerStatus,
+  MCPDiscoveryState,
+  getMCPServerStatus,
+  getMCPDiscoveryState,
+  DiscoveredMCPTool,
+} from 'fss-link-core';
+
+import { MessageActionReturn } from './types.js';
+import { Type, CallableTool } from '@google/genai';
+
+vi.mock('fss-link-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('fss-link-core')>();
+  return {
+    ...actual,
+    getMCPServerStatus: vi.fn(),
+    getMCPDiscoveryState: vi.fn(),
+    MCPOAuthProvider: {
+      authenticate: vi.fn(),
+    },
+    MCPOAuthTokenStorage: {
+      getToken: vi.fn(),
+      isTokenExpired: vi.fn(),
+    },
+  };
+});
+
+// Helper function to check if result is a message action
+const isMessageAction = (result: unknown): result is MessageActionReturn =>
+  result !== null &&
+  typeof result === 'object' &&
+  'type' in result &&
+  result.type === 'message';
+
+// Helper function to create a mock DiscoveredMCPTool
+const createMockMCPTool = (
+  name: string,
+  serverName: string,
+  description?: string,
+) =>
+  new DiscoveredMCPTool(
+    {
+      callTool: vi.fn(),
+      tool: vi.fn(),
+    } as unknown as CallableTool,
+    serverName,
+    name,
+    description || `Description for ${name}`,
+    { type: Type.OBJECT, properties: {} },
+    name, // serverToolName same as name for simplicity
+  );
+
+describe('mcpCommand', () => {
+  let mockContext: ReturnType<typeof createMockCommandContext>;
+  let mockConfig: {
+    getToolRegistry: ReturnType<typeof vi.fn>;
+    getMcpServers: ReturnType<typeof vi.fn>;
+    getBlockedMcpServers: ReturnType<typeof vi.fn>;
+    getPromptRegistry: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Set up default mock environment
+    vi.unstubAllEnvs();
+
+    // Default mock implementations
+    vi.mocked(getMCPServerStatus).mockReturnValue(MCPServerStatus.CONNECTED);
+    vi.mocked(getMCPDiscoveryState).mockReturnValue(
+      MCPDiscoveryState.COMPLETED,
+    );
+
+    // Create mock config with all necessary methods
+    mockConfig = {
+      getToolRegistry: vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      }),
+      getMcpServers: vi.fn().mockReturnValue({}),
+      getBlockedMcpServers: vi.fn().mockReturnValue([]),
+      getPromptRegistry: vi.fn().mockResolvedValue({
+        getAllPrompts: vi.fn().mockReturnValue([]),
+        getPromptsByServer: vi.fn().mockReturnValue([]),
+      }),
+    };
+
+    mockContext = createMockCommandContext({
+      services: {
+        config: mockConfig,
+      },
+    });
+  });
+
+  describe('basic functionality', () => {
+    it('should show an error if config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const result = await mcpCommand.action!(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should show an error if tool registry is not available', async () => {
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue(undefined);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not retrieve tool registry.',
+      });
+    });
+  });
+
+  describe('no MCP servers configured', () => {
+    beforeEach(() => {
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      });
+      mockConfig.getMcpServers = vi.fn().mockReturnValue({});
+    });
+
+    it('should display a message with a URL when no MCP servers are configured', async () => {
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content:
+          'No MCP servers configured. Please view MCP documentation in your browser: https://docs.anthropic.com/en/docs/claude-code/tools/mcp-server/#how-to-set-up-your-mcp-server or use the cli /docs command',
+      });
+    });
+  });
+
+  describe('with configured MCP servers', () => {
+    beforeEach(() => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+        server2: { command: 'cmd2' },
+        server3: { command: 'cmd3' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+    });
+
+    it('should display configured MCP servers with status indicators and their tools', async () => {
+      // Setup getMCPServerStatus mock implementation
+      vi.mocked(getMCPServerStatus).mockImplementation((serverName) => {
+        if (serverName === 'server1') return MCPServerStatus.CONNECTED;
+        if (serverName === 'server2') return MCPServerStatus.CONNECTED;
+        return MCPServerStatus.DISCONNECTED; // server3
+      });
+
+      // Mock tools from each server using actual DiscoveredMCPTool instances
+      const mockServer1Tools = [
+        createMockMCPTool('server1_tool1', 'server1'),
+        createMockMCPTool('server1_tool2', 'server1'),
+      ];
+      const mockServer2Tools = [createMockMCPTool('server2_tool1', 'server2')];
+      const mockServer3Tools = [createMockMCPTool('server3_tool1', 'server3')];
+
+      const allTools = [
+        ...mockServer1Tools,
+        ...mockServer2Tools,
+        ...mockServer3Tools,
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(allTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        // Server 1 - Connected
+        expect(message).toContain(
+          '🟢 \u001b[1mserver1\u001b[0m - Ready (2 tools)',
+        );
+        expect(message).toContain('server1_tool1');
+        expect(message).toContain('server1_tool2');
+
+        // Server 2 - Connected
+        expect(message).toContain(
+          '🟢 \u001b[1mserver2\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain('server2_tool1');
+
+        // Server 3 - Disconnected but with cached tools, so shows as Ready
+        expect(message).toContain(
+          '🟢 \u001b[1mserver3\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain('server3_tool1');
+
+        // Check that helpful tips are displayed when no arguments are provided
+        expect(message).toContain('💡 Tips:');
+        expect(message).toContain('/mcp desc');
+        expect(message).toContain('/mcp schema');
+        expect(message).toContain('/mcp nodesc');
+        expect(message).toContain('Ctrl+T');
+      }
+    });
+
+    it('should display tool descriptions when desc argument is used', async () => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'This is a server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Mock tools with descriptions using actual DiscoveredMCPTool instances
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'This is tool 1 description'),
+        createMockMCPTool('tool2', 'server1', 'This is tool 2 description'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'desc');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that server description is included
+        expect(message).toContain(
+          '\u001b[1mserver1\u001b[0m - Ready (2 tools)',
+        );
+        expect(message).toContain(
+          '\u001b[32mThis is a server description\u001b[0m',
+        );
+
+        // Check that tool descriptions are included
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+        expect(message).toContain(
+          '\u001b[32mThis is tool 1 description\u001b[0m',
+        );
+        expect(message).toContain('\u001b[36mtool2\u001b[0m');
+        expect(message).toContain(
+          '\u001b[32mThis is tool 2 description\u001b[0m',
+        );
+
+        // Check that tips are NOT displayed when arguments are provided
+        expect(message).not.toContain('💡 Tips:');
+      }
+    });
+
+    it('should not display descriptions when nodesc argument is used', async () => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'This is a server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'This is tool 1 description'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'nodesc');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that descriptions are not included
+        expect(message).not.toContain('This is a server description');
+        expect(message).not.toContain('This is tool 1 description');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+
+        // Check that tips are NOT displayed when arguments are provided
+        expect(message).not.toContain('💡 Tips:');
+      }
+    });
+
+    it('should indicate when a server has no tools', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+        server2: { command: 'cmd2' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Setup server statuses
+      vi.mocked(getMCPServerStatus).mockImplementation((serverName) => {
+        if (serverName === 'server1') return MCPServerStatus.CONNECTED;
+        if (serverName === 'server2') return MCPServerStatus.DISCONNECTED;
+        return MCPServerStatus.DISCONNECTED;
+      });
+
+      // Mock tools - only server1 has tools
+      const mockServerTools = [createMockMCPTool('server1_tool1', 'server1')];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain(
+          '🟢 \u001b[1mserver1\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain('\u001b[36mserver1_tool1\u001b[0m');
+        expect(message).toContain(
+          '🔴 \u001b[1mserver2\u001b[0m - Disconnected (0 tools cached)',
+        );
+        expect(message).toContain('No tools or prompts available');
+      }
+    });
+
+    it('should show startup indicator when servers are connecting', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+        server2: { command: 'cmd2' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Setup server statuses with one connecting
+      vi.mocked(getMCPServerStatus).mockImplementation((serverName) => {
+        if (serverName === 'server1') return MCPServerStatus.CONNECTED;
+        if (serverName === 'server2') return MCPServerStatus.CONNECTING;
+        return MCPServerStatus.DISCONNECTED;
+      });
+
+      // Setup discovery state as in progress
+      vi.mocked(getMCPDiscoveryState).mockReturnValue(
+        MCPDiscoveryState.IN_PROGRESS,
+      );
+
+      // Mock tools
+      const mockServerTools = [
+        createMockMCPTool('server1_tool1', 'server1'),
+        createMockMCPTool('server2_tool1', 'server2'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that startup indicator is shown
+        expect(message).toContain(
+          '⏳ MCP servers are starting up (1 initializing)...',
+        );
+        expect(message).toContain(
+          'Note: First startup may take longer. Tool availability will update automatically.',
+        );
+
+        // Check server statuses
+        expect(message).toContain(
+          '🟢 \u001b[1mserver1\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain(
+          '🔄 \u001b[1mserver2\u001b[0m - Starting... (first startup may take longer) (tools and prompts will appear when ready)',
+        );
+      }
+    });
+
+    it('should display the extension name for servers from extensions', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1', extensionName: 'my-extension' },
+      };
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('server1 (from my-extension)');
+      }
+    });
+
+    it('should display blocked MCP servers', async () => {
+      mockConfig.getMcpServers = vi.fn().mockReturnValue({});
+      const blockedServers = [
+        { name: 'blocked-server', extensionName: 'my-extension' },
+      ];
+      mockConfig.getBlockedMcpServers = vi.fn().mockReturnValue(blockedServers);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain(
+          '🔴 \u001b[1mblocked-server (from my-extension)\u001b[0m - Blocked',
+        );
+      }
+    });
+
+    it('should display both active and blocked servers correctly', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1', extensionName: 'my-extension' },
+      };
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+      const blockedServers = [
+        { name: 'blocked-server', extensionName: 'another-extension' },
+      ];
+      mockConfig.getBlockedMcpServers = vi.fn().mockReturnValue(blockedServers);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('server1 (from my-extension)');
+        expect(message).toContain(
+          '🔴 \u001b[1mblocked-server (from another-extension)\u001b[0m - Blocked',
+        );
+      }
+    });
+  });
+
+  describe('schema functionality', () => {
+    it('should display tool schemas when schema argument is used', async () => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'This is a server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Create tools with parameter schemas
+      const mockCallableTool1: CallableTool = {
+        callTool: vi.fn(),
+        tool: vi.fn(),
+      } as unknown as CallableTool;
+      const mockCallableTool2: CallableTool = {
+        callTool: vi.fn(),
+        tool: vi.fn(),
+      } as unknown as CallableTool;
+
+      const tool1 = new DiscoveredMCPTool(
+        mockCallableTool1,
+        'server1',
+        'tool1',
+        'This is tool 1 description',
+        {
+          type: Type.OBJECT,
+          properties: {
+            param1: { type: Type.STRING, description: 'First parameter' },
+          },
+          required: ['param1'],
+        },
+        'tool1',
+      );
+
+      const tool2 = new DiscoveredMCPTool(
+        mockCallableTool2,
+        'server1',
+        'tool2',
+        'This is tool 2 description',
+        {
+          type: Type.OBJECT,
+          properties: {
+            param2: { type: Type.NUMBER, description: 'Second parameter' },
+          },
+          required: ['param2'],
+        },
+        'tool2',
+      );
+
+      const mockServerTools = [tool1, tool2];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'schema');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that server description is included
+        expect(message).toContain('Ready (2 tools)');
+        expect(message).toContain('This is a server description');
+
+        // Check that tool descriptions and schemas are included
+        expect(message).toContain('This is tool 1 description');
+        expect(message).toContain('Parameters:');
+        expect(message).toContain('param1');
+        expect(message).toContain('STRING');
+        expect(message).toContain('This is tool 2 description');
+        expect(message).toContain('param2');
+        expect(message).toContain('NUMBER');
+      }
+    });
+
+    it('should handle tools without parameter schemas gracefully', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Mock tools without parameter schemas
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'Tool without schema'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'schema');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('tool1');
+        expect(message).toContain('Tool without schema');
+        // Should not crash when parameterSchema is undefined
+      }
+    });
+  });
+
+  describe('argument parsing', () => {
+    beforeEach(() => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'Server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'Test tool'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+    });
+
+    it('should handle "descriptions" as alias for "desc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'descriptions');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+      }
+    });
+
+    it('should handle "nodescriptions" as alias for "nodesc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'nodescriptions');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle mixed case arguments', async () => {
+      const result = await mcpCommand.action!(mockContext, 'DESC');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+      }
+    });
+
+    it('should handle multiple arguments - "schema desc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'schema desc');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle multiple arguments - "desc schema"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'desc schema');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle "schema" alone showing descriptions', async () => {
+      const result = await mcpCommand.action!(mockContext, 'schema');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle "nodesc" overriding "schema" - "schema nodesc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'schema nodesc');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).toContain('Parameters:'); // Schema should still show
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle "nodesc" overriding "desc" - "desc nodesc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'desc nodesc');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).not.toContain('Parameters:');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle "nodesc" overriding both "desc" and "schema" - "desc schema nodesc"', async () => {
+      const result = await mcpCommand.action!(
+        mockContext,
+        'desc schema nodesc',
+      );
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).toContain('Parameters:'); // Schema should still show
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle extra whitespace in arguments', async () => {
+      const result = await mcpCommand.action!(mockContext, '  desc   schema  ');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle empty arguments gracefully', async () => {
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).not.toContain('Parameters:');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle unknown arguments gracefully', async () => {
+      const result = await mcpCommand.action!(mockContext, 'unknown arg');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).not.toContain('Parameters:');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty server names gracefully', async () => {
+      const mockMcpServers = {
+        '': { command: 'cmd1' }, // Empty server name
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+    });
+
+    it('should handle servers with special characters in names', async () => {
+      const mockMcpServers = {
+        'server-with-dashes': { command: 'cmd1' },
+        server_with_underscores: { command: 'cmd2' },
+        'server.with.dots': { command: 'cmd3' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('server-with-dashes');
+        expect(message).toContain('server_with_underscores');
+        expect(message).toContain('server.with.dots');
+      }
+    });
+  });
+
+  describe('auth subcommand', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('should list OAuth-enabled servers when no server name is provided', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'oauth-server': { oauth: { enabled: true } },
+              'regular-server': {},
+              'another-oauth': { oauth: { enabled: true } },
+            }),
+          },
+        },
+      });
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      expect(authCommand).toBeDefined();
+
+      const result = await authCommand!.action!(context, '');
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toContain('oauth-server');
+        expect(result.content).toContain('another-oauth');
+        expect(result.content).not.toContain('regular-server');
+        expect(result.content).toContain('/mcp auth <server-name>');
+      }
+    });
+
+    it('should show message when no OAuth servers are configured', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'regular-server': {},
+            }),
+          },
+        },
+      });
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toBe(
+          'No MCP servers configured with OAuth authentication.',
+        );
+      }
+    });
+
+    it('should authenticate with a specific server', async () => {
+      const mockToolRegistry = {
+        discoverToolsForServer: vi.fn(),
+      };
+      const mockGeminiClient = {
+        setTools: vi.fn(),
+      };
+
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'test-server': {
+                url: 'http://localhost:3000',
+                oauth: { enabled: true },
+              },
+            }),
+            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+            getGeminiClient: vi.fn().mockReturnValue(mockGeminiClient),
+            getPromptRegistry: vi.fn().mockResolvedValue({
+              removePromptsByServer: vi.fn(),
+            }),
+          },
+        },
+      });
+      // Mock the reloadCommands function
+      context.ui.reloadCommands = vi.fn();
+
+      const { MCPOAuthProvider } = await import('fss-link-core');
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, 'test-server');
+
+      expect(MCPOAuthProvider.authenticate).toHaveBeenCalledWith(
+        'test-server',
+        { enabled: true },
+        'http://localhost:3000',
+      );
+      expect(mockToolRegistry.discoverToolsForServer).toHaveBeenCalledWith(
+        'test-server',
+      );
+      expect(mockGeminiClient.setTools).toHaveBeenCalled();
+      expect(context.ui.reloadCommands).toHaveBeenCalledTimes(1);
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toContain('Successfully authenticated');
+      }
+    });
+
+    it('should handle authentication errors', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'test-server': { oauth: { enabled: true } },
+            }),
+          },
+        },
+      });
+
+      const { MCPOAuthProvider } = await import('fss-link-core');
+      (
+        MCPOAuthProvider.authenticate as ReturnType<typeof vi.fn>
+      ).mockRejectedValue(new Error('Auth failed'));
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, 'test-server');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('error');
+        expect(result.content).toContain('Failed to authenticate');
+        expect(result.content).toContain('Auth failed');
+      }
+    });
+
+    it('should handle non-existent server', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'existing-server': {},
+            }),
+          },
+        },
+      });
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, 'non-existent');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('error');
+        expect(result.content).toContain("MCP server 'non-existent' not found");
+      }
+    });
+  });
+
+  describe('refresh subcommand', () => {
+    it('should refresh the list of tools and display the status', async () => {
+      const mockToolRegistry = {
+        discoverMcpTools: vi.fn(),
+        restartMcpServers: vi.fn(),
+        getAllTools: vi.fn().mockReturnValue([]),
+      };
+      const mockGeminiClient = {
+        setTools: vi.fn(),
+      };
+
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({ server1: {} }),
+            getBlockedMcpServers: vi.fn().mockReturnValue([]),
+            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+            getGeminiClient: vi.fn().mockReturnValue(mockGeminiClient),
+            getPromptRegistry: vi.fn().mockResolvedValue({
+              getPromptsByServer: vi.fn().mockReturnValue([]),
+            }),
+          },
+        },
+      });
+      // Mock the reloadCommands function, which is new logic.
+      context.ui.reloadCommands = vi.fn();
+
+      const refreshCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'refresh',
+      );
+      expect(refreshCommand).toBeDefined();
+
+      const result = await refreshCommand!.action!(context, '');
+
+      expect(context.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: 'info',
+          text: 'Restarting MCP servers...',
+        },
+        expect.any(Number),
+      );
+      expect(mockToolRegistry.restartMcpServers).toHaveBeenCalled();
+      expect(mockGeminiClient.setTools).toHaveBeenCalled();
+      expect(context.ui.reloadCommands).toHaveBeenCalledTimes(1);
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toContain('Configured MCP servers:');
+      }
+    });
+
+    it('should show an error if config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const refreshCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'refresh',
+      );
+      const result = await refreshCommand!.action!(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should show an error if tool registry is not available', async () => {
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue(undefined);
+
+      const refreshCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'refresh',
+      );
+      const result = await refreshCommand!.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not retrieve tool registry.',
+      });
+    });
+  });
+});