@descix/cli 1.0.0

package/vendor/mcp/transports/http-sse-transport.js

@@ -0,0 +1,196 @@
+/**
+ * HTTP+SSE Transport for MCP Server
+ * 
+ * Handles JSON-RPC 2.0 over HTTP POST with SSE for streaming
+ * Used by remote MCP clients like ChatGPT, web-based agents
+ * 
+ * Authentication: X-DeSciX-Signature header (wallet signature as API key)
+ */
+
+import { User } from '../../../descix-cli/lib/api-client.js';
+
+export class HttpSseTransport {
+    constructor(mcpServer, options = {}) {
+        this.mcpServer = mcpServer;
+        this.options = options;
+        this.apiClient = options.apiClient || null;
+    }
+
+    /**
+     * Create Express middleware for MCP HTTP endpoint
+     * @returns {Function} Express middleware
+     */
+    createMiddleware() {
+        return async (req, res, next) => {
+            // Handle MCP JSON-RPC requests
+            if (req.method !== 'POST') {
+                return res.status(405).json({
+                    jsonrpc: '2.0',
+                    id: null,
+                    error: { code: -32600, message: 'Only POST requests are supported' }
+                });
+            }
+
+            try {
+                // Extract and validate signature-based auth
+                const signature = this.extractSignature(req);
+                let walletInfo = null;
+                let user = null;
+
+                if (signature) {
+                    // Authenticate via API signature (O(1) lookup)
+                    const authResult = await this.authenticateBySignature(signature);
+                    if (authResult) {
+                        user = authResult.user;
+                        walletInfo = {
+                            userId: user.id,
+                            walletAddress: user.wallet_address,
+                            signatureId: authResult.signatureRecord.id,
+                            permissions: authResult.signatureRecord.permissions,
+                            communities: authResult.signatureRecord.communities
+                        };
+                    }
+                }
+
+                // Handle the MCP request
+                const request = req.body;
+                const response = await this.mcpServer.handleRequest(request, user, walletInfo);
+
+                // Only send response if it's not a notification
+                if (response !== null) {
+                    res.json(response);
+                } else {
+                    res.status(204).end();
+                }
+            } catch (error) {
+                console.error('[MCP:HTTP] Error handling request:', error.message);
+                res.status(500).json({
+                    jsonrpc: '2.0',
+                    id: req.body?.id || null,
+                    error: {
+                        code: -32603,
+                        message: 'Internal error',
+                        data: error.message
+                    }
+                });
+            }
+        };
+    }
+
+    /**
+     * Create SSE endpoint for streaming responses
+     * @returns {Function} Express middleware for SSE
+     */
+    createSseMiddleware() {
+        return async (req, res, next) => {
+            // Set SSE headers
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            res.setHeader('X-Accel-Buffering', 'no');
+
+            // Extract signature for auth
+            const signature = this.extractSignature(req);
+            let walletInfo = null;
+
+            if (signature) {
+                const authResult = await this.authenticateBySignature(signature);
+                if (authResult) {
+                    walletInfo = {
+                        userId: authResult.user.id,
+                        walletAddress: authResult.user.wallet_address,
+                        signatureId: authResult.signatureRecord.id,
+                        permissions: authResult.signatureRecord.permissions
+                    };
+                }
+            }
+
+            // Send initial connection event
+            res.write(`event: connected\ndata: ${JSON.stringify({ status: 'connected' })}\n\n`);
+
+            // Store connection info for potential use
+            req.mcpConnection = {
+                walletInfo,
+                sendEvent: (event, data) => {
+                    res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+                }
+            };
+
+            // Handle client disconnect
+            req.on('close', () => {
+                console.error('[MCP:SSE] Client disconnected');
+            });
+
+            // Keep connection alive with heartbeat
+            const heartbeat = setInterval(() => {
+                res.write(`: heartbeat\n\n`);
+            }, 30000);
+
+            req.on('close', () => {
+                clearInterval(heartbeat);
+            });
+        };
+    }
+
+    /**
+     * Extract signature from request
+     * Supports header: X-DeSciX-Signature or Authorization: Bearer <signature>
+     */
+    extractSignature(req) {
+        // Check X-DeSciX-Signature header
+        const sigHeader = req.headers['x-descix-signature'];
+        if (sigHeader) return sigHeader;
+
+        // Check Authorization header
+        const authHeader = req.headers['authorization'];
+        if (authHeader && authHeader.startsWith('Signature ')) {
+            return authHeader.substring(10);
+        }
+
+        // Check query param (for SSE)
+        if (req.query?.signature) {
+            return req.query.signature;
+        }
+
+        return null;
+    }
+
+    /**
+     * Authenticate by signature via /apifront/
+     * @param {string} signature - Wallet signature
+     * @returns {Promise<{user, signatureRecord}|null>}
+     */
+    async authenticateBySignature(signature) {
+        if (!this.apiClient) {
+            console.error('[MCP:HTTP] No API client configured for signature auth');
+            return null;
+        }
+
+        try {
+            const result = await this.apiClient.invoke('authenticate_by_signature', {
+                signature
+            }, { allowGuest: true });
+
+            if (result?.success) {
+                return {
+                    user: { id: result.user_id },
+                    signatureRecord: {
+                        id: result.signature_id,
+                        name: result.signature_name,
+                        permissions: result.permissions,
+                        communities: result.communities
+                    }
+                };
+            }
+        } catch (error) {
+            console.error('[MCP:HTTP] Signature auth failed:', error.message);
+        }
+
+        return null;
+    }
+}
+
+export default HttpSseTransport;
+
+
+

