@1mcp/agent 0.2.0 → 0.7.0

package/README.md

@@ -28,7 +28,7 @@ npx -y @1mcp/agent --config ~/Library/Application\ Support/Claude/claude_desktop
     "mcpServers": {
         "1mcp": {
             "type": "http",
-            "url": "http://localhost:3050"
+            "url": "http://localhost:3050/sse"
         }
     }
 }
@@ -41,24 +41,81 @@ npx -y @1mcp/agent --config ~/Library/Application\ Support/Claude/claude_desktop
 You can run the server directly using `npx`:
 
 ```bash
-# Run with HTTP/SSE transport (default)
+# Basic usage (starts server with SSE transport)
 npx -y @1mcp/agent
 
-# Run with stdio transport
-npx -y @1mcp/agent --transport stdio
+# Use existing Claude Desktop config
+npx -y @1mcp/agent --config ~/Library/Application\ Support/Claude/claude_desktop_config.json
 
-# Run with AI assistant config file
-npx -y @1mcp/agent --config /path/to/ai/assistant/config.json
+# Use stdio transport instead of SSE
+npx -y @1mcp/agent --transport stdio
 
-# Show help
+# Show all available options
 npx -y @1mcp/agent --help
 ```
 
 Available options:
-- `--transport, -t`: Transport type to use (choices: "stdio", "sse", default: "sse")
-- `--config, -c`: Path to the configuration file
+- `--transport, -t`: Choose transport type ("stdio" or "sse", default: "sse")
+- `--config, -c`: Use a specific config file
+- `--port, -P`: Change SSE port (default: 3050)
+- `--host, -H`: Change SSE host (default: localhost)
+- `--tags, -g`: Filter servers by tags (see Tags section below)
 - `--help, -h`: Show help
 
+### Understanding Tags
+
+Tags help you control which MCP servers are available to different clients. Think of tags as labels that describe what each server can do.
+
+#### How to Use Tags
+
+1. **In your server config**: Add tags to each server to describe its capabilities
+```json
+{
+  "mcpServers": {
+    "web-server": {
+      "command": "uvx",
+      "args": ["mcp-server-fetch"],
+      "tags": ["network", "web"],
+      "disabled": false
+    },
+    "file-server": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "~/Downloads"],
+      "tags": ["filesystem"],
+      "disabled": false
+    }
+  }
+}
+```
+
+2. **When starting 1MCP in stdio mode**: You can filter servers by tags
+```bash
+# Only start servers with the "network" tag
+npx -y @1mcp/agent --transport stdio --tags "network"
+
+# Start servers with either "network" or "filesystem" tags
+npx -y @1mcp/agent --transport stdio --tags "network,filesystem"
+```
+
+3. **When using SSE transport**: Clients can request servers with specific tags
+```json
+{
+    "mcpServers": {
+        "1mcp": {
+            "type": "http",
+            "url": "http://localhost:3050/sse?tags=network"  // Only connect to network-capable servers
+        }
+    }
+}
+```
+
+Example tags:
+- `network`: For servers that make web requests
+- `filesystem`: For servers that handle file operations
+- `memory`: For servers that provide memory/storage
+- `shell`: For servers that run shell commands
+- `db`: For servers that handle database operations
+
 ## Configuration
 
 ### Global Configuration
@@ -172,10 +229,10 @@ pnpm dev
 
 ### Debugging
 
-Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector), which is available as a package script:
+Using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector), which is available as a package script:
 
 ```bash
-pnpm run inspector
+pnpm inspector
 ```
 
 The Inspector will provide a URL to access debugging tools in your browser.

package/build/capabilities/capabilityManager.js

@@ -5,16 +5,17 @@ import { registerRequestHandlers } from '../handlers/requestHandlers.js';
  * Collects capabilities from all clients and registers them with the server
  * @param clients Record of client instances
  * @param server The MCP server instance
+ * @param tags Array of tags to filter clients by
  * @returns The combined server capabilities
  */
