@mseep/claudian 2.0.25

package/tests/unit/core/mcp/McpTester.test.ts

@@ -0,0 +1,282 @@
+import { testMcpServer } from '@/core/mcp/McpTester';
+import type { ManagedMcpServer } from '@/core/types';
+
+// Mock the MCP SDK transports and client
+jest.mock('@modelcontextprotocol/sdk/client', () => ({
+  Client: jest.fn().mockImplementation(() => ({
+    connect: jest.fn(),
+    getServerVersion: jest.fn().mockReturnValue({ name: 'test-server', version: '1.0.0' }),
+    listTools: jest.fn().mockResolvedValue({
+      tools: [
+        { name: 'tool1', description: 'A test tool', inputSchema: { type: 'object' } },
+        { name: 'tool2' },
+      ],
+    }),
+    close: jest.fn(),
+  })),
+}));
+
+jest.mock('@modelcontextprotocol/sdk/client/sse', () => ({
+  SSEClientTransport: jest.fn(),
+}));
+
+jest.mock('@modelcontextprotocol/sdk/client/stdio', () => ({
+  StdioClientTransport: jest.fn(),
+}));
+
+jest.mock('@modelcontextprotocol/sdk/client/streamableHttp', () => ({
+  StreamableHTTPClientTransport: jest.fn(),
+}));
+
+jest.mock('@/utils/env', () => ({
+  getEnhancedPath: jest.fn((p?: string) => p || '/usr/bin'),
+}));
+
+jest.mock('@/utils/mcp', () => ({
+  parseCommand: jest.fn((cmd: string, args?: string[]) => {
+    if (args && args.length > 0) return { cmd, args };
+    const parts = cmd.split(' ');
+    return { cmd: parts[0] || '', args: parts.slice(1) };
+  }),
+}));
+
+describe('testMcpServer', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('stdio server', () => {
+    it('should connect and return tools for a valid stdio server', async () => {
+      const server: ManagedMcpServer = {
+        name: 'test',
+        config: { command: 'node server.js', args: ['--port', '3000'] },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(true);
+      expect(result.serverName).toBe('test-server');
+      expect(result.serverVersion).toBe('1.0.0');
+      expect(result.tools).toHaveLength(2);
+      expect(result.tools[0].name).toBe('tool1');
+      expect(result.tools[0].description).toBe('A test tool');
+      expect(result.tools[1].name).toBe('tool2');
+    });
+
+    it('should return error for missing command', async () => {
+      const { parseCommand } = jest.requireMock('@/utils/mcp');
+      parseCommand.mockReturnValueOnce({ cmd: '', args: [] });
+
+      const server: ManagedMcpServer = {
+        name: 'empty',
+        config: { command: '' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Missing command');
+      expect(result.tools).toEqual([]);
+    });
+  });
+
+  describe('sse server', () => {
+    it('should connect to an SSE server', async () => {
+      const { SSEClientTransport } = jest.requireMock('@modelcontextprotocol/sdk/client/sse');
+      const server: ManagedMcpServer = {
+        name: 'sse-test',
+        config: { type: 'sse' as const, url: 'https://example.com/sse' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(true);
+      expect(result.tools).toHaveLength(2);
+      expect(SSEClientTransport).toHaveBeenCalledWith(
+        expect.any(URL),
+        expect.objectContaining({
+          fetch: expect.any(Function),
+        }),
+      );
+    });
+  });
+
+  describe('http server', () => {
+    it('should connect to an HTTP server', async () => {
+      const { StreamableHTTPClientTransport } = jest.requireMock('@modelcontextprotocol/sdk/client/streamableHttp');
+      const server: ManagedMcpServer = {
+        name: 'http-test',
+        config: { type: 'http' as const, url: 'https://example.com/api' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(true);
+      expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(
+        expect.any(URL),
+        expect.objectContaining({
+          fetch: expect.any(Function),
+        }),
+      );
+    });
+
+    it('should pass headers when configured', async () => {
+      const { StreamableHTTPClientTransport } = jest.requireMock('@modelcontextprotocol/sdk/client/streamableHttp');
+      const server: ManagedMcpServer = {
+        name: 'http-auth',
+        config: {
+          type: 'http' as const,
+          url: 'https://example.com/api',
+          headers: { Authorization: 'Bearer token' },
+        },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(true);
+      expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(
+        expect.any(URL),
+        expect.objectContaining({
+          fetch: expect.any(Function),
+          requestInit: { headers: { Authorization: 'Bearer token' } },
+        }),
+      );
+    });
+  });
+
+  describe('error handling', () => {
+    it('should return error when transport creation fails', async () => {
+      const { SSEClientTransport } = jest.requireMock('@modelcontextprotocol/sdk/client/sse');
+      SSEClientTransport.mockImplementationOnce(() => {
+        throw new Error('Transport init failed');
+      });
+
+      const server: ManagedMcpServer = {
+        name: 'bad-sse',
+        config: { type: 'sse' as const, url: 'https://example.com/sse' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Transport init failed');
+      expect(result.tools).toEqual([]);
+    });
+
+    it('should return generic error for non-Error transport failures', async () => {
+      const { StreamableHTTPClientTransport } = jest.requireMock('@modelcontextprotocol/sdk/client/streamableHttp');
+      StreamableHTTPClientTransport.mockImplementationOnce(() => {
+        throw 'string error';
+      });
+
+      const server: ManagedMcpServer = {
+        name: 'bad-http',
+        config: { type: 'http' as const, url: 'https://example.com' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Invalid server configuration');
+    });
+
+    it('should return error when connection fails', async () => {
+      const { Client } = jest.requireMock('@modelcontextprotocol/sdk/client');
+      Client.mockImplementationOnce(() => ({
+        connect: jest.fn().mockRejectedValue(new Error('Connection refused')),
+        close: jest.fn(),
+      }));
+
+      const server: ManagedMcpServer = {
+        name: 'refused',
+        config: { command: 'node server.js' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Connection refused');
+    });
+
+    it('should return unknown error for non-Error connection failures', async () => {
+      const { Client } = jest.requireMock('@modelcontextprotocol/sdk/client');
+      Client.mockImplementationOnce(() => ({
+        connect: jest.fn().mockRejectedValue(42),
+        close: jest.fn(),
+      }));
+
+      const server: ManagedMcpServer = {
+        name: 'weird-error',
+        config: { command: 'node server.js' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Unknown error');
+    });
+
+    it('should handle listTools failure gracefully (partial success)', async () => {
+      const { Client } = jest.requireMock('@modelcontextprotocol/sdk/client');
+      Client.mockImplementationOnce(() => ({
+        connect: jest.fn(),
+        getServerVersion: jest.fn().mockReturnValue({ name: 'partial', version: '0.1' }),
+        listTools: jest.fn().mockRejectedValue(new Error('listTools not supported')),
+        close: jest.fn(),
+      }));
+
+      const server: ManagedMcpServer = {
+        name: 'partial',
+        config: { command: 'node server.js' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(true);
+      expect(result.serverName).toBe('partial');
+      expect(result.tools).toEqual([]);
+    });
+
+    it('should handle close errors silently', async () => {
+      const { Client } = jest.requireMock('@modelcontextprotocol/sdk/client');
+      Client.mockImplementationOnce(() => ({
+        connect: jest.fn(),
+        getServerVersion: jest.fn().mockReturnValue(null),
+        listTools: jest.fn().mockResolvedValue({ tools: [] }),
+        close: jest.fn().mockRejectedValue(new Error('close failed')),
+      }));
+
+      const server: ManagedMcpServer = {
+        name: 'close-fail',
+        config: { command: 'node server.js' },
+        enabled: true,
+        contextSaving: false,
+      };
+
+      const result = await testMcpServer(server);
+
+      expect(result.success).toBe(true);
+      expect(result.serverName).toBeUndefined();
+    });
+  });
+});

package/tests/unit/core/mcp/createNodeFetch.test.ts

@@ -0,0 +1,188 @@
+import * as http from 'http';
+import type { AddressInfo } from 'net';
+
+import { createNodeFetch } from '@/core/mcp/McpTester';
+
+interface ReceivedRequest {
+  method: string;
+  url: string;
+  headers: http.IncomingHttpHeaders;
+  body: string;
+}
+
+function createTestServer(handler?: (req: ReceivedRequest, res: http.ServerResponse) => void): {
+  server: http.Server;
+  getUrl: () => string;
+  received: ReceivedRequest[];
+} {
+  const received: ReceivedRequest[] = [];
+
+  const server = http.createServer((req, res) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (chunk: Buffer) => chunks.push(chunk));
+    req.on('end', () => {
+      const entry: ReceivedRequest = {
+        method: req.method ?? 'GET',
+        url: req.url ?? '/',
+        headers: req.headers,
+        body: Buffer.concat(chunks).toString('utf-8'),
+      };
+      received.push(entry);
+
+      if (handler) {
+        handler(entry, res);
+      } else {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+      }
+    });
+  });
+
+  server.listen(0);
+
+  return {
+    server,
+    getUrl: () => {
+      const addr = server.address() as AddressInfo;
+      return `http://127.0.0.1:${addr.port}`;
+    },
+    received,
+  };
+}
+
+describe('createNodeFetch', () => {
+  let server: http.Server;
+  let getUrl: () => string;
+  let received: ReceivedRequest[];
+  let nodeFetch: ReturnType<typeof createNodeFetch>;
+  const serversToClose: http.Server[] = [];
+
+  beforeAll(() => {
+    ({ server, getUrl, received } = createTestServer());
+    nodeFetch = createNodeFetch();
+  });
+
+  afterAll(() => new Promise<void>((resolve) => {
+    server.close(() => resolve());
+  }));
+
+  afterEach(async () => {
+    received.length = 0;
+    await Promise.all(
+      serversToClose.map((s) => new Promise<void>((resolve) => s.close(() => resolve()))),
+    );
+    serversToClose.length = 0;
+  });
+
+  it('should set Content-Length header for POST with body', async () => {
+    const body = JSON.stringify({ jsonrpc: '2.0', method: 'initialize', id: 1 });
+
+    const response = await nodeFetch(getUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+    });
+
+    expect(response.ok).toBe(true);
+    expect(received).toHaveLength(1);
+    expect(received[0].headers['content-length']).toBe(String(Buffer.byteLength(body)));
+    expect(received[0].headers['transfer-encoding']).toBeUndefined();
+  });
+
+  it('should deliver valid JSON body without chunk framing', async () => {
+    const payload = { jsonrpc: '2.0', method: 'tools/list', id: 2 };
+    const body = JSON.stringify(payload);
+
+    await nodeFetch(getUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+    });
+
+    expect(received).toHaveLength(1);
+    const parsed = JSON.parse(received[0].body);
+    expect(parsed).toEqual(payload);
+  });
+
+  it('should not set Content-Length for GET requests without body', async () => {
+    await nodeFetch(getUrl(), { method: 'GET' });
+
+    expect(received).toHaveLength(1);
+    expect(received[0].headers['content-length']).toBeUndefined();
+    expect(received[0].method).toBe('GET');
+  });
+
+  it('should forward custom headers', async () => {
+    await nodeFetch(getUrl(), {
+      method: 'GET',
+      headers: { 'X-Custom': 'test-value', Authorization: 'Bearer token123' },
+    });
+
+    expect(received).toHaveLength(1);
+    expect(received[0].headers['x-custom']).toBe('test-value');
+    expect(received[0].headers['authorization']).toBe('Bearer token123');
+  });
+
+  it('should return response status and body', async () => {
+    const response = await nodeFetch(getUrl(), { method: 'GET' });
+
+    expect(response.status).toBe(200);
+    expect(response.ok).toBe(true);
+
+    const data = await response.json() as { ok: boolean };
+    expect(data).toEqual({ ok: true });
+  });
+
+  it('should handle non-200 responses', async () => {
+    const { server: errorServer, getUrl: errorUrl, received: errorReceived } = createTestServer(
+      (_req, res) => {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'not found' }));
+      },
+    );
+    serversToClose.push(errorServer);
+
+    const response = await nodeFetch(errorUrl(), { method: 'GET' });
+
+    expect(response.status).toBe(404);
+    expect(response.ok).toBe(false);
+    expect(errorReceived).toHaveLength(1);
+
+    const data = await response.json() as { error: string };
+    expect(data).toEqual({ error: 'not found' });
+  });
+
+  it('should support abort signal', async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      nodeFetch(getUrl(), { method: 'GET', signal: controller.signal }),
+    ).rejects.toThrow();
+  });
+
+  it('should accept URL object as input', async () => {
+    const url = new URL(getUrl());
+
+    const response = await nodeFetch(url, { method: 'GET' });
+
+    expect(response.ok).toBe(true);
+    expect(received).toHaveLength(1);
+  });
+
+  it('should handle multi-byte characters in body with correct Content-Length', async () => {
+    const body = JSON.stringify({ text: '你好世界' });
+
+    await nodeFetch(getUrl(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body,
+    });
+
+    expect(received).toHaveLength(1);
+    // Content-Length should be byte length, not character length
+    expect(received[0].headers['content-length']).toBe(String(Buffer.byteLength(body)));
+    const parsed = JSON.parse(received[0].body) as { text: string };
+    expect(parsed.text).toBe('你好世界');
+  });
+});