@1mcp/agent 0.4.0 → 0.8.0

package/build/logger/mcpTransport.js

@@ -1,150 +0,0 @@
-import Transport from 'winston-transport';
-// Map Winston log levels to MCP log levels
-const LOG_LEVEL_MAP = {
-    error: 'error',
-    warn: 'warning',
-    info: 'info',
-    verbose: 'debug',
-    debug: 'debug',
-    silly: 'debug',
-};
-/**
- * Winston transport for sending logs to MCP clients
- */
-export class MCPTransport extends Transport {
-    server;
-    loggerName;
-    connected = false;
-    constructor(options) {
-        super(options);
-        this.server = options.server;
-        this.loggerName = options.loggerName || '1mcp';
-        // Set up connection status handlers
-        this.setupConnectionHandlers();
-    }
-    /**
-     * Set up handlers for connection status changes
-     */
-    setupConnectionHandlers() {
-        // Handle connection close
-        this.server.onclose = () => {
-            this.setConnected(false);
-        };
-    }
-    /**
-     * Set the connection status of the transport
-     * @param connected Whether the server is connected
-     */
-    setConnected(connected) {
-        const previousState = this.connected;
-        this.connected = connected;
-        // Log connection state changes
-        if (previousState !== connected) {
-            console.debug(`MCP Transport connection state changed to: ${connected ? 'connected' : 'disconnected'}`);
-        }
-    }
-    /**
-     * Send a log notification to the MCP client
-     * @param info The log info object
-     * @returns true if the notification was sent, false otherwise
-     */
-    sendLogNotification(info) {
-        if (!this.server || !this.connected) {
-            return false;
-        }
-        // Map Winston log level to MCP log level
-        const level = LOG_LEVEL_MAP[info.level] || 'info';
-        const sanitizedData = this.sanitizeData(info);
-        // Extract message and metadata
-        const { message, level: _, ...meta } = sanitizedData;
-        // Create MCP logging notification
-        const notification = {
-            method: 'notifications/message',
-            params: {
-                level,
-                message: typeof message === 'string' ? message : JSON.stringify(message),
-                logger: this.loggerName,
-                data: Object.keys(meta).length > 0 ? meta : undefined,
-            },
-        };
-        // Send notification to MCP clients
-        try {
-            this.server.notification(notification);
-            return true;
-        }
-        catch (error) {
-            console.error('Failed to send log notification to MCP client:', error);
-            return false;
-        }
-    }
-    /**
-     * Sanitize log data to remove sensitive information
-     * @param data The data to sanitize
-     * @returns Sanitized data
-     */
-    sanitizeData(data) {
-        if (typeof data !== 'object' || data === null) {
-            return data;
-        }
-        // List of potentially sensitive field names
-        const sensitiveFields = [
-            'password',
-            'token',
-            'secret',
-            'key',
-            'credential',
-            'auth',
-            'apiKey',
-            'api_key',
-            'accessToken',
-            'access_token',
-            'jwt',
-            'ssn',
-            'creditCard',
-            'credit_card',
-            'cvv',
-            'pin',
-        ];
-        if (Array.isArray(data)) {
-            return data.map((item) => this.sanitizeData(item));
-        }
-        const sanitized = {};
-        for (const [key, value] of Object.entries(data)) {
-            // Check if this is a sensitive field
-            const isSensitive = sensitiveFields.some((field) => key.toLowerCase().includes(field.toLowerCase()));
-            if (isSensitive) {
-                sanitized[key] = '[REDACTED]';
-            }
-            else if (typeof value === 'object' && value !== null) {
-                sanitized[key] = this.sanitizeData(value);
-            }
-            else {
-                sanitized[key] = value;
-            }
-        }
-        return sanitized;
-    }
-    log(info, callback) {
-        setImmediate(() => {
-            this.emit('logged', info);
-        });
-        // Only try to send if connected
-        if (this.connected) {
-            try {
-                this.sendLogNotification(info);
-            }
-            catch (_) {
-                // Ignore any errors during log sending
-            }
-        }
-        // Always call the callback to prevent blocking
-        callback();
-    }
-    /**
-     * Clean up resources when the transport is closed
-     */
-    close() {
-        this.setConnected(false);
-        this.server.onclose = undefined;
-    }
-}

package/build/serverManager.test.js

@@ -1,158 +0,0 @@
-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();
-        });
-    });
-});