@1mcp/agent 0.1.0 → 0.4.0

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,10 +23,40 @@ 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.1.0';
+export const MCP_SERVER_VERSION = '0.4.0';
 export const MCP_URI_SEPARATOR = '_1mcp_';
+// Global config paths
+export const CONFIG_DIR_NAME = '1mcp';
+export const DEFAULT_CONFIG = {
+    mcpServers: {},
+};
+/**
+ * Get the global config directory path based on OS
+ */
+export function getGlobalConfigDir() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir) {
+        throw new Error('Could not determine home directory');
+    }
+    const configDir = process.platform === 'darwin' || process.platform === 'linux'
+        ? `${homeDir}/.config/${CONFIG_DIR_NAME}`
+        : `${homeDir}/AppData/Roaming/${CONFIG_DIR_NAME}`;
+    return configDir;
+}
+/**
+ * Get the global config file path
+ */
+export function getGlobalConfigPath() {
+    return `${getGlobalConfigDir()}/${MCP_CONFIG_FILE}`;
+}
 // Connection retry settings
 export const CONNECTION_RETRY = {
     MAX_ATTEMPTS: 3,
     INITIAL_DELAY_MS: 1000,
 };
+export const MCP_SERVER_CAPABILITIES = {
+    logging: {},
+    resources: {},
+    tools: {},
+    prompts: {},
+};

package/build/handlers/notificationHandlers.js

