@1mcp/agent 0.2.0 → 0.7.0

package/build/serverManager.test.js

@@ -0,0 +1,158 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ServerManager } from './serverManager.js';
+import logger from './logger/logger.js';
+import configReloadService from './services/configReloadService.js';
+import { setupCapabilities } from './capabilities/capabilityManager.js';
+import { enhanceServerWithLogging } from './middleware/loggingMiddleware.js';
+// Mock dependencies
+jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+    Server: jest.fn(),
+}));
+jest.mock('@modelcontextprotocol/sdk/shared/transport.js', () => ({
+    Transport: jest.fn(),
+}));
+jest.mock('./logger/logger.js', () => {
+    const mockLogger = {
+        info: jest.fn(),
+        error: jest.fn(),
+    };
+    return {
+        __esModule: true,
+        default: mockLogger,
+    };
+});
+jest.mock('./services/configReloadService.js', () => ({
+    __esModule: true,
+    default: {
+        initialize: jest.fn(),
+    },
+}));
+jest.mock('./capabilities/capabilityManager.js', () => ({
+    setupCapabilities: jest.fn(),
+}));
+jest.mock('./middleware/loggingMiddleware.js', () => ({
+    enhanceServerWithLogging: jest.fn(),
+}));
+describe('ServerManager', () => {
+    let mockConfig;
+    let mockCapabilities;
+    let mockClients;
+    let mockTransports;
+    let mockTransport;
+    let mockServer;
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        // Setup test data
+        mockConfig = { name: 'test-server', version: '1.0.0' };
+        mockCapabilities = { capabilities: { test: true } };
+        mockClients = {};
+        mockTransports = {};
+        mockTransport = {
+        // Add any required Transport properties here
+        };
+        mockServer = {
+            connect: jest.fn().mockResolvedValue(undefined),
+            transport: mockTransport,
+        };
+        // Setup mocks
+        Server.mockImplementation(() => mockServer);
+        setupCapabilities.mockResolvedValue(undefined);
+        enhanceServerWithLogging.mockReturnValue(undefined);
+        configReloadService.initialize.mockImplementation(() => undefined);
+    });
+    describe('getInstance', () => {
+        it('should create a singleton instance', () => {
+            const instance1 = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            const instance2 = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            expect(instance1).toBe(instance2);
+        });
+    });
+    describe('connectTransport', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        const tags = ['tag1', 'tag2'];
+        beforeEach(() => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+        });
+        it('should successfully connect a transport', async () => {
+            await serverManager.connectTransport(mockTransport, sessionId, tags);
+            expect(Server).toHaveBeenCalledWith(mockConfig, mockCapabilities);
+            expect(enhanceServerWithLogging).toHaveBeenCalledWith(mockServer);
+            expect(setupCapabilities).toHaveBeenCalled();
+            expect(configReloadService.initialize).toHaveBeenCalled();
+            expect(mockServer.connect).toHaveBeenCalledWith(mockTransport);
+            expect(logger.info).toHaveBeenCalledWith(`Connected transport for session ${sessionId}`);
+        });
+        it('should handle connection errors', async () => {
+            const error = new Error('Connection failed');
+            mockServer.connect.mockRejectedValueOnce(error);
+            await expect(serverManager.connectTransport(mockTransport, sessionId, tags)).rejects.toThrow('Connection failed');
+            expect(logger.error).toHaveBeenCalled();
+        });
+    });
+    describe('disconnectTransport', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        beforeEach(() => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+        });
+        it('should successfully disconnect a transport', async () => {
+            await serverManager.connectTransport(mockTransport, sessionId);
+            jest.clearAllMocks(); // Clear the logs from connectTransport
+            serverManager.disconnectTransport(sessionId);
+            expect(logger.info).toHaveBeenCalledWith(`Disconnected transport for session ${sessionId}`);
+        });
+        it('should handle non-existent session gracefully', () => {
+            serverManager.disconnectTransport('non-existent');
+            expect(logger.info).not.toHaveBeenCalled();
+        });
+    });
+    describe('transport management methods', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        beforeEach(async () => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            await serverManager.connectTransport(mockTransport, sessionId);
+        });
+        it('should get transport by session id', () => {
+            const transport = serverManager.getTransport(sessionId);
+            expect(transport).toBe(mockTransport);
+        });
+        it('should return undefined for non-existent session', () => {
+            const transport = serverManager.getTransport('non-existent');
+            expect(transport).toBeUndefined();
+        });
+        it('should get all transports', () => {
+            const transports = serverManager.getTransports();
+            expect(transports.size).toBe(1);
+            expect(transports.get(sessionId)).toBe(mockTransport);
+        });
+        it('should get client transports', () => {
+            const clientTransports = serverManager.getClientTransports();
+            expect(clientTransports).toEqual(mockTransports);
+        });
+        it('should get active transports count', () => {
+            expect(serverManager.getActiveTransportsCount()).toBe(1);
+        });
+    });
+    describe('getServer', () => {
+        let serverManager;
+        const sessionId = 'test-session';
+        const tags = ['tag1', 'tag2'];
+        beforeEach(async () => {
+            serverManager = ServerManager.getInstance(mockConfig, mockCapabilities, mockClients, mockTransports);
+            await serverManager.connectTransport(mockTransport, sessionId, tags);
+        });
+        it('should return server info for existing session', () => {
+            const serverInfo = serverManager.getServer(sessionId);
+            expect(serverInfo).toBeDefined();
+            expect(serverInfo?.server).toBe(mockServer);
+            expect(serverInfo?.tags).toEqual(tags);
+        });
+        it('should return undefined for non-existent session', () => {
+            const serverInfo = serverManager.getServer('non-existent');
+            expect(serverInfo).toBeUndefined();
+        });
+    });
+});

