@goonnguyen/human-mcp 1.3.0 → 2.0.0

package/src/tools/eyes/utils/gemini-client.ts

@@ -1,73 +0,0 @@
-import { GoogleGenerativeAI, GenerativeModel } from "@google/generative-ai";
-import type { Config } from "@/utils/config";
-import { logger } from "@/utils/logger";
-import { APIError } from "@/utils/errors";
-
-export class GeminiClient {
-  private genAI: GoogleGenerativeAI;
-  
-  constructor(private config: Config) {
-    if (!config.gemini.apiKey) {
-      throw new APIError("Google Gemini API key is required");
-    }
-    this.genAI = new GoogleGenerativeAI(config.gemini.apiKey);
-  }
-  
-  getModel(detailLevel: "quick" | "detailed"): GenerativeModel {
-    const modelName = detailLevel === "detailed" 
-      ? this.config.gemini.model
-      : "gemini-2.5-flash";
-    
-    return this.genAI.getGenerativeModel({ 
-      model: modelName,
-      generationConfig: {
-        temperature: 0.1,
-        topK: 1,
-        topP: 0.95,
-        maxOutputTokens: 8192,
-      }
-    });
-  }
-  
-  async analyzeContent(
-    model: GenerativeModel,
-    prompt: string,
-    mediaData: Array<{ mimeType: string; data: string }>
-  ): Promise<string> {
-    try {
-      logger.debug(`Analyzing content with ${mediaData.length} media files`);
-      
-      const parts = [
-        { text: prompt },
-        ...mediaData.map(media => ({
-          inlineData: {
-            mimeType: media.mimeType,
-            data: media.data
-          }
-        }))
-      ];
-      
-      // Add timeout wrapper
-      const analysisPromise = model.generateContent(parts);
-      const timeoutPromise = new Promise<never>((_, reject) => {
-        setTimeout(() => reject(new APIError("Gemini API request timed out")), this.config.server.requestTimeout);
-      });
-      
-      const result = await Promise.race([analysisPromise, timeoutPromise]);
-      const response = await result.response;
-      const text = response.text();
-      
-      if (!text) {
-        throw new APIError("No response from Gemini API");
-      }
-      
-      return text;
-    } catch (error) {
-      logger.error("Gemini API error:", error);
-      if (error instanceof Error) {
-        throw new APIError(`Gemini API error: ${error.message}`);
-      }
-      throw new APIError("Unknown Gemini API error");
-    }
-  }
-}

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

@@ -1,134 +0,0 @@
-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/middleware.ts

@@ -1,46 +0,0 @@
-import type { Request, Response, NextFunction } from "express";
-import type { SecurityConfig } from "../types.js";
-
-export function createSecurityMiddleware(config?: SecurityConfig) {
-  return async (req: Request, res: Response, next: NextFunction) => {
-    // DNS Rebinding Protection
-    if (config?.enableDnsRebindingProtection) {
-      const host = req.headers.host?.split(':')[0];
-      const allowedHosts = config.allowedHosts || ['127.0.0.1', 'localhost'];
-      
-      if (host && !allowedHosts.includes(host)) {
-        res.status(403).json({
-          error: 'Forbidden: Invalid host'
-        });
-        return;
-      }
-    }
-
-    // Rate Limiting (basic implementation)
-    if (config?.enableRateLimiting) {
-      // Implement rate limiting logic here
-      // Could use express-rate-limit package
-    }
-
-    // Secret-based authentication (optional)
-    if (config?.secret) {
-      const authHeader = req.headers.authorization;
-      if (!authHeader || !authHeader.startsWith('Bearer ')) {
-        res.status(401).json({
-          error: 'Unauthorized: Missing authentication'
-        });
-        return;
-      }
-      
-      const token = authHeader.substring(7);
-      if (token !== config.secret) {
-        res.status(401).json({
-          error: 'Unauthorized: Invalid token'
-        });
-        return;
-      }
-    }
-
-    next();
-  };
-}

package/src/transports/http/routes.ts