-export async function setupCapabilities(clients, server) {
+export async function setupCapabilities(clients, serverInfo) {
     // Collect capabilities from all clients
     const capabilities = collectCapabilities(clients);
     // Set up notification handlers
-    setupClientToServerNotifications(clients, server);
-    setupServerToClientNotifications(clients, server);
+    setupClientToServerNotifications(clients, serverInfo);
+    setupServerToClientNotifications(clients, serverInfo);
     // Register request handlers based on capabilities
-    registerRequestHandlers(clients, server, capabilities);
+    registerRequestHandlers(clients, serverInfo);
     return capabilities;
 }
 /**
@@ -23,12 +24,19 @@ export async function setupCapabilities(clients, server) {
  * @returns The combined server capabilities
  */
 function collectCapabilities(clients) {
-    let capabilities = {};
-    for (const [name, client] of Object.entries(clients)) {
+    const capabilities = {};
+    for (const [name, clientInfo] of Object.entries(clients)) {
         try {
-            const clientCapabilities = client.getServerCapabilities() || {};
-            logger.debug(`Capabilities from ${name}: ${JSON.stringify(clientCapabilities)}`);
-            capabilities = { ...capabilities, ...clientCapabilities };
+            const serverCapabilities = clientInfo.client.getServerCapabilities() || {};
+            logger.debug(`Capabilities from ${name}: ${JSON.stringify(serverCapabilities)}`);
+            // Store capabilities per client
+            clientInfo.capabilities = serverCapabilities;
+            // Aggregate capabilities
+            capabilities.resources = { ...capabilities.resources, ...serverCapabilities.resources };
+            capabilities.tools = { ...capabilities.tools, ...serverCapabilities.tools };
+            capabilities.prompts = { ...capabilities.prompts, ...serverCapabilities.prompts };
+            capabilities.experimental = { ...capabilities.experimental, ...serverCapabilities.experimental };
+            capabilities.logging = { ...capabilities.logging, ...serverCapabilities.logging };
         }
         catch (error) {
             logger.error(`Failed to get capabilities from ${name}: ${error}`);

package/build/clients/clientManager.js

@@ -1,7 +1,8 @@
 import createClient from '../client.js';
 import logger from '../logger/logger.js';
-import { CONNECTION_RETRY, MCP_SERVER_NAME } from '../constants.js';
-import { ClientConnectionError, ClientNotFoundError, withErrorHandling } from '../utils/errorHandling.js';
+import { CONNECTION_RETRY, MCP_SERVER_NAME, ERROR_CODES } from '../constants.js';
+import { ClientConnectionError, ClientNotFoundError, MCPError } from '../utils/errorTypes.js';
+import { ClientStatus } from '../types.js';
 /**
  * Creates client instances for all transports with retry logic
  * @param transports Record of transport instances
@@ -15,15 +16,27 @@ export async function createClients(transports) {
             const client = await createClient();
             // Connect with retry logic
             await connectWithRetry(client, transport, name);
-            clients[name] = client;
+            clients[name] = {
+                name,
+                transport,
+                client,
+                status: ClientStatus.Connected,
+                lastConnected: new Date(),
+            };
             logger.info(`Client created for ${name}`);
         }
         catch (error) {
             logger.error(`Failed to create client for ${name}: ${error}`);
-            // We continue with other clients even if one fails
+            clients[name] = {
+                name,
+                transport,
+                client: await createClient(),
+                status: ClientStatus.Error,
+                lastError: error instanceof Error ? error : new Error(String(error)),
+            };
         }
     }
-    return clients;
+    return Object.freeze(clients);
 }
 /**
  * Connects a client to its transport with retry logic
@@ -71,13 +84,54 @@ export function getClient(clients, clientName) {
     return client;
 }
 /**
- * Executes a client operation with error handling
+ * Executes an operation with error handling and retry logic
+ * @param operation The operation to execute
+ * @param context The execution context (client info or server info)
+ * @param options Operation options including timeout and retry settings
+ * @returns The result of the operation
+ */
+export async function executeOperation(operation, contextName, options = {}) {
+    const { retryCount = 0, retryDelay = 1000 } = options;
+    let lastError;
+    for (let i = 0; i <= retryCount; i++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (i < retryCount) {
+                logger.info(`Retrying operation ${operation.name} on ${contextName} after ${retryDelay}ms`);
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            }
+        }
+    }
+    // If we get here, we've exhausted all retries
+    logger.error(`Operation failed on ${contextName} after ${retryCount + 1} attempts: ${lastError}`);
+    if (lastError instanceof MCPError) {
+        throw lastError;
+    }
+    const mcpError = new MCPError(`Error executing operation on ${contextName}`, ERROR_CODES.INTERNAL_SERVER_ERROR, {
+        originalError: lastError,
+    });
+    throw mcpError;
+}
+/**
+ * Executes a client operation with error handling and retry logic
  * @param clients Record of client instances
  * @param clientName The name of the client to use
  * @param operation The operation to execute
- * @returns The result of the operation
+ * @param options Operation options including timeout and retry settings
+ */
+export async function executeClientOperation(clients, clientName, operation, options = {}) {
+    const clientInfo = getClient(clients, clientName);
+    return executeOperation(() => operation(clientInfo), `client ${clientName}`, options);
+}
+/**
+ * Executes a server operation with error handling and retry logic
+ * @param server The server to execute the operation on
+ * @param operation The operation to execute
+ * @param options Operation options including timeout and retry settings
  */
-export async function executeClientOperation(clients, clientName, operation) {
-    const client = getClient(clients, clientName);
-    return withErrorHandling(async () => operation(client), `Error executing operation on client ${clientName}`)();
+export async function executeServerOperation(server, operation, options = {}) {
+    return executeOperation(() => operation(server), 'server', options);
 }

package/build/clients/clientManager.test.js

@@ -0,0 +1,172 @@
+import { createClients, getClient, executeOperation, executeClientOperation, executeServerOperation, } from './clientManager.js';
+import createClientFn from '../client.js';
+import logger from '../logger/logger.js';
+import { ClientStatus } from '../types.js';
+import { ClientConnectionError, ClientNotFoundError, MCPError } from '../utils/errorTypes.js';
+import { MCP_SERVER_NAME, CONNECTION_RETRY } from '../constants.js';
+// Mock dependencies
+jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
+    Client: jest.fn(),
+}));
+jest.mock('../client.js', () => ({
+    __esModule: true,
+    default: jest.fn(),
+}));
+jest.mock('../logger/logger.js', () => ({
+    __esModule: true,
+    default: {
+        info: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+describe('clientManager', () => {
+    let mockTransport;
+    let mockClient;
+    let mockTransports;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useFakeTimers();
+        mockTransport = {
+            name: 'test-transport',
+            start: jest.fn(),
+            send: jest.fn(),
+            close: jest.fn(),
+        };
+        mockClient = {
+            connect: jest.fn(),
+            getServerVersion: jest.fn(),
+        };
+        mockTransports = {
+            'test-client': mockTransport,
+        };
+        createClientFn.mockResolvedValue(mockClient);
+    });
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+    describe('createClients', () => {
+        it('should create clients successfully', async () => {
+            mockClient.connect.mockResolvedValue(undefined);
+            mockClient.getServerVersion.mockResolvedValue({ name: 'test-server', version: '1.0.0' });
+            const clientsPromise = createClients(mockTransports);
+            await jest.runAllTimersAsync();
+            const clients = await clientsPromise;
+            expect(clients['test-client']).toBeDefined();
+            expect(clients['test-client'].status).toBe(ClientStatus.Connected);
+            expect(clients['test-client'].transport).toBe(mockTransport);
+            expect(logger.info).toHaveBeenCalledWith('Client created for test-client');
+        });
+        it('should handle client connection failure after retries', async () => {
+            const error = new Error('Connection failed');
+            mockClient.connect.mockRejectedValue(error);
+            const clientsPromise = createClients(mockTransports);
+            // Run through all retry attempts
+            for (let i = 0; i < CONNECTION_RETRY.MAX_ATTEMPTS; i++) {
+                await jest.advanceTimersByTimeAsync(CONNECTION_RETRY.INITIAL_DELAY_MS * Math.pow(2, i));
+            }
+            const clients = await clientsPromise;
+            expect(clients['test-client'].status).toBe(ClientStatus.Error);
+            expect(clients['test-client'].lastError).toBeInstanceOf(ClientConnectionError);
+            expect(clients['test-client'].lastError?.message).toContain('Connection failed');
+            expect(mockClient.connect).toHaveBeenCalledTimes(CONNECTION_RETRY.MAX_ATTEMPTS);
+        });
+        it('should prevent circular dependency with MCP server', async () => {
+            mockClient.connect.mockResolvedValue(undefined);
+            mockClient.getServerVersion.mockResolvedValue({ name: MCP_SERVER_NAME, version: '1.0.0' });
+            const clientsPromise = createClients(mockTransports);
+            await jest.runAllTimersAsync();
+            const clients = await clientsPromise;
+            expect(clients['test-client'].status).toBe(ClientStatus.Error);
+            expect(clients['test-client'].lastError).toBeInstanceOf(ClientConnectionError);
+            expect(clients['test-client'].lastError?.message).toContain('circular dependency');
+        });
+    });
+    describe('getClient', () => {
+        let clients;
+        beforeEach(async () => {
+            clients = await createClients(mockTransports);
+        });
+        it('should return client info for existing client', () => {
+            const clientInfo = getClient(clients, 'test-client');
+            expect(clientInfo).toBeDefined();
+            expect(clientInfo.name).toBe('test-client');
+        });
+        it('should throw ClientNotFoundError for non-existent client', () => {
+            expect(() => getClient(clients, 'non-existent')).toThrow(ClientNotFoundError);
+        });
+    });
+    describe('executeOperation', () => {
+        it('should execute operation successfully', async () => {
+            const operation = jest.fn().mockResolvedValue('result');
+            const result = await executeOperation(operation, 'test-context');
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalled();
+        });
+        it('should retry failed operations', async () => {
+            const error = new Error('Operation failed');
+            const operation = jest.fn().mockRejectedValueOnce(error).mockResolvedValueOnce('result');
+            const operationPromise = executeOperation(operation, 'test-context', { retryCount: 1, retryDelay: 1000 });
+            // Advance timer by retry delay
+            await jest.advanceTimersByTimeAsync(1000);
+            const result = await operationPromise;
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalledTimes(2);
+            expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('Retrying operation'));
+        });
+        it('should throw error after max retries', async () => {
+            const error = new Error('Operation failed');
+            const operation = jest.fn().mockRejectedValue(error);
+            const operationPromise = executeOperation(operation, 'test-context', { retryCount: 2, retryDelay: 1000 });
+            // Create rejection assertion before advancing timers
+            const rejection = expect(operationPromise).rejects.toMatchObject({
+                message: 'Error executing operation on test-context',
+                data: { originalError: error },
+            });
+            // Advance timer for each retry
+            for (let i = 0; i < 2; i++) {
+                await jest.advanceTimersByTimeAsync(1000);
+            }
+            // Wait for the rejection assertion
+            await rejection;
+            expect(operation).toHaveBeenCalledTimes(3); // Initial try + 2 retries
+            expect(logger.error).toHaveBeenCalled();
+        });
+    });
+    describe('executeClientOperation', () => {
+        let clients;
+        beforeEach(async () => {
+            clients = await createClients(mockTransports);
+        });
+        it('should execute client operation successfully', async () => {
+            const operation = jest.fn().mockResolvedValue('result');
+            const result = await executeClientOperation(clients, 'test-client', operation);
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalledWith(clients['test-client']);
+        });
+        it('should throw error for non-existent client', async () => {
+            const operation = jest.fn();
+            await expect(executeClientOperation(clients, 'non-existent', operation)).rejects.toThrow(ClientNotFoundError);
+        });
+    });
+    describe('executeServerOperation', () => {
+        let mockServer;
+        beforeEach(() => {
+            mockServer = {
+                server: {
+                    request: jest.fn().mockResolvedValue('result'),
+                },
+            };
+        });
+        it('should execute server operation successfully', async () => {
+            const operation = jest.fn().mockResolvedValue('result');
+            const result = await executeServerOperation(mockServer, operation);
+            expect(result).toBe('result');
+            expect(operation).toHaveBeenCalledWith(mockServer);
+        });
+        it('should handle server operation failure', async () => {
+            const error = new Error('Server operation failed');
+            const operation = jest.fn().mockRejectedValue(error);
+            await expect(executeServerOperation(mockServer, operation)).rejects.toThrow(MCPError);
+        });
+    });
+});

package/build/config/configManager.js

@@ -127,4 +127,4 @@ export class ConfigManager extends EventEmitter {
         return { ...this.transportConfig };
     }
 }
-export default ConfigManager.getInstance();
+export default ConfigManager;

package/build/config/configManager.test.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { ConfigManager, ConfigChangeEvent } from './configManager.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+import { setupCommonJestMocks } from '../test-utils/mocks/commonMocks.js';
+import { testConfig } from '../test-utils/fixtures/commonFixtures.js';
+import { clearAllMocks, createEventEmitterSpy } from '../test-utils/helpers/testHelpers.js';
+// Mock modules
+jest.mock('fs', () => ({
+    existsSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    writeFileSync: jest.fn(),
+    readFileSync: jest.fn(),
+    watch: jest.fn(() => ({ close: jest.fn() })),
+}));
+// Setup common mocks
+setupCommonJestMocks();
+// Mock constants
+jest.mock('../constants.js', () => ({
+    __esModule: true,
+    DEFAULT_CONFIG: { mcpServers: {} },
+    getGlobalConfigPath: jest.fn(),
+    getGlobalConfigDir: jest.fn().mockReturnValue('/test'),
+}));
+describe('ConfigManager', () => {
+    const testConfigPath = '/test/config.json';
+    beforeEach(() => {
+        // Reset all mocks and timers
+        clearAllMocks();
+        // Reset singleton instance
+        ConfigManager.instance = undefined;
+        // Default mock implementations
+        fs.existsSync.mockReturnValue(true);
+        fs.readFileSync.mockReturnValue(JSON.stringify({ mcpServers: {} }));
+    });
+    describe('getInstance', () => {
+        it('should create singleton instance', () => {
+            const instance1 = ConfigManager.getInstance(testConfigPath);
+            const instance2 = ConfigManager.getInstance(testConfigPath);
+            expect(instance1).toBe(instance2);
+        });
+        it('should use provided config path', () => {
+            const instance = ConfigManager.getInstance(testConfigPath);
+            expect(instance.configFilePath).toBe(testConfigPath);
+        });
+    });
+    describe('ensureConfigExists', () => {
+        it('should create config directory and file if they do not exist', () => {
+            fs.existsSync
+                .mockReturnValueOnce(false) // Directory doesn't exist
+                .mockReturnValueOnce(false); // File doesn't exist
+            ConfigManager.getInstance(testConfigPath);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(path.dirname(testConfigPath), { recursive: true });
+            expect(fs.writeFileSync).toHaveBeenCalledWith(testConfigPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+        });
+    });
+    describe('config watching', () => {
+        it('should start and stop watching config file', () => {
+            const instance = ConfigManager.getInstance(testConfigPath);
+            instance.startWatching();
+            expect(fs.watch).toHaveBeenCalledWith(testConfigPath, expect.any(Function));
+            instance.stopWatching();
+            expect(instance['configWatcher']).toBeNull();
+        });
+        it('should reload config on file change', () => {
+            const instance = ConfigManager.getInstance(testConfigPath);
+            const mockWatcher = { close: jest.fn() };
+            let watchCallback = () => { };
+            fs.watch.mockImplementation((path, callback) => {
+                watchCallback = callback;
+                return mockWatcher;
+            });
+            instance.startWatching();
+            // Setup spy for event emission
+            const emitSpy = createEventEmitterSpy(instance);
+            // Mock new config data
+            fs.readFileSync.mockReturnValueOnce(JSON.stringify(testConfig));
+            // Simulate file change
+            watchCallback('change', path.basename(testConfigPath));
+            expect(emitSpy).toHaveBeenCalledWith(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, testConfig.mcpServers);
+        });
+    });
+    describe('getTransportConfig', () => {
+        it('should return copy of transport config', () => {
+            fs.readFileSync.mockReturnValueOnce(JSON.stringify(testConfig));
+            const instance = ConfigManager.getInstance(testConfigPath);
+            const config = instance.getTransportConfig();
+            expect(config).toEqual(testConfig.mcpServers);
+            expect(config).not.toBe(instance['transportConfig']); // Should be a copy
+        });
+    });
+});

package/build/config/transportConfig.js

@@ -1,74 +1,53 @@
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { z, ZodError } from 'zod';
+import { ZodError } from 'zod';
 import logger from '../logger/logger.js';
-/**
- * Zod schema for transport configuration
- */
-export const transportConfigSchema = z.object({
-    type: z.enum(['stdio', 'sse', 'http']).optional(),
-    disabled: z.boolean().optional(),
-    // SSEServerParameters fields
-    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(),
-});
+import { transportConfigSchema } from '../types.js';
 /**
  * Creates transport instances from configuration
  * @returns Record of transport instances
  */
-export function createTransports(mcpConfig) {
+export function createTransports(config) {
     const transports = {};
-    for (const [name, transport] of Object.entries(mcpConfig)) {
-        if (transport.disabled) {
+    for (const [name, params] of Object.entries(config)) {
+        if (params.disabled) {
             logger.debug(`Skipping disabled transport: ${name}`);
             continue;
         }
         try {
-            // Validate transport configuration
-            const validatedTransport = transportConfigSchema.parse(transport);
-            // Merge environment variables
-            validatedTransport.env = {
-                ...Object.fromEntries(Object.entries(process.env)
-                    .filter(([_, v]) => v !== undefined)
-                    .map(([k, v]) => [k, String(v)])),
-                ...validatedTransport.env,
-            };
-            // Create transport based on type
+            const validatedTransport = transportConfigSchema.parse(params);
             if (validatedTransport.type === 'sse' || validatedTransport.type === 'http') {
                 if (!validatedTransport.url) {
                     throw new Error(`URL is required for SSE transport: ${name}`);
                 }
-                transports[name] = new SSEClientTransport(new URL(validatedTransport.url), {
+                const transport = new SSEClientTransport(new URL(validatedTransport.url), {
                     requestInit: {
                         headers: validatedTransport.headers,
                     },
                 });
+                transport.timeout = validatedTransport.timeout;
+                transport.tags = validatedTransport.tags;
+                transports[name] = transport;
             }
             else {
-                // For stdio transport, ensure required fields are present
                 if (!validatedTransport.command) {
                     throw new Error(`Command is required for stdio transport: ${name}`);
                 }
-                transports[name] = new StdioClientTransport(validatedTransport);
+                const transport = new StdioClientTransport(validatedTransport);
+                transport.timeout = validatedTransport.timeout;
+                transport.tags = validatedTransport.tags;
+                transports[name] = transport;
             }
-            logger.debug(`Created ${validatedTransport.type} transport for ${name}`);
+            logger.debug(`Created transport: ${name}`);
         }
         catch (error) {
             if (error instanceof ZodError) {
                 logger.error(`Invalid transport configuration for ${name}:`, error.errors);
             }
-            else if (error instanceof Error) {
-                logger.error(`Failed to create transport for ${name}: ${error.message}`);
-            }
             else {
-                logger.error(`Failed to create transport for ${name}: ${String(error)}`);
+                logger.error(`Error creating transport ${name}:`, error);
             }
+            throw error;
         }
     }
     return transports;

package/build/constants.js

@@ -3,6 +3,7 @@
  */
 // Server configuration
 export const PORT = 3050;
+export const HOST = '127.0.0.1';
 // API endpoints
 export const SSE_ENDPOINT = '/sse';
 export const MESSAGES_ENDPOINT = '/messages';
@@ -22,7 +23,7 @@ export const ERROR_CODES = {
 // MCP constants
 export const MCP_CONFIG_FILE = 'mcp.json';
 export const MCP_SERVER_NAME = '1mcp';
-export const MCP_SERVER_VERSION = '0.2.0';
+export const MCP_SERVER_VERSION = '0.7.0';
 export const MCP_URI_SEPARATOR = '_1mcp_';
 // Global config paths
 export const CONFIG_DIR_NAME = '1mcp';