@goonnguyen/human-mcp 1.2.0 → 1.3.0

package/src/index.ts

@@ -18,6 +18,8 @@ async function main() {
         sessionMode: config.transport.http.sessionMode,
         enableSse: config.transport.http.enableSse,
         enableJsonResponse: config.transport.http.enableJsonResponse,
+        enableSseFallback: config.transport.http.enableSseFallback,
+        ssePaths: config.transport.http.ssePaths,
         security: config.transport.http.security
       } : undefined
     };

package/src/tools/eyes/index.ts

@@ -17,9 +17,9 @@ import type { Config } from "@/utils/config.js";
 export async function registerEyesTool(server: McpServer, config: Config) {
   const geminiClient = new GeminiClient(config);
   
-  // Register eyes.analyze tool
+  // Register eyes_analyze tool
   server.registerTool(
-    "eyes.analyze",
+    "eyes_analyze",
     {
       title: "Vision Analysis Tool",
       description: "Analyze images, videos, and GIFs using AI vision capabilities",
@@ -36,7 +36,7 @@ export async function registerEyesTool(server: McpServer, config: Config) {
         return await handleAnalyze(geminiClient, args, config);
       } catch (error) {
         const mcpError = handleError(error);
-        logger.error(`Tool eyes.analyze error:`, mcpError);
+        logger.error(`Tool eyes_analyze error:`, mcpError);
         
         return {
           content: [{
@@ -49,9 +49,9 @@ export async function registerEyesTool(server: McpServer, config: Config) {
     }
   );
 
-  // Register eyes.compare tool
+  // Register eyes_compare tool
   server.registerTool(
-    "eyes.compare",
+    "eyes_compare",
     {
       title: "Image Comparison Tool", 
       description: "Compare two images and identify differences",
@@ -66,7 +66,7 @@ export async function registerEyesTool(server: McpServer, config: Config) {
         return await handleCompare(geminiClient, args);
       } catch (error) {
         const mcpError = handleError(error);
-        logger.error(`Tool eyes.compare error:`, mcpError);
+        logger.error(`Tool eyes_compare error:`, mcpError);
         
         return {
           content: [{
@@ -173,7 +173,7 @@ Be precise with locations and measurements where possible.`;
       }
     ]);
     
-    const result = await response.response;
+    const result = response.response;
     const comparisonText = result.text();
     
     return {

package/src/tools/eyes/processors/image.ts

@@ -5,6 +5,7 @@ import type { AnalysisOptions, ProcessingResult } from "@/types";
 import { createPrompt, parseAnalysisResponse } from "../utils/formatters.js";
 import { logger } from "@/utils/logger.js";
 import { ProcessingError } from "@/utils/errors.js";
+import { getCloudflareR2 } from "@/utils/cloudflare-r2.js";
 
 export async function processImage(
   model: GenerativeModel,
@@ -58,6 +59,50 @@ export async function processImage(
 }
 
 async function loadImage(source: string, fetchTimeout?: number): Promise<{ imageData: string; mimeType: string }> {
+  // Detect Claude Desktop virtual paths and auto-upload to Cloudflare
+  if (source.startsWith('/mnt/user-data/') || source.startsWith('/mnt/')) {
+    logger.info(`Detected Claude Desktop virtual path: ${source}`);
+    
+    // Extract filename from path
+    const filename = source.split('/').pop() || 'upload.jpg';
+    
+    // Try to read from a temporary upload directory (if middleware saved it)
+    const tempPath = `/tmp/mcp-uploads/${filename}`;
+    
+    try {
+      // Check if file was temporarily saved by middleware
+      if (await fs.access(tempPath).then(() => true).catch(() => false)) {
+        const buffer = await fs.readFile(tempPath);
+        
+        // Upload to Cloudflare R2 if configured
+        const cloudflare = getCloudflareR2();
+        if (cloudflare) {
+          const publicUrl = await cloudflare.uploadFile(buffer, filename);
+          
+          // Clean up temp file
+          await fs.unlink(tempPath).catch(() => {});
+          
+          // Now fetch from the CDN URL
+          return loadImage(publicUrl, fetchTimeout);
+        }
+      }
+    } catch (error) {
+      logger.warn(`Could not process temp file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    
+    // If no temp file or Cloudflare not configured, provide helpful error
+    throw new ProcessingError(
+      `Local file access not supported via HTTP transport.\n` +
+      `The file path "${source}" is not accessible.\n\n` +
+      `Solutions:\n` +
+      `1. Upload your file to Cloudflare R2 first using the /mcp/upload endpoint\n` +
+      `2. Use a public URL instead of a local file path\n` +
+      `3. Convert the image to a base64 data URI\n` +
+      `4. Use the stdio transport for local file access`
+    );
+  }
+  
+  // Existing base64 handling
   if (source.startsWith('data:image/')) {
     const [header, data] = source.split(',');
     if (!header || !data) {
@@ -67,12 +112,27 @@ async function loadImage(source: string, fetchTimeout?: number): Promise<{ image
     if (!mimeMatch || !mimeMatch[1]) {
       throw new ProcessingError("Invalid base64 image format");
     }
+    
+    // Optional: For large base64 images, upload to Cloudflare R2 if configured
+    const cloudflare = getCloudflareR2();
+    if (cloudflare && data.length > 1024 * 1024) { // > 1MB base64
+      logger.info('Large base64 image detected, uploading to Cloudflare R2');
+      try {
+        const publicUrl = await cloudflare.uploadBase64(data, mimeMatch[1]);
+        return loadImage(publicUrl, fetchTimeout);
+      } catch (error) {
+        logger.warn('Failed to upload large base64 to Cloudflare R2:', error);
+        // Continue with base64 processing
+      }
+    }
+    
     return {
       imageData: data,
       mimeType: mimeMatch[1]
     };
   }
   
+  // Existing URL handling
   if (source.startsWith('http://') || source.startsWith('https://')) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), fetchTimeout || 30000);
@@ -106,7 +166,31 @@ async function loadImage(source: string, fetchTimeout?: number): Promise<{ image
     }
   }
   
+  // Local file handling - auto-upload to Cloudflare for HTTP transport
   try {
+    const stats = await fs.stat(source);
+    if (!stats.isFile()) {
+      throw new ProcessingError(`Path is not a file: ${source}`);
+    }
+    
+    // If using HTTP transport, upload to Cloudflare R2 if configured
+    const cloudflare = getCloudflareR2();
+    if (process.env.TRANSPORT_TYPE === 'http' && cloudflare) {
+      logger.info(`HTTP transport detected, uploading local file to Cloudflare R2: ${source}`);
+      try {
+        const buffer = await fs.readFile(source);
+        const filename = source.split('/').pop() || 'upload.jpg';
+        const publicUrl = await cloudflare.uploadFile(buffer, filename);
+        
+        // Fetch from CDN
+        return loadImage(publicUrl, fetchTimeout);
+      } catch (error) {
+        logger.warn(`Failed to upload to Cloudflare R2: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        // Continue with local file processing
+      }
+    }
+    
+    // For stdio transport or when Cloudflare is not configured, process locally
     const buffer = await fs.readFile(source);
     const processedImage = await sharp(buffer)
       .resize(1024, 1024, { fit: 'inside', withoutEnlargement: true })
@@ -118,6 +202,12 @@ async function loadImage(source: string, fetchTimeout?: number): Promise<{ image
       mimeType: 'image/jpeg'
     };
   } catch (error) {
+    if (error instanceof Error && error.message.includes('ENOENT')) {
+      throw new ProcessingError(
+        `File not found: ${source}\n` +
+        `When using HTTP transport, files are automatically uploaded to Cloudflare R2 if configured.`
+      );
+    }
     throw new ProcessingError(`Failed to load image file: ${error instanceof Error ? error.message : 'Unknown error'}`);
   }
 }

package/src/transports/http/file-interceptor.ts

@@ -0,0 +1,134 @@
+import type { Request, Response, NextFunction } from 'express';
+import { getCloudflareR2 } from '@/utils/cloudflare-r2.js';
+import { logger } from '@/utils/logger.js';
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function fileInterceptorMiddleware(
+  req: Request,
+  res: Response,
+  next: NextFunction
+) {
+  // Only intercept tool calls with file paths
+  if (req.body?.method === 'tools/call' && req.body?.params?.arguments) {
+    const args = req.body.params.arguments;
+    
+    // Check for source fields that might contain file paths
+    const fileFields = ['source', 'source1', 'source2', 'path', 'filePath'];
+    
+    for (const field of fileFields) {
+      if (args[field] && typeof args[field] === 'string') {
+        const filePath = args[field];
+        
+        // Detect Claude Desktop virtual paths
+        if (filePath.startsWith('/mnt/user-data/') || filePath.startsWith('/mnt/')) {
+          logger.info(`Intercepting Claude Desktop virtual path: ${filePath}`);
+          
+          try {
+            // Extract filename
+            const filename = path.basename(filePath);
+            
+            // Check if we have a temporary file saved by Claude Desktop
+            const tempPath = path.join('/tmp/claude-uploads', filename);
+            
+            if (await fs.access(tempPath).then(() => true).catch(() => false)) {
+              const cloudflare = getCloudflareR2();
+              if (cloudflare) {
+                // File exists in temp, upload to Cloudflare
+                const buffer = await fs.readFile(tempPath);
+                const publicUrl = await cloudflare.uploadFile(buffer, filename);
+                
+                // Replace the virtual path with CDN URL
+                args[field] = publicUrl;
+                
+                // Clean up temp file
+                await fs.unlink(tempPath).catch(() => {});
+                
+                logger.info(`Replaced virtual path with CDN URL: ${publicUrl}`);
+              }
+            } else {
+              // No temp file, try to extract from request if it's base64
+              // This handles cases where Claude Desktop might send base64 inline
+              if ((req.body.params as any).fileData && (req.body.params as any).fileData[field]) {
+                const base64Data = (req.body.params as any).fileData[field];
+                const mimeType = (req.body.params as any).fileMimeTypes?.[field] || 'image/jpeg';
+                
+                const cloudflare = getCloudflareR2();
+                if (cloudflare) {
+                  const publicUrl = await cloudflare.uploadBase64(
+                    base64Data,
+                    mimeType,
+                    filename
+                  );
+                  
+                  args[field] = publicUrl;
+                  logger.info(`Uploaded inline base64 to CDN: ${publicUrl}`);
+                }
+              } else {
+                // Provide helpful error response
+                logger.warn(`Cannot access virtual path: ${filePath}`);
+                return res.status(400).json({
+                  jsonrpc: '2.0',
+                  error: {
+                    code: -32602,
+                    message: 'File not accessible via HTTP transport',
+                    data: {
+                      path: filePath,
+                      suggestions: [
+                        'Upload the file using the /mcp/upload endpoint first',
+                        'Use a public URL instead of a local file path',
+                        'Convert the image to a base64 data URI',
+                        'Switch to stdio transport for local file access'
+                      ]
+                    }
+                  },
+                  id: req.body.id
+                });
+              }
+            }
+          } catch (error) {
+            logger.error(`Error processing virtual path: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return res.status(500).json({
+              jsonrpc: '2.0',
+              error: {
+                code: -32603,
+                message: `Failed to process file: ${error instanceof Error ? error.message : 'Unknown error'}`
+              },
+              id: req.body.id
+            });
+          }
+        }
+        
+        // Handle regular local paths when in HTTP mode
+        else if (!filePath.startsWith('http') && !filePath.startsWith('data:')) {
+          if (process.env.TRANSPORT_TYPE === 'http') {
+            const cloudflare = getCloudflareR2();
+            if (cloudflare) {
+              try {
+                // Check if file exists locally
+                await fs.access(filePath);
+                
+                // Upload to Cloudflare R2
+                const buffer = await fs.readFile(filePath);
+                const filename = path.basename(filePath);
+                const publicUrl = await cloudflare.uploadFile(buffer, filename);
+                
+                // Replace local path with CDN URL
+                args[field] = publicUrl;
+                
+                logger.info(`Auto-uploaded local file to CDN: ${publicUrl}`);
+              } catch (error) {
+                if (error instanceof Error && error.message.includes('ENOENT')) {
+                  logger.warn(`Local file not found: ${filePath}`);
+                }
+                // Continue without modification if file doesn't exist or cloudflare not configured
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  next();
+}

package/src/transports/http/routes.ts

@@ -1,15 +1,23 @@
 import { Router } from "express";
-import { randomUUID } from "node:crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { SessionManager } from "./session.js";
 import type { HttpTransportConfig } from "../types.js";
+import multer from 'multer';
+import { getCloudflareR2 } from '@/utils/cloudflare-r2.js';
+import { logger } from '@/utils/logger.js';
+
+// Interface for SSE session checking (to avoid circular dependency)
+interface SSESessionChecker {
+  hasSession(sessionId: string): boolean;
+}
 
 export function createRoutes(
   mcpServer: McpServer,
   sessionManager: SessionManager,
-  config: HttpTransportConfig
+  config: HttpTransportConfig,
+  sseSessionChecker?: SSESessionChecker
 ): Router {
   const router = Router();
 
@@ -21,7 +29,7 @@ export function createRoutes(
       if (config.sessionMode === 'stateless') {
         await handleStatelessRequest(mcpServer, req, res);
       } else {
-        await handleStatefulRequest(mcpServer, sessionManager, sessionId, req, res);
+        await handleStatefulRequest(mcpServer, sessionManager, sessionId, req, res, sseSessionChecker);
       }
     } catch (error) {
       handleError(res, error);
@@ -72,6 +80,145 @@ export function createRoutes(
     res.status(204).send();
   });
 
+  // Configure multer for memory storage
+  const upload = multer({
+    storage: multer.memoryStorage(),
+    limits: {
+      fileSize: 100 * 1024 * 1024, // 100MB limit
+    },
+    fileFilter: (req, file, cb) => {
+      // Accept images, videos, and GIFs
+      if (file.mimetype.startsWith('image/') || 
+          file.mimetype.startsWith('video/') ||
+          file.mimetype === 'image/gif') {
+        cb(null, true);
+      } else {
+        cb(new Error('Invalid file type. Only images and videos are allowed.'));
+      }
+    }
+  });
+
+  // POST /upload - Handle file uploads to Cloudflare R2
+  router.post('/upload', upload.single('file'), async (req, res) => {
+    try {
+      if (!req.file) {
+        res.status(400).json({
+          jsonrpc: '2.0',
+          error: {
+            code: -32600,
+            message: 'No file uploaded'
+          },
+          id: null
+        });
+        return;
+      }
+
+      const cloudflare = getCloudflareR2();
+      if (!cloudflare) {
+        res.status(500).json({
+          jsonrpc: '2.0',
+          error: {
+            code: -32603,
+            message: 'Cloudflare R2 not configured. Please set up environment variables.'
+          },
+          id: null
+        });
+        return;
+      }
+      
+      // Upload to Cloudflare R2
+      const publicUrl = await cloudflare.uploadFile(
+        req.file.buffer,
+        req.file.originalname
+      );
+      
+      res.json({
+        jsonrpc: '2.0',
+        result: {
+          success: true,
+          url: publicUrl,
+          originalName: req.file.originalname,
+          size: req.file.size,
+          mimeType: req.file.mimetype,
+          message: 'File uploaded successfully to Cloudflare R2'
+        },
+        id: (req.body as any)?.id || null
+      });
+    } catch (error) {
+      logger.error('Upload error:', error);
+      res.status(500).json({
+        jsonrpc: '2.0',
+        error: {
+          code: -32603,
+          message: `Failed to upload file: ${error instanceof Error ? error.message : 'Unknown error'}`
+        },
+        id: (req.body as any)?.id || null
+      });
+    }
+  });
+
+  // POST /upload-base64 - Handle base64 uploads
+  router.post('/upload-base64', async (req, res) => {
+    try {
+      const { data, mimeType, filename } = req.body;
+      
+      if (!data || !mimeType) {
+        res.status(400).json({
+          jsonrpc: '2.0',
+          error: {
+            code: -32600,
+            message: 'Missing required fields: data and mimeType'
+          },
+          id: null
+        });
+        return;
+      }
+
+      const cloudflare = getCloudflareR2();
+      if (!cloudflare) {
+        res.status(500).json({
+          jsonrpc: '2.0',
+          error: {
+            code: -32603,
+            message: 'Cloudflare R2 not configured. Please set up environment variables.'
+          },
+          id: null
+        });
+        return;
+      }
+      
+      // Remove data URI prefix if present
+      const base64Data = data.replace(/^data:.*?;base64,/, '');
+      
+      // Upload to Cloudflare R2
+      const publicUrl = await cloudflare.uploadBase64(
+        base64Data,
+        mimeType,
+        filename
+      );
+      
+      res.json({
+        jsonrpc: '2.0',
+        result: {
+          success: true,
+          url: publicUrl,
+          message: 'Base64 data uploaded successfully to Cloudflare R2'
+        },
+        id: req.body?.id || null
+      });
+    } catch (error) {
+      logger.error('Base64 upload error:', error);
+      res.status(500).json({
+        jsonrpc: '2.0',
+        error: {
+          code: -32603,
+          message: `Failed to upload base64 data: ${error instanceof Error ? error.message : 'Unknown error'}`
+        },
+        id: req.body?.id || null
+      });
+    }
+  });
+
   return router;
 }
 
@@ -97,8 +244,22 @@ async function handleStatefulRequest(
   sessionManager: SessionManager,
   sessionId: string | undefined,
   req: any,
-  res: any
+  res: any,
+  sseSessionChecker?: SSESessionChecker
 ): Promise<void> {
+  // Check if sessionId is being used by SSE transport
+  if (sessionId && sseSessionChecker?.hasSession(sessionId)) {
+    res.status(400).json({
+      jsonrpc: '2.0',
+      error: {
+        code: -32600,
+        message: 'Session ID is already in use by SSE transport',
+      },
+      id: null,
+    });
+    return;
+  }
+
   let transport = sessionId ? 
     await sessionManager.getTransport(sessionId) : null;
 

package/src/transports/http/server.ts

@@ -4,14 +4,16 @@ import compression from "compression";
 import helmet from "helmet";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { createRoutes } from "./routes.js";
+import { createSSERoutes } from "./sse-routes.js";
 import { SessionManager } from "./session.js";
 import { createSecurityMiddleware } from "./middleware.js";
-import type { HttpTransportConfig } from "../types.js";
+import { fileInterceptorMiddleware } from "./file-interceptor.js";
+import type { HttpTransportConfig, HttpServerHandle } from "../types.js";
 
 export async function startHttpTransport(
   mcpServer: McpServer,
   config: HttpTransportConfig
-): Promise<void> {
+): Promise<HttpServerHandle> {
   const app = express();
   const sessionManager = new SessionManager(config.sessionMode, config);
 
@@ -27,40 +29,88 @@ export async function startHttpTransport(
     app.use(cors({
       origin: config.security?.corsOrigins || '*',
       exposedHeaders: ['Mcp-Session-Id'],
-      allowedHeaders: ['Content-Type', 'mcp-session-id'],
+      allowedHeaders: ['Content-Type', 'mcp-session-id', 'Authorization'],
       credentials: true
     }));
   }
 
   app.use(createSecurityMiddleware(config.security));
+  
+  // Add file interceptor middleware before routes
+  app.use(fileInterceptorMiddleware);
+
+  // Create SSE routes first if enabled to get SSE manager reference
+  let sseManager: any = undefined;
+  if (config.enableSseFallback) {
+    console.log('Enabling SSE fallback transport');
+    const sseRoutes = createSSERoutes(mcpServer, config, sessionManager);
+    app.use(sseRoutes);
+    
+    // Store SSE manager reference for cleanup and cross-validation
+    sseManager = (sseRoutes as any).sseManager;
+    (app as any).sseManager = sseManager;
+  }
 
-  // Create routes
-  const routes = createRoutes(mcpServer, sessionManager, config);
+  // Create routes with SSE session checker
+  const routes = createRoutes(mcpServer, sessionManager, config, sseManager);
   app.use('/mcp', routes);
 
   // Health check endpoint
   app.get('/health', (req, res) => {
-    res.json({ status: 'healthy', transport: 'streamable-http' });
+    const healthStatus: any = { 
+      status: 'healthy', 
+      transport: 'streamable-http' 
+    };
+    
+    if (config.enableSseFallback) {
+      healthStatus.sseFallback = 'enabled';
+      healthStatus.ssePaths = config.ssePaths;
+    }
+    
+    res.json(healthStatus);
   });
 
   // Start server
   const port = config.port || 3000;
   const host = config.host || '0.0.0.0';
   
-  app.listen(port, host, () => {
+  const server = app.listen(port, host, () => {
     console.log(`MCP HTTP Server listening on http://${host}:${port}`);
     console.log(`Health check: http://${host}:${port}/health`);
     console.log(`MCP endpoint: http://${host}:${port}/mcp`);
   });
 
-  // Graceful shutdown handling
-  process.on('SIGTERM', async () => {
+  // Create cleanup function
+  const cleanup = async () => {
     console.log('Shutting down HTTP server...');
     await sessionManager.cleanup();
-  });
+    
+    // Cleanup SSE sessions if enabled
+    if (config.enableSseFallback && (app as any).sseManager) {
+      await (app as any).sseManager.cleanup();
+    }
+  };
 
-  process.on('SIGINT', async () => {
-    console.log('Shutting down HTTP server...');
-    await sessionManager.cleanup();
-  });
+  // Graceful shutdown handling
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+
+  // Return server handle
+  const handle: HttpServerHandle = {
+    app,
+    server,
+    sessionManager,
+    sseManager,
+    async close() {
+      await cleanup();
+      return new Promise<void>((resolve, reject) => {
+        server.close((err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    }
+  };
+
+  return handle;
 }

package/src/transports/http/session.ts

@@ -63,8 +63,11 @@ export class SessionManager {
   async terminateSession(sessionId: string): Promise<void> {
     const transport = this.transports.get(sessionId);
     if (transport) {
-      transport.close();
+      // Remove from map first to prevent circular cleanup
       this.transports.delete(sessionId);
+      // Clear the onclose handler to prevent recursion
+      transport.onclose = undefined;
+      transport.close();
     }
     
     if (this.store) {
@@ -73,10 +76,15 @@ export class SessionManager {
   }
 
   async cleanup(): Promise<void> {
-    for (const [sessionId, transport] of this.transports) {
+    // Create a copy of the map entries to avoid modification during iteration
+    const transportEntries = Array.from(this.transports.entries());
+    this.transports.clear();
+    
+    for (const [sessionId, transport] of transportEntries) {
+      // Clear the onclose handler to prevent recursion during cleanup
+      transport.onclose = undefined;
       transport.close();
     }
-    this.transports.clear();
     
     if (this.store) {
       await this.store.cleanup();