@1mcp/agent 0.2.0 → 0.4.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

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, capabilities);
     return capabilities;
 }
 /**
@@ -24,9 +25,9 @@ export async function setupCapabilities(clients, server) {
  */
 function collectCapabilities(clients) {
     let capabilities = {};
-    for (const [name, client] of Object.entries(clients)) {
+    for (const [name, clientInfo] of Object.entries(clients)) {
         try {
-            const clientCapabilities = client.getServerCapabilities() || {};
+            const clientCapabilities = clientInfo.client.getServerCapabilities() || {};
             logger.debug(`Capabilities from ${name}: ${JSON.stringify(clientCapabilities)}`);
             capabilities = { ...capabilities, ...clientCapabilities };
         }

package/build/clients/clientManager.js

@@ -1,7 +1,9 @@
 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 { withErrorHandling } from '../utils/errorHandling.js';
+import { ClientConnectionError, ClientNotFoundError } 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 +17,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 +85,30 @@ export function getClient(clients, clientName) {
     return client;
 }
 /**
- * Executes a client operation with error handling
+ * Executes a client operation with error handling and timeout
  * @param clients Record of client instances
  * @param clientName The name of the client to use
  * @param operation The operation to execute
+ * @param options Operation options including timeout and retry settings
  * @returns The result of the operation
  */
-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 executeClientOperation(clients, clientName, operation, options = {}) {
+    const clientInfo = getClient(clients, clientName);
+    const { retryCount = 0, retryDelay = 1000 } = options;
+    return withErrorHandling(async () => {
+        let lastError;
+        for (let i = 0; i <= retryCount; i++) {
+            try {
+                return await operation(clientInfo);
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (i < retryCount) {
+                    logger.info(`Retrying operation ${operation.name} on client ${clientName} after ${retryDelay}ms`);
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+            }
+        }
+        throw lastError;
+    }, `Error executing operation on client ${clientName}`)();
 }

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,106 @@
+import fs from 'fs';
+import path from 'path';
+// Mock modules before importing ConfigManager
+jest.mock('fs', () => ({
+    existsSync: jest.fn(),
+    mkdirSync: jest.fn(),
+    writeFileSync: jest.fn(),
+    readFileSync: jest.fn(),
+    watch: jest.fn(() => ({ close: jest.fn() })),
+}));
+const mockLogger = {
+    error: jest.fn(),
+    warn: jest.fn(),
+    info: jest.fn(),
+    debug: jest.fn(),
+    level: 'info',
+    transports: [],
+};
+jest.doMock('../logger/logger.js', () => ({
+    __esModule: true,
+    default: mockLogger,
+}));
+// Mock constants
+jest.doMock('../constants.js', () => ({
+    __esModule: true,
+    DEFAULT_CONFIG: { mcpServers: {} },
+    getGlobalConfigPath: jest.fn(),
+    getGlobalConfigDir: jest.fn().mockReturnValue('/test'),
+}));
+// Import after mocks are set up
+import { ConfigManager, ConfigChangeEvent } from './configManager.js';
+import { DEFAULT_CONFIG } from '../constants.js';
+describe('ConfigManager', () => {
+    const testConfigPath = '/test/config.json';
+    beforeEach(() => {
+        // Reset all mocks
+        jest.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 = jest.spyOn(instance, 'emit');
+            // Mock new config data
+            const newConfig = { mcpServers: { test: { url: 'test-url' } } };
+            fs.readFileSync.mockReturnValueOnce(JSON.stringify(newConfig));
+            // Simulate file change
+            watchCallback('change', path.basename(testConfigPath));
+            expect(emitSpy).toHaveBeenCalledWith(ConfigChangeEvent.TRANSPORT_CONFIG_CHANGED, newConfig.mcpServers);
+        });
+    });
+    describe('getTransportConfig', () => {
+        it('should return copy of transport config', () => {
+            const testConfig = {
+                mcpServers: {
+                    test: { url: 'test-url' },
+                },
+            };
+            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.4.0';
 export const MCP_URI_SEPARATOR = '_1mcp_';
 // Global config paths
 export const CONFIG_DIR_NAME = '1mcp';

package/build/handlers/notificationHandlers.js

@@ -4,9 +4,9 @@ import { withErrorHandling } from '../utils/errorHandling.js';
 /**
  * Sets up client-to-server notification handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-export function setupClientToServerNotifications(clients, server) {
+export function setupClientToServerNotifications(clients, serverInfo) {
     const clientNotificationSchemas = [
         CancelledNotificationSchema,
         ProgressNotificationSchema,
@@ -16,11 +16,11 @@ export function setupClientToServerNotifications(clients, server) {
         ToolListChangedNotificationSchema,
         PromptListChangedNotificationSchema,
     ];
-    for (const [name, client] of Object.entries(clients)) {
+    for (const [name, clientInfo] of Object.entries(clients)) {
         clientNotificationSchemas.forEach((schema) => {
-            client.setNotificationHandler(schema, withErrorHandling(async (notification) => {
+            clientInfo.client.setNotificationHandler(schema, withErrorHandling(async (notification) => {
                 logger.info(`Received notification in client: ${name} ${JSON.stringify(notification)}`);
-                server.notification({
+                serverInfo.server.notification({
                     ...notification,
                     params: {
                         ...notification.params,
@@ -34,20 +34,20 @@ export function setupClientToServerNotifications(clients, server) {
 /**
  * Sets up server-to-client notification handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-export function setupServerToClientNotifications(clients, server) {
+export function setupServerToClientNotifications(clients, serverInfo) {
     const serverNotificationSchemas = [
         CancelledNotificationSchema,
         ProgressNotificationSchema,
         InitializedNotificationSchema,
         RootsListChangedNotificationSchema,
     ];
-    for (const [name, client] of Object.entries(clients)) {
+    for (const [name, clientInfo] of Object.entries(clients)) {
         serverNotificationSchemas.forEach((schema) => {
-            server.setNotificationHandler(schema, withErrorHandling(async (notification) => {
+            serverInfo.server.setNotificationHandler(schema, withErrorHandling(async (notification) => {
                 logger.info(`Received notification in server: ${name} ${JSON.stringify(notification)}`);
-                client.notification({
+                clientInfo.client.notification({
                     ...notification,
                     params: {
                         ...notification.params,