package/vendor/mcp/transports/index.js

@@ -0,0 +1,15 @@
+/**
+ * MCP Transport Layer
+ * 
+ * Provides pluggable transport implementations for the DeSciX MCP Server:
+ * - StdioTransport: For CLI-based clients (Cursor, VS Code, Claude Desktop)
+ * - HttpSseTransport: For remote HTTP clients (ChatGPT, web agents)
+ * 
+ * All transports use the same DeSciXMCPServer core with HTTP-only API calls.
+ */
+
+export { StdioTransport } from './stdio-transport.js';
+export { HttpSseTransport } from './http-sse-transport.js';
+
+
+

package/vendor/mcp/transports/stdio-transport.js

@@ -0,0 +1,118 @@
+/**
+ * Stdio Transport for MCP Server
+ * 
+ * Uses the official @modelcontextprotocol/sdk for proper protocol handling.
+ * This wrapper bridges our DeSciXMCPServer with the official SDK's transport.
+ */
+
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+/**
+ * StdioTransport - bridges DeSciXMCPServer to official MCP SDK transport
+ * 
+ * Note: This is a thin wrapper. The actual MCP server should use the
+ * official Server class from @modelcontextprotocol/sdk for full compatibility.
+ */
+export class StdioTransport {
+    constructor(mcpServer, options = {}) {
+        this.mcpServer = mcpServer;
+        this.options = options;
+        this.walletInfo = options.walletInfo || null;
+        this.transport = null;
+    }
+
+    /**
+     * Start the stdio transport using official SDK
+     */
+    async start() {
+        console.error('[MCP:Stdio] Starting with official MCP SDK transport...');
+        
+        // Create the official stdio transport
+        this.transport = new StdioServerTransport();
+        
+        // The transport handles the protocol - we need to connect it to our server
+        // This is a temporary bridge until we fully migrate to the SDK's Server class
+        console.error('[MCP:Stdio] Transport created, delegating to MCP server...');
+        
+        // For now, we'll use manual message handling since our server has custom logic
+        // The official SDK uses a different architecture (Server class with handlers)
+        
+        // Import readline for manual handling until full SDK migration
+        const readline = await import('readline');
+        
+        const rl = readline.createInterface({
+            input: process.stdin,
+            terminal: false
+        });
+
+        console.error('[MCP:Stdio] Transport ready, waiting for JSON-RPC requests...');
+
+        rl.on('line', async (line) => {
+            if (!line.trim()) return;
+            
+            try {
+                const request = JSON.parse(line);
+                console.error(`[MCP:Stdio] << ${request.method || 'unknown'} (id: ${request.id})`);
+                
+                const response = await this.mcpServer.handleRequest(request, null, this.walletInfo);
+                
+                if (response !== null) {
+                    const json = JSON.stringify(response);
+                    console.error(`[MCP:Stdio] >> Response (id: ${response.id}, ${json.length} bytes)`);
+                    // Write to stdout with explicit flush
+                    process.stdout.write(json + '\n', () => {
+                        // Callback after write completes
+                    });
+                }
+            } catch (error) {
+                console.error('[MCP:Stdio] Parse error:', error.message);
+                const errorResponse = {
+                    jsonrpc: '2.0',
+                    id: null,
+                    error: {
+                        code: -32700,
+                        message: 'Parse error',
+                        data: error.message
+                    }
+                };
+                process.stdout.write(JSON.stringify(errorResponse) + '\n');
+            }
+        });
+
+        rl.on('close', () => {
+            console.error('[MCP:Stdio] Transport closed');
+        });
+
+        // Keep process alive
+        return new Promise((resolve) => {
+            rl.on('close', resolve);
+            process.on('SIGINT', () => {
+                rl.close();
+                resolve();
+            });
+            process.on('SIGTERM', () => {
+                rl.close();
+                resolve();
+            });
+        });
+    }
+
+    /**
+     * Stop the transport
+     */
+    stop() {
+        console.error('[MCP:Stdio] Transport stopped');
+    }
+
+    /**
+     * Update wallet info
+     */
+    setWalletInfo(walletInfo) {
+        this.walletInfo = walletInfo;
+    }
+}
+
+export default StdioTransport;
+
+
+