cellium-mcp-client 1.1.3 → 1.1.4

package/dist/cli.js

@@ -11,23 +11,32 @@ const program = new commander_1.Command();
 program
     .name('cellium-mcp-client')
     .description('MCP client for connecting to remote Cellium processor server')
-    .version('1.1.2')
+    .version('1.1.3')
     .option('-t, --token <token>', 'Authentication token (format: user:username:hash)')
     .option('-e, --endpoint <url>', 'Server endpoint URL', 'http://localhost:3000/mcp')
     .option('-v, --verbose', 'Enable verbose logging')
+    .option('-d, --debug', 'Enable debug mode with extensive logging')
     .option('-r, --retry-attempts <num>', 'Number of retry attempts on connection failure', '3')
     .option('--retry-delay <ms>', 'Delay between retry attempts in milliseconds', '1000')
     .parse(process.argv);
 const options = program.opts();
-// Configure logging
+// Configure logging with different levels based on options
+let logLevel = 'info';
+if (options.debug) {
+    logLevel = 'debug';
+}
+else if (options.verbose) {
+    logLevel = 'debug';
+}
 const logger = (0, pino_1.default)({
-    level: options.verbose ? 'debug' : 'info',
+    level: logLevel,
     transport: {
         target: 'pino-pretty',
         options: {
             colorize: true,
-            translateTime: 'HH:MM:ss',
-            ignore: 'pid,hostname'
+            translateTime: 'HH:MM:ss.l',
+            ignore: 'pid,hostname',
+            messageFormat: options.debug ? '[{level}] {msg}' : '{msg}'
         }
     }
 });
@@ -37,47 +46,86 @@ async function main() {
         const token = options.token || process.env.CELLIUM_MCP_TOKEN;
         if (!token) {
             logger.error('Authentication token required. Use --token option or CELLIUM_MCP_TOKEN environment variable');
+            logger.info('Token format should be: user:username:hash');
             process.exit(1);
         }
         // Validate token format
         if (!token.match(/^user:[^:]+:[a-f0-9]+$/)) {
             logger.error('Invalid token format. Expected: user:username:hash');
+            logger.info('Example: user:myusername:abc123def456...');
             process.exit(1);
         }
-        logger.info('Starting Cellium MCP Client');
+        logger.info({
+            version: '1.1.3',
+            debugMode: !!options.debug,
+            verboseMode: !!options.verbose
+        }, 'Starting Cellium MCP Client');
         logger.debug({
             endpoint: options.endpoint,
             retryAttempts: parseInt(options.retryAttempts),
-            retryDelay: parseInt(options.retryDelay)
-        }, 'Configuration');
+            retryDelay: parseInt(options.retryDelay),
+            tokenPreview: `${token.split(':')[0]}:${token.split(':')[1]}:${token.split(':')[2]?.substring(0, 8)}...`
+        }, 'Configuration loaded');
         const client = new client_1.CelliumMCPClient({
             token,
             endpoint: options.endpoint,
             logger,
             retryAttempts: parseInt(options.retryAttempts),
-            retryDelay: parseInt(options.retryDelay)
+            retryDelay: parseInt(options.retryDelay),
+            debugMode: !!options.debug
+        });
+        // Enhanced error handling for unhandled rejections
+        process.on('unhandledRejection', (reason, promise) => {
+            logger.error({
+                reason,
+                promise
+            }, 'Unhandled promise rejection');
+        });
+        process.on('uncaughtException', (error) => {
+            logger.fatal({ error }, 'Uncaught exception');
+            process.exit(1);
         });
         // Handle graceful shutdown
         process.on('SIGINT', async () => {
             logger.info('Received SIGINT, shutting down gracefully');
-            await client.disconnect();
-            process.exit(0);
+            try {
+                await client.disconnect();
+                process.exit(0);
+            }
+            catch (error) {
+                logger.error({ error }, 'Error during shutdown');
+                process.exit(1);
+            }
         });
         process.on('SIGTERM', async () => {
             logger.info('Received SIGTERM, shutting down gracefully');
-            await client.disconnect();
-            process.exit(0);
+            try {
+                await client.disconnect();
+                process.exit(0);
+            }
+            catch (error) {
+                logger.error({ error }, 'Error during shutdown');
+                process.exit(1);
+            }
         });