package/build/services/configReloadService.js

@@ -1,14 +1,14 @@
 import logger from '../logger/logger.js';
-import configManager, { ConfigChangeEvent } from '../config/configManager.js';
-import { createTransports } from '../config/transportConfig.js';
+import { ConfigChangeEvent, ConfigManager } from '../config/configManager.js';
 import { createClients } from '../clients/clientManager.js';
 import { setupCapabilities } from '../capabilities/capabilityManager.js';
+import { createTransports } from '../config/transportConfig.js';
 /**
  * Service to handle dynamic configuration reloading
  */
 export class ConfigReloadService {
     static instance;
-    server = null;
+    serverInfo = null;
     currentTransports = {};
     isReloading = false;
     /**
@@ -27,12 +27,13 @@ export class ConfigReloadService {
     }
     /**
      * Initialize the service with the server instance
-     * @param server The MCP server instance
+     * @param serverInfo The MCP server instance
      * @param initialTransports The initial transports
      */
-    initialize(server, initialTransports) {
-        this.server = server;
+    initialize(serverInfo, initialTransports) {
+        this.serverInfo = serverInfo;
         this.currentTransports = initialTransports;
+        const configManager = ConfigManager.getInstance();
         // Set up configuration change listener
         configManager.on(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, this.handleConfigChange.bind(this));
         // Start watching for configuration changes
@@ -44,7 +45,7 @@ export class ConfigReloadService {
      * @param newConfig The new transport configuration
      */
     async handleConfigChange(newConfig) {
-        if (!this.server || this.isReloading) {
+        if (!this.serverInfo || this.isReloading) {
             return;
         }
         this.isReloading = true;
@@ -67,7 +68,7 @@ export class ConfigReloadService {
             // Create clients for the new transports
             const newClients = await createClients(newTransports);
             // Register new capabilities with the server
-            await setupCapabilities(newClients, this.server);
+            await setupCapabilities(newClients, this.serverInfo);
             // Update current transports
             this.currentTransports = newTransports;
             logger.info('Configuration reload completed successfully');
@@ -83,6 +84,7 @@ export class ConfigReloadService {
      * Stop the service and clean up resources
      */
     stop() {
+        const configManager = ConfigManager.getInstance();
         configManager.stopWatching();
         configManager.removeAllListeners(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED);
         logger.info('Config reload service stopped');

package/build/test-utils/fixtures/commonFixtures.js

@@ -0,0 +1,44 @@
+import { createMockTransport } from '../mocks/commonMocks.js';
+// Common test clients fixture
+export const createTestClients = () => ({
+    client1: {
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+        transport: createMockTransport(),
+    },
+    client2: {
+        capabilities: {
+            resources: {},
+        },
+        transport: createMockTransport(),
+    },
+    client3: {
+        capabilities: {
+            tools: {},
+        },
+        transport: createMockTransport(),
+    },
+    clientNoCapabilities: {
+        transport: createMockTransport(),
+    },
+    clientNoTags: {
+        capabilities: {
+            resources: {},
+        },
+        transport: createMockTransport(),
+    },
+});
+// Common test config fixture
+export const testConfig = {
+    mcpServers: {
+        test: { url: 'test-url' },
+    },
+};
+// Common test capabilities fixture
+export const testCapabilities = {
+    resources: {},
+    tools: {},
+    test: true,
+};

package/build/test-utils/helpers/testHelpers.js

@@ -0,0 +1,23 @@
+// Helper to clear all mocks in a test
+export const clearAllMocks = () => {
+    jest.clearAllMocks();
+    jest.useRealTimers();
+};
+// Helper to setup fake timers
+export const setupFakeTimers = () => {
+    jest.useFakeTimers();
+};
+// Helper to advance timers by time
+export const advanceTimersByTime = async (ms) => {
+    await jest.advanceTimersByTimeAsync(ms);
+};
+// Helper to run all timers
+export const runAllTimers = async () => {
+    await jest.runAllTimersAsync();
+};
+// Helper to create a mock event emitter spy
+export const createEventEmitterSpy = (instance) => {
+    return jest.spyOn(instance, 'emit');
+};
+// Helper to wait for next tick
+export const waitForNextTick = () => new Promise((resolve) => process.nextTick(resolve));

package/build/test-utils/mocks/commonMocks.js

@@ -0,0 +1,65 @@
+// Mock Logger
+export const mockLogger = {
+    info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn(),
+    level: 'info',
+    transports: [],
+};
+// Mock Transport
+export const createMockTransport = () => ({
+    start: jest.fn(),
+    send: jest.fn(),
+    close: jest.fn(),
+});
+// Mock Server
+export const createMockServer = (overrides = {}) => ({
+    connect: jest.fn().mockResolvedValue(undefined),
+    transport: createMockTransport(),
+    ...overrides,
+});
+// Mock Client
+export const createMockClient = (overrides = {}) => ({
+    connect: jest.fn(),
+    getServerVersion: jest.fn(),
+    ...overrides,
+});
+// Mock File System
+export const createMockFs = () => ({
+    existsSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    writeFileSync: jest.fn(),
+    readFileSync: jest.fn(),
+    watch: jest.fn(() => ({ close: jest.fn() })),
+});
+// Mock Config
+export const createMockConfig = (overrides = {}) => ({
+    name: 'test-server',
+    version: '1.0.0',
+    ...overrides,
+});
+// Mock Capabilities
+export const createMockCapabilities = (overrides = {}) => ({
+    capabilities: {
+        resources: {},
+        tools: {},
+        ...overrides,
+    },
+});
+// Jest module mocks setup helper
+export const setupCommonJestMocks = () => {
+    jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+        Server: jest.fn(),
+    }));
+    jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
+        Client: jest.fn(),
+    }));
+    jest.mock('@modelcontextprotocol/sdk/shared/transport.js', () => ({
+        Transport: jest.fn(),
+    }));
+    jest.mock('../../logger/logger.js', () => ({
+        __esModule: true,
+        default: mockLogger,
+    }));
+};

package/build/types.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+/**
+ * Zod schema for transport configuration
+ */
+export const transportConfigSchema = z.object({
+    type: z.enum(['stdio', 'sse', 'http']).optional(),
+    disabled: z.boolean().optional(),
+    timeout: z.number().optional(),
+    tags: z.array(z.string()).optional(),
+    // HTTP/SSE Parameters
+    url: z.string().url().optional(),
+    headers: z.record(z.string()).optional(),
+    // StdioServerParameters fields
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    stderr: z.union([z.string(), z.number()]).optional(),
+    cwd: z.string().optional(),
+    env: z.record(z.string()).optional(),
+});
+/**
+ * Enum representing possible client connection states
+ */
+export var ClientStatus;
+(function (ClientStatus) {
+    /** Client is successfully connected */
+    ClientStatus["Connected"] = "connected";
+    /** Client is disconnected */
+    ClientStatus["Disconnected"] = "disconnected";
+    /** Client encountered an error */
+    ClientStatus["Error"] = "error";
+})(ClientStatus || (ClientStatus = {}));

package/build/utils/clientFiltering.js

@@ -0,0 +1,101 @@
+import logger from '../logger/logger.js';
+/**
+ * Filters clients by tags
+ * @param clients Record of client instances
+ * @param tags Array of tags to filter by
+ * @returns Filtered record of client instances
+ */
+export function filterClientsByTags(clients, tags) {
+    if (!tags || tags.length === 0) {
+        return clients;
+    }
+    const filteredClients = {};
+    let matchedClients = 0;
+    for (const [name, clientInfo] of Object.entries(clients)) {
+        const clientTags = clientInfo.transport.tags || [];
+        const hasMatchingTags = tags.every((tag) => clientTags.includes(tag));
+        if (hasMatchingTags) {
+            filteredClients[name] = clientInfo;
+            matchedClients++;
+        }
+    }
+    if (matchedClients === 0) {
+        logger.warn(`No clients found matching tags: ${tags.join(', ')}`);
+    }
+    else {
+        logger.debug(`Found ${matchedClients} clients matching tags: ${tags.join(', ')}`);
+    }
+    return Object.freeze(filteredClients);
+}
+/**
+ * Filters clients by capabilities
+ * @param clients Record of client instances
+ * @param capabilities Object containing capabilities to filter by
+ * @returns Filtered record of client instances
+ */
+export function filterClientsByCapabilities(clients, capabilities) {
+    const filteredClients = {};
+    let matchedClients = 0;
+    for (const [name, clientInfo] of Object.entries(clients)) {
+        const clientCapabilities = clientInfo.capabilities || {};
+        const hasMatchingCapabilities = Object.keys(capabilities).every((capability) => {
+            const clientCapability = clientCapabilities[capability];
+            return clientCapability !== undefined;
+        });
+        if (hasMatchingCapabilities) {
+            filteredClients[name] = clientInfo;
+            matchedClients++;
+        }
+    }
+    if (matchedClients === 0) {
+        logger.warn(`No clients found matching capabilities: ${JSON.stringify(capabilities)}`);
+    }
+    else {
+        logger.debug(`Found ${matchedClients} clients matching capabilities: ${JSON.stringify(capabilities)}`);
+    }
+    return Object.freeze(filteredClients);
+}
+/**
+ * Filters clients by multiple criteria
+ * @param filters Array of client filters
+ * @returns Filtered record of client instances
+ */
+export function filterClients(...filters) {
+    return (clients) => {
+        return filters.reduce((filteredClients, filter) => filter(filteredClients), clients);
+    };
+}
+/**
+ * Filters clients by capabilities
+ * @param requiredCapabilities Object containing capabilities to filter by
+ * @returns Filtered record of client instances
+ */
+export function byCapabilities(requiredCapabilities) {
+    return (clients) => {
+        return Object.entries(clients).reduce((filtered, [name, clientInfo]) => {
+            const hasCapabilities = Object.keys(requiredCapabilities).every((cap) => clientInfo.capabilities && cap in clientInfo.capabilities);
+            if (hasCapabilities) {
+                filtered[name] = clientInfo;
+            }
+            return filtered;
+        }, {});
+    };
+}
+/**
+ * Filters clients by tags
+ * @param tags Array of tags to filter by
+ * @returns Filtered record of client instances
+ */
+export function byTags(tags) {
+    return (clients) => {
+        if (!tags || tags.length === 0)
+            return clients;
+        return Object.entries(clients).reduce((filtered, [name, clientInfo]) => {
+            const hasMatchingTags = tags.every((tag) => clientInfo.transport.tags?.includes(tag));
+            if (hasMatchingTags) {
+                filtered[name] = clientInfo;
+            }
+            return filtered;
+        }, {});
+    };
+}

package/build/utils/clientFiltering.test.js

@@ -0,0 +1,124 @@
+import { filterClients, byCapabilities, byTags, filterClientsByCapabilities, filterClientsByTags, } from './clientFiltering.js';
+describe('Client Filtering Utils', () => {
+    const mockClients = {
+        client1: {
+            capabilities: {
+                resources: {},
+                tools: {},
+            },
+            transport: {
+                tags: ['tag1', 'tag2'],
+            },
+        },
+        client2: {
+            capabilities: {
+                resources: {},
+            },
+            transport: {
+                tags: ['tag1'],
+            },
+        },
+        client3: {
+            capabilities: {
+                tools: {},
+            },
+            transport: {
+                tags: ['tag3'],
+            },
+        },
+        clientNoCapabilities: {
+            transport: {
+                tags: ['tag1'],
+            },
+        },
+        clientNoTags: {
+            capabilities: {
+                resources: {},
+            },
+            transport: {},
+        },
+    };
+    describe('filterClientsByCapabilities', () => {
+        it('should filter clients by single capability', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { resources: {} });
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoTags']);
+        });
+        it('should filter clients by multiple capabilities', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { resources: {}, tools: {} });
+            expect(Object.keys(filtered)).toEqual(['client1']);
+        });
+        it('should handle clients with no capabilities', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { resources: {} });
+            expect(filtered).not.toHaveProperty('clientNoCapabilities');
+        });
+        it('should return empty object when no matches found', () => {
+            const filtered = filterClientsByCapabilities(mockClients, { nonexistent: {} });
+            expect(Object.keys(filtered)).toHaveLength(0);
+        });
+    });
+    describe('filterClientsByTags', () => {
+        it('should return all clients when no tags provided', () => {
+            const filtered = filterClientsByTags(mockClients, undefined);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+        it('should filter clients by single tag', () => {
+            const filtered = filterClientsByTags(mockClients, ['tag1']);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoCapabilities']);
+        });
+        it('should filter clients by multiple tags', () => {
+            const filtered = filterClientsByTags(mockClients, ['tag1', 'tag2']);
+            expect(Object.keys(filtered)).toEqual(['client1']);
+        });
+        it('should handle clients with no tags', () => {
+            const filtered = filterClientsByTags(mockClients, ['tag1']);
+            expect(filtered).not.toHaveProperty('clientNoTags');
+        });
+        it('should return empty object when no matches found', () => {
+            const filtered = filterClientsByTags(mockClients, ['nonexistent']);
+            expect(Object.keys(filtered)).toHaveLength(0);
+        });
+    });
+    describe('filterClients (composed filters)', () => {
+        it('should chain multiple filters together', () => {
+            const filtered = filterClients(byCapabilities({ resources: {} }), byTags(['tag1']))(mockClients);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2']);
+        });
+        it('should handle empty filters array', () => {
+            const filtered = filterClients()(mockClients);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+        it('should handle no matching results', () => {
+            const filtered = filterClients(byCapabilities({ resources: {} }), byTags(['tag3']))(mockClients);
+            expect(Object.keys(filtered)).toHaveLength(0);
+        });
+    });
+    describe('byCapabilities', () => {
+        it('should create a filter function for capabilities', () => {
+            const filter = byCapabilities({ resources: {} });
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoTags']);
+        });
+        it('should handle undefined capabilities safely', () => {
+            const filter = byCapabilities({ resources: {} });
+            const filtered = filter({ ...mockClients, unsafeClient: { transport: {} } });
+            expect(filtered).not.toHaveProperty('unsafeClient');
+        });
+    });
+    describe('byTags', () => {
+        it('should create a filter function for tags', () => {
+            const filter = byTags(['tag1']);
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(['client1', 'client2', 'clientNoCapabilities']);
+        });
+        it('should handle undefined tags array', () => {
+            const filter = byTags(undefined);
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+        it('should handle empty tags array', () => {
+            const filter = byTags([]);
+            const filtered = filter(mockClients);
+            expect(Object.keys(filtered)).toEqual(Object.keys(mockClients));
+        });
+    });
+});