cellium-mcp-client 1.0.3 → 1.1.1

package/README.md

@@ -1,10 +1,10 @@
 # @cellium/mcp-client
 
-A Model Context Protocol (MCP) client for connecting to the remote Cellium processor server via Server-Sent Events (SSE).
+A Model Context Protocol (MCP) server that proxies requests to remote Cellium processor servers.
 
 ## Features
 
-- **SSE Transport**: Connects to remote Cellium server using Server-Sent Events
+- **HTTP Proxy**: Proxies MCP requests to remote Cellium servers via HTTP
 - **Authentication**: Token-based authentication with format `user:username:hash`
 - **Robust Connection Management**: Automatic reconnection with configurable retry logic
 - **MCP Protocol Compliance**: Uses official `@modelcontextprotocol/sdk`
@@ -38,7 +38,7 @@ cellium-mcp-client --token "user:your-username:your-hash"
 # With custom endpoint and verbose logging
 cellium-mcp-client \
   --token "user:your-username:your-hash" \
-  --endpoint "https://mcp.cellium.dev/sse" \
+  --endpoint "https://mcp.cellium.dev/mcp" \
   --verbose \
   --retry-attempts 5 \
   --retry-delay 2000
@@ -66,7 +66,7 @@ const logger = pino();
 
 const client = new CelliumMCPClient({
   token: 'user:your-username:your-hash',
-  endpoint: 'https://mcp.cellium.dev/sse',
+  endpoint: 'https://mcp.cellium.dev/mcp',
   logger,
   retryAttempts: 3,
   retryDelay: 1000
@@ -87,7 +87,7 @@ process.on('SIGINT', async () => {
 | Option | Environment Variable | Description | Default |
 |--------|---------------------|-------------|---------|
 | `--token` | `CELLIUM_MCP_TOKEN` | Authentication token (required) | - |
-| `--endpoint` | - | Server endpoint URL | `https://mcp.cellium.dev/sse` |
+| `--endpoint` | - | Server endpoint URL | `https://mcp.cellium.dev/mcp` |
 | `--verbose` | - | Enable verbose logging | `false` |
 | `--retry-attempts` | - | Number of retry attempts | `3` |
 | `--retry-delay` | - | Delay between retries (ms) | `1000` |
@@ -106,29 +106,20 @@ Example: `user:john-doe:a1b2c3d4e5f6...`
 ## Architecture
 
 ```
-┌─────────────────┐    SSE     ┌─────────────────┐
-│                 │◄──────────►│                 │
-│   MCP Client    │   HTTPS    │ Cellium Server  │
-│  (This Package) │            │   (Remote)      │
-│                 │            │                 │
-└─────────────────┘            └─────────────────┘
-         ▲                               │
-         │ stdio                        │
-         │ MCP Protocol                 │
-         ▼                               │
-┌─────────────────┐                     │
-│                 │                     │
-│  Code Editor /  │                     │
-│  AI Assistant   │                     │
-│   (Cody, etc.)  │                     │
-└─────────────────┘                     │
+┌─────────────────┐   stdio    ┌─────────────────┐   HTTPS    ┌─────────────────┐
+│                 │◄──────────►│                 │◄──────────►│                 │
+│  Code Editor /  │    MCP     │ cellium-mcp-    │    HTTP    │ Cellium Server  │
+│  AI Assistant   │  Protocol  │ client (Proxy)  │   Requests │   (Remote)      │
+│   (Cody, etc.)  │            │                 │            │                 │
+└─────────────────┘            └─────────────────┘            └─────────────────┘
 ```
 
-The client acts as a bridge between local MCP clients (like Cody) and the remote Cellium processor server, handling:
-- Authentication and connection management
-- Protocol translation between stdio MCP and SSE
-- Error handling and reconnection logic
-- Request/response proxying
+The client acts as an **MCP server proxy** between local MCP clients (like Cody) and the remote Cellium processor server, handling:
+- **MCP Protocol**: Full stdio-based MCP server implementation
+- **Authentication**: Token-based authentication with remote server
+- **Request Proxying**: Converts MCP requests to HTTP requests to remote server
+- **Error Handling**: Graceful handling of connection failures
+- **Connection Management**: Automatic retry and reconnection logic
 
 ## Development
 
@@ -153,7 +144,7 @@ npm run dev
 ### Connection Issues
 
 1. **Invalid token format**: Ensure your token follows the `user:username:hash` format
-2. **Network connectivity**: Check if `https://mcp.cellium.dev/sse` is accessible
+2. **Network connectivity**: Check if `https://mcp.cellium.dev/mcp` is accessible
 3. **Authentication failed**: Verify your token is valid and not expired
 
 ### Verbose Logging

package/dist/cli.js

@@ -11,7 +11,7 @@ const program = new commander_1.Command();
 program
     .name('cellium-mcp-client')
     .description('MCP client for connecting to remote Cellium processor server')
-    .version('1.0.3')
+    .version('1.1.1')
     .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')

package/dist/client.d.ts

@@ -11,14 +11,12 @@ export declare class CelliumMCPClient {
     private localServer;
     private isConnected;
     private reconnectTimer?;
-    private currentRetryCount;
     constructor(config: CelliumMCPClientConfig);
     private setupServer;
     private makeHttpRequest;
     connect(): Promise<void>;
+    private testConnectionInBackground;
     serve(): Promise<void>;
     private testConnection;
-    private handleConnectionError;
-    private reconnect;
     disconnect(): Promise<void>;
 }

package/dist/client.js

@@ -30,12 +30,22 @@ const PingSchema = zod_1.z.object({
     method: zod_1.z.literal('ping'),
     params: zod_1.z.object({}).optional()
 });
+const InitializeSchema = zod_1.z.object({
+    method: zod_1.z.literal('initialize'),
+    params: zod_1.z.object({
+        protocolVersion: zod_1.z.string(),
+        capabilities: zod_1.z.object({}).passthrough()
+    })
+});
+const InitializedNotificationSchema = zod_1.z.object({
+    method: zod_1.z.literal('notifications/initialized'),
+    params: zod_1.z.object({}).optional()
+});
 class CelliumMCPClient {
     config;
     localServer;
     isConnected = false;
     reconnectTimer;
-    currentRetryCount = 0;
     constructor(config) {
         this.config = {
             retryAttempts: 3,
@@ -55,57 +65,67 @@ class CelliumMCPClient {
         this.setupServer();
     }
     setupServer() {
-        // Register a dynamic tool handler that forwards all tool calls to remote server
-        this.localServer.registerTool('cellium-proxy-tool', {
-            description: 'Proxy tool for Cellium server - handles all tool calls dynamically'
-        }, async (_args) => {
-            // This won't actually be called since we override the request handlers directly
-            return { content: [{ type: 'text', text: 'Proxy tool' }] };
+        // Handle MCP initialization
+        this.localServer.server.setRequestHandler(InitializeSchema, async (_request) => {
+            this.config.logger.debug('Received initialize request');
+            return {
+                protocolVersion: '2024-11-05',
+                capabilities: {
+                    tools: {},
+                    resources: {}
+                },
+                serverInfo: {
+                    name: 'cellium-mcp-client',
+                    version: '1.1.1'
+                }
+            };
         });
         // Override the underlying server's tool request handlers to proxy to remote
         this.localServer.server.setRequestHandler(ToolsListSchema, async () => {
             this.config.logger.debug('Proxying tools/list to remote server');
-            if (!this.isConnected) {
-                throw new Error('Not connected to remote server');
-            }
             const result = await this.makeHttpRequest('tools/list', {});
             return result;
         });
         this.localServer.server.setRequestHandler(ToolsCallSchema, async (request) => {
             this.config.logger.debug({ toolName: request.params?.name }, 'Proxying tool call to remote server');
-            if (!this.isConnected) {
-                throw new Error('Not connected to remote server');
-            }
             const result = await this.makeHttpRequest('tools/call', request.params);
             return result;
         });
         // Handle resources as well
         this.localServer.server.setRequestHandler(ResourcesListSchema, async () => {
             this.config.logger.debug('Proxying resources/list to remote server');
-            if (!this.isConnected) {
-                throw new Error('Not connected to remote server');
-            }
             const result = await this.makeHttpRequest('resources/list', {});
             return result;
         });
         this.localServer.server.setRequestHandler(ResourcesReadSchema, async (request) => {
             this.config.logger.debug({ uri: request.params?.uri }, 'Proxying resources/read to remote server');
-            if (!this.isConnected) {
-                throw new Error('Not connected to remote server');
-            }
             const result = await this.makeHttpRequest('resources/read', request.params);
             return result;
         });
         // Handle ping
         this.localServer.server.setRequestHandler(PingSchema, async () => {
-            if (!this.isConnected) {
-                throw new Error('Not connected to remote server');
-            }
             const result = await this.makeHttpRequest('ping', {});
             return result;
         });
+        // Handle other common MCP methods
+        this.localServer.server.setNotificationHandler(InitializedNotificationSchema, async () => {
+            this.config.logger.debug('Received initialized notification');
+            // No response needed for notifications
+        });
     }
     async makeHttpRequest(method, params) {
+        // If not connected, try to connect first
+        if (!this.isConnected) {
+            try {
+                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');
+                throw new Error('Cannot connect to remote Cellium server');
+            }
+        }
         const mcpEndpoint = this.config.endpoint.replace('/sse', '/mcp');
         const requestBody = {
             jsonrpc: '2.0',
@@ -134,31 +154,38 @@ class CelliumMCPClient {
         }
         catch (error) {
             this.config.logger.error({ error, method }, '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 }, 'Connecting to Cellium MCP Server');
-            // Test connection with a ping
+            this.config.logger.info({ endpoint: this.config.endpoint }, 'Starting Cellium MCP Server');
+            // Set up the stdio transport for local MCP server immediately
+            const stdioTransport = new stdio_js_1.StdioServerTransport();
+            await this.localServer.connect(stdioTransport);
+            this.config.logger.info('MCP Server connected and ready');
+            // 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');
+            throw error;
+        }
+    }
+    async testConnectionInBackground() {
+        try {
             await this.testConnection();
             this.isConnected = true;
-            this.currentRetryCount = 0;
+            this.config.logger.info('Connected to remote Cellium server');
             if (this.reconnectTimer) {
                 clearTimeout(this.reconnectTimer);
                 this.reconnectTimer = undefined;
             }
-            this.config.logger.info('Connected to remote Cellium server');
-            // Set up the stdio transport for local MCP server
-            const stdioTransport = new stdio_js_1.StdioServerTransport();
-            await this.localServer.connect(stdioTransport);
-            this.config.logger.info('MCP Client connected and ready');
         }
         catch (error) {
-            this.config.logger.error({ error }, 'Failed to connect');
+            this.config.logger.warn({ error }, 'Failed to connect to remote server, will retry on first request');
             this.isConnected = false;
-            this.handleConnectionError();
-            throw error;
         }
     }
     async serve() {
@@ -192,28 +219,6 @@ class CelliumMCPClient {
         }
         this.config.logger.debug('Connection test successful');
     }
-    handleConnectionError() {
-        if (this.currentRetryCount < this.config.retryAttempts) {
-            this.currentRetryCount++;
-            this.config.logger.warn(`Connection failed, retrying in ${this.config.retryDelay}ms (attempt ${this.currentRetryCount}/${this.config.retryAttempts})`);
-            this.reconnectTimer = setTimeout(() => {
-                this.reconnect();
-            }, this.config.retryDelay);
-        }
-        else {
-            this.config.logger.error('Max retry attempts reached, giving up');
-            process.exit(1);
-        }
-    }
-    async reconnect() {
-        try {
-            await this.connect();
-        }
-        catch (error) {
-            this.config.logger.error({ error }, 'Reconnection failed');
-            this.handleConnectionError();
-        }
-    }
     async disconnect() {
         this.config.logger.info('Disconnecting from Cellium MCP Server');
         this.isConnected = false;

package/package.json

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