+        logger.debug('Connecting to MCP transport...');
         await client.connect();
+        logger.info('MCP Client ready - starting server...');
         // Start the MCP server and keep process alive for stdio communication
         await client.serve();
     }
     catch (error) {
-        logger.error({ error }, 'Fatal error');
+        logger.fatal({
+            error: error instanceof Error ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack
+            } : error
+        }, 'Fatal error during startup');
         process.exit(1);
     }
 }
 main().catch((error) => {
-    console.error('Unhandled error:', error);
+    console.error('Unhandled startup error:', error);
     process.exit(1);
 });

package/dist/client.d.ts

@@ -5,17 +5,28 @@ export interface CelliumMCPClientConfig {
     logger: Logger;
     retryAttempts?: number;
     retryDelay?: number;
+    debugMode?: boolean;
 }
 export declare class CelliumMCPClient {
     private config;
     private localServer;
+    private transport?;
     private isConnected;
     private reconnectTimer?;
     private keepAliveInterval?;
+    private transportState;
+    private activeRequests;
+    private mcpProtocolVersion;
     constructor(config: CelliumMCPClientConfig);
+    private logDebug;
+    private logRequest;
+    private logResponse;
+    private setupTransportMonitoring;
     private setupServer;
+    private getSafeErrorResponse;
     private makeHttpRequest;
     connect(): Promise<void>;
+    private setupTransportEventListeners;
     private testConnectionInBackground;
     serve(): Promise<void>;
     private testConnection;

package/dist/client.js

@@ -44,19 +44,33 @@ const InitializedNotificationSchema = zod_1.z.object({
 class CelliumMCPClient {
     config;
     localServer;
+    transport;
     isConnected = false;
     reconnectTimer;
     keepAliveInterval;
+    transportState = {
+        connected: false,
+        lastActivity: 0,
+        requestCount: 0,
+        errorCount: 0
+    };
+    activeRequests = new Map();
+    mcpProtocolVersion = '2024-11-05';
     constructor(config) {
         this.config = {
             retryAttempts: 3,
             retryDelay: 1000,
+            debugMode: false,
             ...config
         };
+        this.logDebug('Initializing CelliumMCPClient', {
+            endpoint: this.config.endpoint,
+            debugMode: this.config.debugMode
+        });
         // Local server that interfaces with AI assistants via stdio
         this.localServer = new mcp_js_1.McpServer({
             name: 'cellium-mcp-client',
-            version: '1.0.0'
+            version: '1.1.3'
         }, {
             capabilities: {
                 tools: {},
@@ -64,172 +78,422 @@ class CelliumMCPClient {
             }
         });
         this.setupServer();
+        this.setupTransportMonitoring();
+    }
+    logDebug(message, data) {
+        if (this.config.debugMode) {
+            this.config.logger.debug({
+                timestamp: new Date().toISOString(),
+                transportState: this.transportState,
+                activeRequests: Array.from(this.activeRequests.entries()),
+                ...data
+            }, `[CELLIUM-MCP-DEBUG] ${message}`);
+        }
+    }
+    logRequest(method, id, params) {
+        this.transportState.requestCount++;
+        this.transportState.lastActivity = Date.now();
+        const timing = {
+            start: Date.now(),
+            method,
+            id
+        };
+        this.activeRequests.set(id, timing);
+        this.config.logger.info({
+            requestId: id,
+            method,
+            params,
+            requestCount: this.transportState.requestCount,
+            activeRequestCount: this.activeRequests.size
+        }, `[MCP-REQUEST] Received ${method}`);
+        this.logDebug(`Request received: ${method}`, { id, params });
+    }
+    logResponse(method, id, success, result, error) {
+        const timing = this.activeRequests.get(id);
+        const duration = timing ? Date.now() - timing.start : 0;
+        this.activeRequests.delete(id);
+        this.transportState.lastActivity = Date.now();
+        if (!success) {
+            this.transportState.errorCount++;
+        }
+        this.config.logger.info({
+            requestId: id,
+            method,
+            success,
+            duration,
+            result: success ? result : undefined,
+            error: !success ? error : undefined,
+            activeRequestCount: this.activeRequests.size,
+            totalErrors: this.transportState.errorCount
+        }, `[MCP-RESPONSE] Completed ${method} in ${duration}ms`);
+        this.logDebug(`Response sent: ${method}`, {
+            id,
+            success,
+            duration,
+            result: success ? result : undefined,
+            error: !success ? error : undefined
+        });
+    }
+    setupTransportMonitoring() {
+        // Monitor transport health every 10 seconds
+        setInterval(() => {
+            const now = Date.now();
+            const timeSinceLastActivity = now - this.transportState.lastActivity;
+            this.logDebug('Transport health check', {
+                timeSinceLastActivity,
+                activeRequestsCount: this.activeRequests.size,
+                errorRate: this.transportState.errorCount / Math.max(this.transportState.requestCount, 1)
+            });
+            // Log warning if no activity for 2 minutes
+            if (timeSinceLastActivity > 120000 && this.transportState.requestCount > 0) {
+                this.config.logger.warn({
+                    timeSinceLastActivity,
+                    lastActivity: new Date(this.transportState.lastActivity).toISOString()
+                }, 'Transport appears idle for extended period');
+            }
+            // Log active requests that are taking too long (>30s)
+            for (const [id, timing] of this.activeRequests.entries()) {
+                const requestDuration = now - timing.start;
+                if (requestDuration > 30000) {
+                    this.config.logger.warn({
+                        requestId: id,
+                        method: timing.method,
+                        duration: requestDuration
+                    }, 'Long-running request detected');
+                }
+            }
+        }, 10000);
     }
     setupServer() {
-        // Handle MCP initialization
-        this.localServer.server.setRequestHandler(InitializeSchema, async (_request) => {
-            this.config.logger.debug('Received initialize request');
-            return {
-                protocolVersion: '2024-11-05',
+        this.logDebug('Setting up MCP server handlers');
+        // Add error boundary wrapper for all handlers
+        const withErrorBoundary = (handler, methodName) => {
+            return async (request) => {
+                const requestId = Math.random().toString(36).substring(2, 15);
+                try {
+                    this.logRequest(methodName, requestId, request);
+                    const result = await handler(request);
+                    this.logResponse(methodName, requestId, true, result);
+                    return result;
+                }
+                catch (error) {
+                    this.logResponse(methodName, requestId, false, undefined, error);
+                    // Log the full error for debugging
+                    this.config.logger.error({
+                        error: error instanceof Error ? {
+                            name: error.name,
+                            message: error.message,
+                            stack: error.stack
+                        } : error,
+                        methodName,
+                        requestId,
+                        request
+                    }, `Error in ${methodName} handler`);
+                    // Don't re-throw - return safe fallback instead to prevent transport closure
+                    return this.getSafeErrorResponse(methodName, error);
+                }
+            };
+        };
+        // Handle MCP initialization with protocol version checking
+        this.localServer.server.setRequestHandler(InitializeSchema, withErrorBoundary(async (request) => {
+            this.logDebug('Processing initialize request', request);
+            const clientProtocolVersion = request.params?.protocolVersion;
+            if (clientProtocolVersion && clientProtocolVersion !== this.mcpProtocolVersion) {
+                this.config.logger.warn({
+                    clientVersion: clientProtocolVersion,
+                    serverVersion: this.mcpProtocolVersion
+                }, 'Protocol version mismatch detected');
+            }
+            const initResponse = {
+                protocolVersion: this.mcpProtocolVersion,
                 capabilities: {
                     tools: {},
                     resources: {}
                 },
                 serverInfo: {
                     name: 'cellium-mcp-client',
-                    version: '1.1.2'
+                    version: '1.1.3'
                 }
             };
-        });
+            this.transportState.connected = true;
+            this.transportState.lastActivity = Date.now();
+            this.logDebug('Initialize response prepared', initResponse);
+            return initResponse;
+        }, 'initialize'));
         // Override the underlying server's tool request handlers to proxy to remote
-        this.localServer.server.setRequestHandler(ToolsListSchema, async () => {
-            try {
-                this.config.logger.debug('Proxying tools/list to remote server');
-                const result = await this.makeHttpRequest('tools/list', {});
-                this.config.logger.debug({ result }, 'tools/list result from remote server');
-                return result;
-            }
-            catch (error) {
-                this.config.logger.error({ error }, 'Error proxying tools/list');
-                // Return empty tools list instead of throwing to prevent transport closure
-                return { tools: [] };
+        this.localServer.server.setRequestHandler(ToolsListSchema, withErrorBoundary(async (request) => {
+            this.logDebug('Processing tools/list request', request);
+            // Add artificial delay to test timing issues
+            if (this.config.debugMode) {
+                await new Promise(resolve => setTimeout(resolve, 100));
             }
+            const result = await this.makeHttpRequest('tools/list', {});
+            this.logDebug('tools/list completed successfully', { toolCount: result.tools?.length || 0 });
+            return result;
+        }, 'tools/list'));
+        this.localServer.server.setRequestHandler(ToolsCallSchema, withErrorBoundary(async (request) => {
+            this.logDebug('Processing tools/call request', {
+                toolName: request.params?.name,
+                hasArguments: !!request.params?.arguments
+            });
+            const result = await this.makeHttpRequest('tools/call', request.params);
+            this.logDebug('tools/call completed successfully', {
+                toolName: request.params?.name,
+                resultType: typeof result
+            });
+            return result;
+        }, 'tools/call'));
+        // Handle resources as well
+        this.localServer.server.setRequestHandler(ResourcesListSchema, withErrorBoundary(async (request) => {
+            this.logDebug('Processing resources/list request', request);
+            const result = await this.makeHttpRequest('resources/list', {});
+            this.logDebug('resources/list completed successfully', { resourceCount: result.resources?.length || 0 });
+            return result;
+        }, 'resources/list'));
+        this.localServer.server.setRequestHandler(ResourcesReadSchema, withErrorBoundary(async (request) => {
+            this.logDebug('Processing resources/read request', { uri: request.params?.uri });
+            const result = await this.makeHttpRequest('resources/read', request.params);
+            this.logDebug('resources/read completed successfully', { uri: request.params?.uri });
+            return result;
+        }, 'resources/read'));
+        // Handle ping
+        this.localServer.server.setRequestHandler(PingSchema, withErrorBoundary(async (request) => {
+            this.logDebug('Processing ping request', request);
+            const result = await this.makeHttpRequest('ping', {});
+            this.logDebug('ping completed successfully');
+            return result;
+        }, 'ping'));
+        // Handle other common MCP methods
+        this.localServer.server.setNotificationHandler(InitializedNotificationSchema, async (notification) => {
+            const notificationId = Math.random().toString(36).substring(2, 15);
+            this.logRequest('notifications/initialized', notificationId, notification);
+            this.logDebug('Received initialized notification', notification);
+            this.transportState.connected = true;
+            this.transportState.lastActivity = Date.now();
+            this.logResponse('notifications/initialized', notificationId, true);
+            // No response needed for notifications
         });
-        this.localServer.server.setRequestHandler(ToolsCallSchema, async (request) => {
-            try {
-                this.config.logger.debug({ toolName: request.params?.name }, 'Proxying tool call to remote server');
-                const result = await this.makeHttpRequest('tools/call', request.params);
-                return result;
-            }
-            catch (error) {
-                this.config.logger.error({ error, toolName: request.params?.name }, 'Error proxying tool call');
-                // Return error result instead of throwing
+        this.logDebug('MCP server handlers setup completed');
+    }
+    getSafeErrorResponse(methodName, error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        switch (methodName) {
+            case 'tools/list':
+                return { tools: [] };
+            case 'resources/list':
+                return { resources: [] };
+            case 'tools/call':
                 return {
                     content: [{
                             type: 'text',
-                            text: `Error calling tool: ${error instanceof Error ? error.message : 'Unknown error'}`
+                            text: `Error calling tool: ${errorMessage}`
                         }],
                     isError: true
                 };
-            }
-        });
-        // Handle resources as well
-        this.localServer.server.setRequestHandler(ResourcesListSchema, async () => {
-            try {
-                this.config.logger.debug('Proxying resources/list to remote server');
-                const result = await this.makeHttpRequest('resources/list', {});
-                return result;
-            }
-            catch (error) {
-                this.config.logger.error({ error }, 'Error proxying resources/list');
-                // Return empty resources list instead of throwing
-                return { resources: [] };
-            }
-        });
-        this.localServer.server.setRequestHandler(ResourcesReadSchema, async (request) => {
-            try {
-                this.config.logger.debug({ uri: request.params?.uri }, 'Proxying resources/read to remote server');
-                const result = await this.makeHttpRequest('resources/read', request.params);
-                return result;
-            }
-            catch (error) {
-                this.config.logger.error({ error, uri: request.params?.uri }, 'Error proxying resources/read');
-                // Return error result instead of throwing
+            case 'resources/read':
                 return {
                     contents: [{
-                            uri: request.params?.uri || '',
+                            uri: '',
                             mimeType: 'text/plain',
-                            text: `Error reading resource: ${error instanceof Error ? error.message : 'Unknown error'}`
+                            text: `Error reading resource: ${errorMessage}`
                         }]
                 };
-            }
-        });
-        // Handle ping
-        this.localServer.server.setRequestHandler(PingSchema, async () => {
-            try {
-                const result = await this.makeHttpRequest('ping', {});
-                return result;
-            }
-            catch (error) {
-                this.config.logger.error({ error }, 'Error proxying ping');
-                // Return empty result instead of throwing
+            case 'ping':
                 return {};
-            }
-        });
-        // Handle other common MCP methods
-        this.localServer.server.setNotificationHandler(InitializedNotificationSchema, async () => {
-            this.config.logger.debug('Received initialized notification');
-            // No response needed for notifications
-        });
+            default:
+                return { error: errorMessage };
+        }
     }
     async makeHttpRequest(method, params) {
+        const requestId = Math.random().toString(36).substring(2, 15);
+        const startTime = Date.now();
+        this.logDebug(`Starting HTTP request for ${method}`, {
+            requestId,
+            params,
+            isConnected: this.isConnected,
+            endpoint: this.config.endpoint
+        });
         // If not connected, try to connect first
         if (!this.isConnected) {
             try {
+                this.logDebug('Not connected, attempting connection test');
                 await this.testConnection();
                 this.isConnected = true;
                 this.config.logger.info('Connected to remote Cellium server');
             }
             catch (error) {
-                this.config.logger.error({ error }, 'Failed to connect to remote server');
+                this.config.logger.error({
+                    error: error instanceof Error ? {
+                        name: error.name,
+                        message: error.message,
+                        stack: error.stack
+                    } : error
+                }, 'Failed to connect to remote server');
                 throw new Error('Cannot connect to remote Cellium server');
             }
         }
         const mcpEndpoint = this.config.endpoint.replace('/sse', '/mcp');
         const requestBody = {
             jsonrpc: '2.0',
-            id: Math.random().toString(36).substring(2, 15),
+            id: requestId,
             method,
             params
         };
-        this.config.logger.debug({ method, endpoint: mcpEndpoint }, 'Making HTTP request to remote server');
+        this.logDebug(`Making HTTP request to ${mcpEndpoint}`, {
+            requestId,
+            method,
+            bodySize: JSON.stringify(requestBody).length
+        });
+        let response;
+        let responseText;
         try {
-            const response = await fetch(mcpEndpoint, {
+            response = await fetch(mcpEndpoint, {
                 method: 'POST',
                 headers: {
                     'Authorization': `Bearer ${this.config.token}`,
-                    'Content-Type': 'application/json'
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'cellium-mcp-client/1.1.3'
                 },
                 body: JSON.stringify(requestBody)
             });
+            responseText = await response.text();
+            const duration = Date.now() - startTime;
+            this.logDebug('HTTP response received', {
+                requestId,
+                method,
+                status: response.status,
+                statusText: response.statusText,
+                headers: Object.fromEntries(response.headers.entries()),
+                responseSize: responseText.length,
+                duration
+            });
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            const jsonResponse = await response.json();
+            let jsonResponse;
+            try {
+                jsonResponse = JSON.parse(responseText);
+            }
+            catch (parseError) {
+                this.config.logger.error({
+                    requestId,
+                    method,
+                    responseText: responseText.substring(0, 500),
+                    parseError: parseError instanceof Error ? parseError.message : parseError
+                }, 'Failed to parse JSON response');
+                throw new Error('Invalid JSON response from server');
+            }
+            this.logDebug('HTTP response parsed', {
+                requestId,
+                method,
+                hasResult: !!jsonResponse.result,
+                hasError: !!jsonResponse.error,
+                jsonrpcId: jsonResponse.id
+            });
             if (jsonResponse.error) {
+                this.config.logger.error({
+                    requestId,
+                    method,
+                    serverError: jsonResponse.error
+                }, 'Remote server returned error');
                 throw new Error(`Remote server error: ${jsonResponse.error.message}`);
             }
             return jsonResponse.result;
         }
         catch (error) {
-            this.config.logger.error({ error, method }, 'HTTP request to remote server failed');
+            const duration = Date.now() - startTime;
+            this.config.logger.error({
+                error: error instanceof Error ? {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack
+                } : error,
+                requestId,
+                method,
+                duration,
+                endpoint: mcpEndpoint
+            }, 'HTTP request to remote server failed');
             this.isConnected = false; // Mark as disconnected on error
             throw error;
         }
     }
     async connect() {
         try {
-            this.config.logger.info({ endpoint: this.config.endpoint }, 'Starting Cellium MCP Server');
+            this.config.logger.info({
+                endpoint: this.config.endpoint,
+                debugMode: this.config.debugMode,
+                protocolVersion: this.mcpProtocolVersion
+            }, 'Starting Cellium MCP Server');
+            this.logDebug('Initializing stdio transport');
             // Set up the stdio transport for local MCP server immediately
-            const stdioTransport = new stdio_js_1.StdioServerTransport();
-            await this.localServer.connect(stdioTransport);
+            this.transport = new stdio_js_1.StdioServerTransport();
+            // Add transport event monitoring
+            this.setupTransportEventListeners(this.transport);
+            await this.localServer.connect(this.transport);
+            this.transportState.connected = true;
+            this.transportState.lastActivity = Date.now();
             this.config.logger.info('MCP Server connected and ready');
+            this.logDebug('Transport connected successfully', {
+                transportType: 'stdio',
+                serverName: 'cellium-mcp-client',
+                serverVersion: '1.1.3'
+            });
             // Keep the process alive with a minimal interval
             // This ensures the process doesn't exit when stdin closes
             this.keepAliveInterval = setInterval(() => {
-                // Do nothing - just keep the event loop alive
+                this.logDebug('Keep-alive tick', {
+                    uptime: Date.now() - this.transportState.lastActivity,
+                    activeRequests: this.activeRequests.size
+                });
             }, 30000); // Check every 30 seconds
             this.config.logger.debug('Keep-alive interval started for persistent MCP communication');
             // Test connection to remote server in background, but don't block startup
             this.testConnectionInBackground();
         }
         catch (error) {
-            this.config.logger.error({ error }, 'Failed to start MCP server');
+            this.config.logger.error({
+                error: error instanceof Error ? {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack
+                } : error
+            }, 'Failed to start MCP server');
+            this.transportState.connected = false;
             throw error;
         }
     }
+    setupTransportEventListeners(transport) {
+        this.logDebug('Setting up transport event listeners');
+        // Monitor transport events if available
+        try {
+            // Try to access transport events (may not be available in all SDK versions)
+            const transportAny = transport;
+            if (transportAny.on && typeof transportAny.on === 'function') {
+                transportAny.on('close', () => {
+                    this.config.logger.warn('Transport close event detected');
+                    this.transportState.connected = false;
+                });
+                transportAny.on('error', (error) => {
+                    this.config.logger.error({ error }, 'Transport error event');
+                    this.transportState.errorCount++;
+                });
+                transportAny.on('connect', () => {
+                    this.config.logger.info('Transport connect event');
+                    this.transportState.connected = true;
+                });
+                this.logDebug('Transport event listeners attached');
+            }
+            else {
+                this.logDebug('Transport does not support event listeners');
+            }
+        }
+        catch (error) {
+            this.logDebug('Could not attach transport event listeners', { error });
+        }
+    }
     async testConnectionInBackground() {
         try {
+            this.logDebug('Testing connection to remote server in background');
             await this.testConnection();
             this.isConnected = true;
             this.config.logger.info('Connected to remote Cellium server');
@@ -239,7 +503,9 @@ class CelliumMCPClient {
             }
         }
         catch (error) {
-            this.config.logger.warn({ error }, 'Failed to connect to remote server, will retry on first request');
+            this.config.logger.warn({
+                error: error instanceof Error ? error.message : error
+            }, 'Failed to connect to remote server, will retry on first request');
             this.isConnected = false;
         }
     }
@@ -247,7 +513,22 @@ class CelliumMCPClient {
         // The MCP server is already connected via stdio in connect()
         // Keep the process alive indefinitely for persistent MCP communication
         // This ensures compatibility with MCP clients like Copilot that expect long-running servers
-        this.config.logger.debug('Server is now serving and will stay alive for persistent MCP communication');
+        this.config.logger.debug({
+            transportConnected: this.transportState.connected,
+            serverName: 'cellium-mcp-client'
+        }, 'Server is now serving and will stay alive for persistent MCP communication');
+        this.logDebug('Entering serve mode - process will stay alive');
+        // Set up graceful shutdown handlers
+        process.on('SIGINT', async () => {
+            this.config.logger.info('Received SIGINT, shutting down gracefully...');
+            await this.disconnect();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            this.config.logger.info('Received SIGTERM, shutting down gracefully...');
+            await this.disconnect();
+            process.exit(0);
+        });
         // Return a promise that never resolves to keep the process alive
         // The process will only exit via SIGINT/SIGTERM signals
         return new Promise(() => {
@@ -256,20 +537,32 @@ class CelliumMCPClient {
         });
     }
     async testConnection() {
+        const startTime = Date.now();
         const mcpEndpoint = this.config.endpoint.replace('/sse', '/mcp');
+        this.logDebug('Testing connection', {
+            endpoint: mcpEndpoint,
+            hasToken: !!this.config.token
+        });
         const response = await fetch(mcpEndpoint, {
             method: 'POST',
             headers: {
                 'Authorization': `Bearer ${this.config.token}`,
-                'Content-Type': 'application/json'
+                'Content-Type': 'application/json',
+                'User-Agent': 'cellium-mcp-client/1.1.3'
             },
             body: JSON.stringify({
                 jsonrpc: '2.0',
-                id: 'test-connection',
+                id: 'connection-test',
                 method: 'ping',
                 params: {}
             })
         });
+        const duration = Date.now() - startTime;
+        this.logDebug('Connection test response', {
+            status: response.status,
+            statusText: response.statusText,
+            duration
+        });
         if (!response.ok) {
             throw new Error(`Connection test failed: HTTP ${response.status}`);
         }
@@ -277,11 +570,26 @@ class CelliumMCPClient {
         if (result.error) {
             throw new Error(`Connection test failed: ${result.error.message}`);
         }
-        this.config.logger.debug('Connection test successful');
+        this.config.logger.debug({ duration }, 'Connection test successful');
     }
     async disconnect() {
         this.config.logger.info('Disconnecting from Cellium MCP Server');
+        this.logDebug('Starting disconnect process', {
+            activeRequestCount: this.activeRequests.size,
+            transportConnected: this.transportState.connected
+        });
         this.isConnected = false;
+        this.transportState.connected = false;
+        // Cancel any active requests
+        if (this.activeRequests.size > 0) {
+            this.config.logger.warn({
+                activeRequestCount: this.activeRequests.size
+            }, 'Cancelling active requests during disconnect');
+            for (const [id, timing] of this.activeRequests.entries()) {
+                this.logResponse(timing.method, id, false, undefined, 'Cancelled due to disconnect');
+            }
+            this.activeRequests.clear();
+        }
         if (this.reconnectTimer) {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = undefined;
@@ -290,8 +598,20 @@ class CelliumMCPClient {
             clearInterval(this.keepAliveInterval);
             this.keepAliveInterval = undefined;
         }
-        await this.localServer.close();
-        this.config.logger.info('Disconnected successfully');
+        try {
+            await this.localServer.close();
+            this.logDebug('Local MCP server closed successfully');
+        }
+        catch (error) {
+            this.config.logger.error({
+                error: error instanceof Error ? error.message : error
+            }, 'Error closing local MCP server');
+        }
+        this.config.logger.info({
+            totalRequests: this.transportState.requestCount,
+            totalErrors: this.transportState.errorCount,
+            uptime: Date.now() - this.transportState.lastActivity
+        }, 'Disconnected successfully');
     }
 }
 exports.CelliumMCPClient = CelliumMCPClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cellium-mcp-client",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "MCP client for connecting to remote Cellium processor server",
   "main": "dist/index.js",
   "bin": {