@@ -1,12 +1,12 @@
 import { CancelledNotificationSchema, ProgressNotificationSchema, LoggingMessageNotificationSchema, ResourceUpdatedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema, PromptListChangedNotificationSchema, InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
-import logger from '../logger.js';
+import logger from '../logger/logger.js';
 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,

package/build/handlers/requestHandlers.js

@@ -1,19 +1,21 @@
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import logger from '../logger.js';
-import { setLogLevel } from '../logger.js';
-import { MCP_URI_SEPARATOR, MCP_SERVER_NAME } from '../constants.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, CallToolResultSchema, } from '@modelcontextprotocol/sdk/types.js';
+import logger from '../logger/logger.js';
+import { setLogLevel } from '../logger/logger.js';
+import { MCP_URI_SEPARATOR, MCP_SERVER_NAME, ERROR_CODES } from '../constants.js';
 import { executeClientOperation } from '../clients/clientManager.js';
-import { ProxyError, parseUri, withErrorHandling } from '../utils/errorHandling.js';
+import { parseUri, withErrorHandling } from '../utils/errorHandling.js';
+import { MCPError } from '../utils/errorTypes.js';
+import { filterClientsByTags } from '../utils/clientFiltering.js';
 /**
  * Sends a partial failure notification to inform clients about backend failures
  * @param server The MCP server instance
  * @param operation The operation that partially failed
  * @param failedClients Array of failed clients with error details
  */
-function sendPartialFailureNotification(server, operation, failedClients) {
+function sendPartialFailureNotification(serverInfo, operation, failedClients) {
     if (failedClients.length === 0)
         return;
-    server.notification({
+    serverInfo.server.notification({
         method: 'notifications/message',
         params: {
             level: 'warning',
@@ -32,40 +34,44 @@ function sendPartialFailureNotification(server, operation, failedClients) {
  * @param clients Record of client instances
  * @param server The MCP server instance
  * @param capabilities The server capabilities
+ * @param tags Array of tags to filter clients by
  */
-export function registerRequestHandlers(clients, server, capabilities) {
+export function registerRequestHandlers(clients, serverInfo, capabilities) {
     // Register logging level handler
-    server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    serverInfo.server.setRequestHandler(SetLevelRequestSchema, async (request) => {
         setLogLevel(request.params.level);
         return {};
     });
     // Register resource-related handlers if capability is available
     if (capabilities.resources) {
-        registerResourceHandlers(clients, server);
+        registerResourceHandlers(clients, serverInfo);
     }
     // Register tool-related handlers if capability is available
     if (capabilities.tools) {
-        registerToolHandlers(clients, server);
+        registerToolHandlers(clients, serverInfo);
     }
     // Register prompt-related handlers if capability is available
     if (capabilities.prompts) {
-        registerPromptHandlers(clients, server);
+        registerPromptHandlers(clients, serverInfo);
     }
 }
 /**
  * Registers resource-related request handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-function registerResourceHandlers(clients, server) {
+function registerResourceHandlers(clients, serverInfo) {
     // List Resources handler
-    server.setRequestHandler(ListResourcesRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListResourcesRequestSchema, withErrorHandling(async (request) => {
         const resources = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing resources for ${name}`);
             try {
-                const result = await client.listResources(request.params);
+                const result = await clientInfo.client.listResources(request.params, {
+                    timeout: clientInfo.transport.timeout,
+                });
                 resources.push(...result.resources.map((resource) => ({
                     uri: `${name}${MCP_URI_SEPARATOR}${resource.uri}`,
                     name: resource.name,
@@ -79,23 +85,28 @@ function registerResourceHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list resources from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list resources from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listResources', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listResources', failedClients);
         }
         return { resources };
     }, 'Error listing resources'));
     // List Resource Templates handler
-    server.setRequestHandler(ListResourceTemplatesRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListResourceTemplatesRequestSchema, withErrorHandling(async (request) => {
         const resourceTemplates = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing resource templates for ${name}`);
             try {
-                const result = await client.listResourceTemplates(request.params);
+                const result = await clientInfo.client.listResourceTemplates(request.params, {
+                    timeout: clientInfo.transport.timeout,
+                });
                 resourceTemplates.push(...result.resourceTemplates.map((template) => ({
                     uriTemplate: `${name}${MCP_URI_SEPARATOR}${template.uriTemplate}`,
                     name: template.name,
@@ -109,45 +120,56 @@ function registerResourceHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list resource templates from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list resource templates from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listResourceTemplates', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listResourceTemplates', failedClients);
         }
         return { resourceTemplates };
     }, 'Error listing resource templates'));
     // Subscribe Resource handler
-    server.setRequestHandler(SubscribeRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(SubscribeRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.subscribeResource({ ...request.params, uri: resourceName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.subscribeResource({ ...request.params, uri: resourceName }, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error subscribing to resource'));
     // Unsubscribe Resource handler
-    server.setRequestHandler(UnsubscribeRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(UnsubscribeRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.unsubscribeResource({ ...request.params, uri: resourceName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.unsubscribeResource({ ...request.params, uri: resourceName }, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error unsubscribing from resource'));
     // Read Resource handler
-    server.setRequestHandler(ReadResourceRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ReadResourceRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName } = parseUri(request.params.uri, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.readResource({ ...request.params, uri: resourceName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.readResource({ ...request.params, uri: resourceName }, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error reading resource'));
 }
 /**
  * Registers tool-related request handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-function registerToolHandlers(clients, server) {
+function registerToolHandlers(clients, serverInfo) {
     // List Tools handler
-    server.setRequestHandler(ListToolsRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListToolsRequestSchema, withErrorHandling(async (request) => {
         const tools = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing tools for ${name}`);
             try {
-                const result = await client.listTools(request.params);
+                const result = await clientInfo.client.listTools(request.params, {
+                    timeout: clientInfo.transport.timeout,
+                });
                 tools.push(...result.tools.map((tool) => ({
                     name: `${name}${MCP_URI_SEPARATOR}${tool.name}`,
                     description: tool.description,
@@ -160,35 +182,40 @@ function registerToolHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list tools from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list tools from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listTools', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listTools', failedClients);
         }
         return { tools };
     }, 'Error listing tools'));
     // Call Tool handler
-    server.setRequestHandler(CallToolRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(CallToolRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName: toolName } = parseUri(request.params.name, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.callTool({ ...request.params, name: toolName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.callTool({ ...request.params, name: toolName }, CallToolResultSchema, {
+            timeout: clientInfo.transport.timeout,
+        }));
     }, 'Error calling tool'));
 }
 /**
  * Registers prompt-related request handlers
  * @param clients Record of client instances
- * @param server The MCP server instance
+ * @param serverInfo The MCP server instance
  */
-function registerPromptHandlers(clients, server) {
+function registerPromptHandlers(clients, serverInfo) {
     // List Prompts handler
-    server.setRequestHandler(ListPromptsRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(ListPromptsRequestSchema, withErrorHandling(async (request) => {
         const prompts = [];
         const failedClients = [];
-        for (const [name, client] of Object.entries(clients)) {
+        const filteredClients = filterClientsByTags(clients, serverInfo.tags);
+        for (const [name, clientInfo] of Object.entries(filteredClients)) {
             logger.info(`Listing prompts for ${name}`);
             try {
-                const result = await client.listPrompts(request.params);
+                const result = await clientInfo.client.listPrompts(request.params);
                 prompts.push(...result.prompts.map((prompt) => ({
                     name: `${name}${MCP_URI_SEPARATOR}${prompt.name}`,
                     description: prompt.description,
@@ -201,18 +228,20 @@ function registerPromptHandlers(clients, server) {
             }
         }
         // If all clients failed, throw an error
-        if (failedClients.length === Object.keys(clients).length && Object.keys(clients).length > 0) {
-            throw new ProxyError('Failed to list prompts from all clients', new Error(JSON.stringify(failedClients)));
+        if (failedClients.length === Object.keys(filteredClients).length && Object.keys(filteredClients).length > 0) {
+            throw new MCPError('Failed to list prompts from all clients', ERROR_CODES.INTERNAL_SERVER_ERROR, {
+                failedClients,
+            });
         }
         // Send notification about partial failures
         if (failedClients.length > 0) {
-            sendPartialFailureNotification(server, 'listPrompts', failedClients);
+            sendPartialFailureNotification(serverInfo, 'listPrompts', failedClients);
         }
         return { prompts };
     }, 'Error listing prompts'));
     // Get Prompt handler
-    server.setRequestHandler(GetPromptRequestSchema, withErrorHandling(async (request) => {
+    serverInfo.server.setRequestHandler(GetPromptRequestSchema, withErrorHandling(async (request) => {
         const { clientName, resourceName: promptName } = parseUri(request.params.name, MCP_URI_SEPARATOR);
-        return executeClientOperation(clients, clientName, (client) => client.getPrompt({ ...request.params, name: promptName }));
+        return executeClientOperation(clients, clientName, (clientInfo) => clientInfo.client.getPrompt({ ...request.params, name: promptName }));
     }, 'Error getting prompt'));
 }

package/build/index.js

@@ -1,115 +1,64 @@
 #!/usr/bin/env node
-import express from 'express';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { server } from './server.js';
-import logger, { setMCPTransportConnected } from './logger.js';
-import { PORT, SSE_ENDPOINT, MESSAGES_ENDPOINT, ERROR_CODES } from './constants.js';
+import { setupServer } from './server.js';
+import logger from './logger/logger.js';
 import configReloadService from './services/configReloadService.js';
+import { ConfigManager } from './config/configManager.js';
+import { ExpressServer } from './server/expressServer.js';
+import { PORT, HOST } from './constants.js';
 // Parse command line arguments
 const argv = yargs(hideBin(process.argv))
     .usage('Usage: $0 [options]')
     .options({
     transport: {
         alias: 't',
-        describe: 'Transport type to use (stdio or http)',
+        describe: 'Transport type to use (stdio or sse)',
         type: 'string',
-        choices: ['stdio', 'http'],
-        default: 'http',
+        choices: ['stdio', 'sse'],
+        default: 'sse',
+    },
+    port: {
+        alias: 'P',
+        describe: 'SSE port to listen on, applicable when transport is sse',
+        type: 'number',
+        default: PORT,
+    },
+    host: {
+        alias: 'H',
+        describe: 'SSE host to listen on, applicable when transport is sse',
+        type: 'string',
+        default: HOST,
+    },
+    config: {
+        alias: 'c',
+        describe: 'Path to the config file',
+        type: 'string',
+        default: undefined,
+    },
+    tags: {
+        alias: 'g',
+        describe: 'Tags to filter clients (comma-separated)',
+        type: 'string',
+        default: undefined,
     },
 })
     .help()
     .alias('help', 'h')
     .parseSync();
-const app = express();
-// app.use(express.json());
-// app.use(express.urlencoded({ extended: true }));
-const transportMap = new Map();
-// Add error handling middleware
-app.use((err, req, res, next) => {
-    logger.error('Express error:', err);
-    res.status(500).json({
-        error: {
-            code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-            message: 'Internal server error',
-        },
-    });
-});
-app.get(SSE_ENDPOINT, async (req, res) => {
-    try {
-        logger.info('sse', { query: req.query, headers: req.headers });
-        const transport = new SSEServerTransport(MESSAGES_ENDPOINT, res);
-        await server.connect(transport);
-        transportMap.set(transport.sessionId, transport);
-        // Update MCP transport connection status when a client connects
-        if (transportMap.size === 1) {
-            setMCPTransportConnected(true);
-            logger.info('First client connected, enabling MCP logging transport');
-        }
-        transport.onclose = () => {
-            transportMap.delete(transport.sessionId);
-            logger.info('transport closed', transport.sessionId);
-            // Update MCP transport connection status when all clients disconnect
-            if (transportMap.size === 0) {
-                setMCPTransportConnected(false);
-                logger.info('All clients disconnected, disabling MCP logging transport');
-            }
-        };
-    }
-    catch (error) {
-        logger.error('SSE connection error:', error);
-        res.status(500).end();
-    }
-});
-app.post(MESSAGES_ENDPOINT, async (req, res) => {
-    try {
-        const sessionId = req.query.sessionId;
-        if (!sessionId) {
-            res.status(400).json({
-                error: {
-                    code: ERROR_CODES.INVALID_PARAMS,
-                    message: 'Invalid params: sessionId is required',
-                },
-            });
-            return;
-        }
-        logger.info('message', { body: req.body, sessionId });
-        const transport = transportMap.get(sessionId);
-        if (transport) {
-            await transport.handlePostMessage(req, res);
-            return;
-        }
-        res.status(404).json({
-            error: {
-                code: ERROR_CODES.TRANSPORT_NOT_FOUND,
-                message: 'Transport not found',
-            },
-        });
-    }
-    catch (error) {
-        logger.error('Message handling error:', error);
-        res.status(500).json({
-            error: {
-                code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-                message: 'Internal server error',
-            },
-        });
-    }
-});
 /**
  * Set up graceful shutdown handling
  */
-function setupGracefulShutdown() {
+function setupGracefulShutdown(serverManager) {
     const shutdown = async () => {
         logger.info('Shutting down server...');
         // Stop the configuration reload service
         configReloadService.stop();
         // Close all transports
-        for (const [sessionId, transport] of transportMap.entries()) {
+        for (const [sessionId, transport] of serverManager.getTransports().entries()) {
             try {
-                transport.close();
+                transport?.close();
                 logger.info(`Closed transport: ${sessionId}`);
             }
             catch (error) {
@@ -128,19 +77,36 @@ function setupGracefulShutdown() {
  * Start the server using the specified transport.
  */
 async function main() {
-    // Set up graceful shutdown handling
-    setupGracefulShutdown();
-    if (argv.transport === 'stdio') {
-        // Use stdio transport
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
-        logger.info('Server started with stdio transport');
+    try {
+        ConfigManager.getInstance(argv.config);
+        // Initialize server and get server manager with custom config path if provided
+        const serverManager = await setupServer();
+        // Set up graceful shutdown handling
+        setupGracefulShutdown(serverManager);
+        if (argv.transport === 'stdio') {
+            // Use stdio transport
+            const transport = new StdioServerTransport();
+            // Parse and validate tags from CLI if provided
+            let tags;
+            if (argv.tags) {
+                tags = argv.tags.split(',').filter((tag) => tag.trim().length > 0);
+                if (tags.length === 0) {
+                    logger.warn('No valid tags provided, ignoring tags parameter');
+                    tags = undefined;
+                }
+            }
+            await serverManager.connectTransport(transport, 'stdio', tags);
+            logger.info('Server started with stdio transport');
+        }
+        else {
+            // Use HTTP/SSE transport
+            const expressServer = new ExpressServer(serverManager);
+            expressServer.start(argv.port, argv.host);
+        }
     }
-    else {
-        // Use HTTP/SSE transport
-        app.listen(PORT, () => {
-            logger.info(`Server is running on port ${PORT} with HTTP/SSE transport`);
-        });
+    catch (error) {
+        logger.error('Server error:', error);
+        process.exit(1);
     }
 }
 main().catch((error) => {

package/build/{logger.js → logger/logger.js}

@@ -23,31 +23,18 @@ const customFormat = winston.format.combine(winston.format.timestamp(), winston.
     const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
     return `${timestamp} [${level.toUpperCase()}] ${message}${metaStr}`;
 }));
+const consoleFormat = winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+    const keys = Object.keys(meta);
+    const metaStr = keys.length > 0 ? ` ${keys.map((key) => `${key}=${JSON.stringify(meta[key])}`).join(' ')}` : '';
+    return `${timestamp} [${level.toUpperCase()}] message=${JSON.stringify(message)}${metaStr}`;
+}));
 // Create the logger without the MCP transport initially
 const logger = winston.createLogger({
     level: 'info',
     format: customFormat,
-    defaultMeta: { service: '1mcp' },
     transports: [
         new winston.transports.Console({
-            format: customFormat,
-        }),
-        //
-        // - Write all logs with importance level of `error` or higher to `error.log`
-        //   (i.e., error, fatal, but not other levels)
-        //
-        new winston.transports.File({
-            filename: path.join(logsDir, 'error.log'),
-            level: 'error',
-            format: customFormat,
-        }),
-        //
-        // - Write all logs with importance level of `info` or higher to `combined.log`
-        //   (i.e., fatal, error, warn, and info, but not trace)
-        //
-        new winston.transports.File({
-            filename: path.join(logsDir, 'combined.log'),
-            format: customFormat,
+            format: consoleFormat,
         }),
     ],
     // Prevent logger from exiting on error
@@ -64,7 +51,7 @@ export function addMCPTransport(server, loggerName) {
     // Add the MCP transport to the logger
     mcpTransport = new MCPTransport({
         server,
-        loggerName: loggerName || '1mcp-agent',
+        loggerName: loggerName || '1mcp',
         level: 'info',
     });
     logger.add(mcpTransport);