@@ -1,297 +0,0 @@
-import { Router } from "express";
-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,
-  sseSessionChecker?: SSESessionChecker
-): Router {
-  const router = Router();
-
-  // POST /mcp - Handle client requests
-  router.post('/', async (req, res) => {
-    try {
-      const sessionId = req.headers['mcp-session-id'] as string | undefined;
-      
-      if (config.sessionMode === 'stateless') {
-        await handleStatelessRequest(mcpServer, req, res);
-      } else {
-        await handleStatefulRequest(mcpServer, sessionManager, sessionId, req, res, sseSessionChecker);
-      }
-    } catch (error) {
-      handleError(res, error);
-    }
-  });
-
-  // GET /mcp - SSE endpoint for notifications
-  router.get('/', async (req, res) => {
-    if (config.sessionMode === 'stateless') {
-      res.status(405).json({
-        jsonrpc: "2.0",
-        error: {
-          code: -32000,
-          message: "SSE not supported in stateless mode"
-        },
-        id: null
-      });
-      return;
-    }
-
-    const sessionId = req.headers['mcp-session-id'] as string;
-    const transport = await sessionManager.getTransport(sessionId);
-    
-    if (!transport) {
-      res.status(400).send('Invalid or missing session ID');
-      return;
-    }
-
-    await transport.handleRequest(req, res);
-  });
-
-  // DELETE /mcp - Session termination
-  router.delete('/', async (req, res) => {
-    if (config.sessionMode === 'stateless') {
-      res.status(405).json({
-        jsonrpc: "2.0",
-        error: {
-          code: -32000,
-          message: "Session termination not applicable in stateless mode"
-        },
-        id: null
-      });
-      return;
-    }
-
-    const sessionId = req.headers['mcp-session-id'] as string;
-    await sessionManager.terminateSession(sessionId);
-    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;
-}
-
-async function handleStatelessRequest(
-  mcpServer: McpServer,
-  req: any,
-  res: any
-): Promise<void> {
-  const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: undefined,
-  });
-
-  res.on('close', () => {
-    transport.close();
-  });
-
-  await mcpServer.connect(transport);
-  await transport.handleRequest(req, res, req.body);
-}
-
-async function handleStatefulRequest(
-  mcpServer: McpServer,
-  sessionManager: SessionManager,
-  sessionId: string | undefined,
-  req: 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;
-
-  if (!transport && isInitializeRequest(req.body)) {
-    const session = await sessionManager.createSession(mcpServer);
-    transport = session.transport;
-    res.setHeader('Mcp-Session-Id', session.sessionId);
-  } else if (!transport) {
-    res.status(400).json({
-      jsonrpc: '2.0',
-      error: {
-        code: -32000,
-        message: 'Bad Request: No valid session ID provided',
-      },
-      id: null,
-    });
-    return;
-  }
-
-  await transport.handleRequest(req, res, req.body);
-}
-
-function handleError(res: any, error: any): void {
-  console.error('MCP request error:', error);
-  if (!res.headersSent) {
-    res.status(500).json({
-      jsonrpc: '2.0',
-      error: {
-        code: -32603,
-        message: 'Internal server error',
-      },
-      id: null,
-    });
-  }
-}

package/src/transports/http/server.ts

@@ -1,116 +0,0 @@
-import express from "express";
-import cors from "cors";
-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 { fileInterceptorMiddleware } from "./file-interceptor.js";
-import type { HttpTransportConfig, HttpServerHandle } from "../types.js";
-
-export async function startHttpTransport(
-  mcpServer: McpServer,
-  config: HttpTransportConfig
-): Promise<HttpServerHandle> {
-  const app = express();
-  const sessionManager = new SessionManager(config.sessionMode, config);
-
-  // Apply middleware
-  app.use(express.json({ limit: '50mb' }));
-  app.use(compression());
-  app.use(helmet({
-    contentSecurityPolicy: false, // Disable CSP for API server
-    crossOriginEmbedderPolicy: false
-  }));
-  
-  if (config.security?.enableCors !== false) {
-    app.use(cors({
-      origin: config.security?.corsOrigins || '*',
-      exposedHeaders: ['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 with SSE session checker
-  const routes = createRoutes(mcpServer, sessionManager, config, sseManager);
-  app.use('/mcp', routes);
-
-  // Health check endpoint
-  app.get('/health', (req, res) => {
-    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';
-  
-  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`);
-  });
-
-  // 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();
-    }
-  };
-
-  // 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;
-}