@goonnguyen/human-mcp 1.3.0 → 2.0.0

package/src/transports/http/session.ts

@@ -1,93 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import type { SessionStore, TransportSession, HttpTransportConfig } from "../types.js";
-
-export class SessionManager {
-  private transports: Map<string, StreamableHTTPServerTransport>;
-  private sessionMode: 'stateful' | 'stateless';
-  private store?: SessionStore;
-  private config: HttpTransportConfig;
-
-  constructor(sessionMode: 'stateful' | 'stateless', config: HttpTransportConfig, store?: SessionStore) {
-    this.transports = new Map();
-    this.sessionMode = sessionMode;
-    this.config = config;
-    this.store = store;
-  }
-
-  async createSession(mcpServer: McpServer): Promise<{ transport: StreamableHTTPServerTransport, sessionId: string }> {
-    const sessionId = randomUUID();
-    
-    const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => sessionId,
-      enableJsonResponse: this.config.enableJsonResponse,
-      enableDnsRebindingProtection: this.config.security?.enableDnsRebindingProtection ?? true,
-      allowedHosts: this.config.security?.allowedHosts ?? ['127.0.0.1', 'localhost'],
-    });
-
-    // Store the transport by the generated session ID
-    this.transports.set(sessionId, transport);
-    
-    transport.onclose = () => {
-      this.terminateSession(sessionId);
-    };
-
-    if (this.store) {
-      await this.store.set(sessionId, {
-        id: sessionId,
-        createdAt: Date.now(),
-        transport: transport
-      });
-    }
-
-    await mcpServer.connect(transport);
-    
-    return { transport, sessionId };
-  }
-
-  async getTransport(sessionId: string): Promise<StreamableHTTPServerTransport | null> {
-    let transport = this.transports.get(sessionId);
-    
-    if (!transport && this.store) {
-      const session = await this.store.get(sessionId);
-      if (session && session.transport) {
-        transport = session.transport;
-        this.transports.set(sessionId, transport);
-      }
-    }
-    
-    return transport || null;
-  }
-
-  async terminateSession(sessionId: string): Promise<void> {
-    const transport = this.transports.get(sessionId);
-    if (transport) {
-      // 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) {
-      await this.store.delete(sessionId);
-    }
-  }
-
-  async cleanup(): Promise<void> {
-    // 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();
-    }
-    
-    if (this.store) {
-      await this.store.cleanup();
-    }
-  }
-}

package/src/transports/http/sse-routes.ts

@@ -1,210 +0,0 @@
-import { Router } from "express";
-import type { Request, Response } from "express";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import type { HttpTransportConfig } from "../types.js";
-import type { SessionManager } from "./session.js";
-
-interface SSESession {
-  transport: SSEServerTransport;
-  createdAt: number;
-}
-
-export class SSEManager {
-  private sessions = new Map<string, SSESession>();
-
-  constructor(private config: HttpTransportConfig) {}
-
-  hasSession(sessionId: string): boolean {
-    return this.sessions.has(sessionId);
-  }
-
-  createSession(endpoint: string, res: Response): SSEServerTransport {
-    const transport = new SSEServerTransport(endpoint, res, {
-      allowedHosts: this.config.security?.allowedHosts,
-      allowedOrigins: this.config.security?.corsOrigins,
-      enableDnsRebindingProtection: this.config.security?.enableDnsRebindingProtection
-    });
-
-    const session: SSESession = {
-      transport,
-      createdAt: Date.now()
-    };
-
-    this.sessions.set(transport.sessionId, session);
-
-    // Cleanup on close
-    transport.onclose = () => {
-      this.sessions.delete(transport.sessionId);
-      console.log(`SSE session ${transport.sessionId} closed`);
-    };
-
-    transport.onerror = (error) => {
-      console.error(`SSE session ${transport.sessionId} error:`, error);
-      this.sessions.delete(transport.sessionId);
-    };
-
-    console.log(`SSE session ${transport.sessionId} created`);
-    return transport;
-  }
-
-  getSession(sessionId: string): SSEServerTransport | null {
-    const session = this.sessions.get(sessionId);
-    return session?.transport || null;
-  }
-
-  async cleanup(): Promise<void> {
-    const promises = Array.from(this.sessions.values()).map(session => 
-      session.transport.close()
-    );
-    await Promise.all(promises);
-    this.sessions.clear();
-  }
-
-  getSessionCount(): number {
-    return this.sessions.size;
-  }
-}
-
-export function createSSERoutes(
-  mcpServer: McpServer,
-  config: HttpTransportConfig,
-  streamableSessionManager: SessionManager
-): Router {
-  const router = Router();
-  const sseManager = new SSEManager(config);
-
-  if (!config.ssePaths) {
-    throw new Error("SSE paths configuration is required");
-  }
-
-  const { stream: streamPath, message: messagePath } = config.ssePaths;
-
-  // Guard against stateless mode
-  const checkStatefulMode = (req: Request, res: Response, next: any) => {
-    if (config.sessionMode === 'stateless') {
-      return res.status(405).json({
-        jsonrpc: "2.0",
-        error: {
-          code: -32600,
-          message: "SSE endpoints not available in stateless mode"
-        },
-        id: null
-      });
-    }
-    next();
-  };
-
-  // GET /sse - Establish SSE connection
-  router.get(streamPath, checkStatefulMode, async (req: Request, res: Response) => {
-    try {
-      console.log('SSE connection request received');
-      
-      // Set SSE headers
-      res.setHeader('Content-Type', 'text/event-stream');
-      res.setHeader('Cache-Control', 'no-cache');
-      res.setHeader('Connection', 'keep-alive');
-      
-      // Set CORS headers for SSE if CORS is enabled
-      if (config.security?.enableCors !== false) {
-        res.setHeader('Access-Control-Allow-Origin', 
-          config.security?.corsOrigins?.join(',') || '*');
-        res.setHeader('Access-Control-Allow-Credentials', 'true');
-        res.setHeader('Access-Control-Expose-Headers', 'Mcp-Session-Id');
-      }
-      
-      const baseUrl = `${req.protocol}://${req.get('host')}`;
-      const messageEndpoint = `${baseUrl}${messagePath}`;
-      
-      const transport = sseManager.createSession(messageEndpoint, res);
-      
-      // Connect transport to MCP server
-      await mcpServer.connect(transport);
-      
-      // Start the SSE stream
-      await transport.start();
-      
-      // Set up cleanup on connection close
-      res.on('close', () => {
-        transport.close();
-      });
-      
-    } catch (error) {
-      console.error('Error establishing SSE connection:', error);
-      if (!res.headersSent) {
-        res.status(500).json({
-          jsonrpc: "2.0",
-          error: {
-            code: -32603,
-            message: "Internal error establishing SSE connection"
-          },
-          id: null
-        });
-      }
-    }
-  });
-
-  // POST /messages - Handle incoming messages
-  router.post(messagePath, checkStatefulMode, async (req: Request, res: Response) => {
-    try {
-      const sessionId = req.query.sessionId as string;
-      
-      if (!sessionId) {
-        return res.status(400).json({
-          jsonrpc: "2.0",
-          error: {
-            code: -32600,
-            message: "Missing sessionId query parameter"
-          },
-          id: null
-        });
-      }
-
-      // Check if sessionId is being used by streamable HTTP transport
-      const streamableTransport = await streamableSessionManager.getTransport(sessionId);
-      if (streamableTransport) {
-        return res.status(400).json({
-          jsonrpc: "2.0",
-          error: {
-            code: -32600,
-            message: "Session ID is already in use by streamable HTTP transport"
-          },
-          id: null
-        });
-      }
-
-      const transport = sseManager.getSession(sessionId);
-      if (!transport) {
-        return res.status(400).json({
-          jsonrpc: "2.0",
-          error: {
-            code: -32600,
-            message: `No active SSE session found for sessionId: ${sessionId}`
-          },
-          id: null
-        });
-      }
-
-      // Forward the message to the transport
-      await transport.handlePostMessage(req, res, req.body);
-      
-    } catch (error) {
-      console.error('Error handling SSE message:', error);
-      if (!res.headersSent) {
-        res.status(500).json({
-          jsonrpc: "2.0",
-          error: {
-            code: -32603,
-            message: "Internal error processing message"
-          },
-          id: null
-        });
-      }
-    }
-  });
-
-  // Store reference to manager for cleanup
-  (router as any).sseManager = sseManager;
-
-  return router;
-}

package/src/transports/index.ts

@@ -1,36 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { startStdioTransport } from "./stdio.js";
-import { startHttpTransport } from "./http/server.js";
-import type { TransportConfig, HttpServerHandle } from "./types.js";
-
-export class TransportManager {
-  private server: McpServer;
-  private config: TransportConfig;
-  private httpHandle?: HttpServerHandle;
-
-  constructor(server: McpServer, config: TransportConfig) {
-    this.server = server;
-    this.config = config;
-  }
-
-  async start(): Promise<void> {
-    switch (this.config.type) {
-      case 'stdio':
-        await startStdioTransport(this.server);
-        break;
-      case 'http':
-        this.httpHandle = await startHttpTransport(this.server, this.config.http!);
-        break;
-      case 'both':
-        await startStdioTransport(this.server);
-        this.httpHandle = await startHttpTransport(this.server, this.config.http!);
-        break;
-    }
-  }
-
-  async stop(): Promise<void> {
-    if (this.httpHandle) {
-      await this.httpHandle.close();
-    }
-  }
-}

package/src/transports/stdio.ts

@@ -1,7 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-export async function startStdioTransport(server: McpServer): Promise<void> {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}

package/src/transports/types.ts

@@ -1,50 +0,0 @@
-import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-
-export interface TransportConfig {
-  type: 'stdio' | 'http' | 'both';
-  http?: HttpTransportConfig;
-}
-
-export interface HttpTransportConfig {
-  port: number;
-  host?: string;
-  sessionMode: 'stateful' | 'stateless';
-  enableSse?: boolean;
-  enableJsonResponse?: boolean;
-  enableSseFallback?: boolean;
-  ssePaths?: {
-    stream: string;
-    message: string;
-  };
-  security?: SecurityConfig;
-}
-
-export interface SecurityConfig {
-  enableCors?: boolean;
-  corsOrigins?: string[];
-  enableDnsRebindingProtection?: boolean;
-  allowedHosts?: string[];
-  enableRateLimiting?: boolean;
-  secret?: string;
-}
-
-export interface TransportSession {
-  id: string;
-  createdAt: number;
-  transport: StreamableHTTPServerTransport;
-}
-
-export interface SessionStore {
-  get(sessionId: string): Promise<TransportSession | null>;
-  set(sessionId: string, session: TransportSession): Promise<void>;
-  delete(sessionId: string): Promise<void>;
-  cleanup(): Promise<void>;
-}
-
-export interface HttpServerHandle {
-  app: any;
-  server: any;
-  sessionManager: any;
-  sseManager?: any;
-  close(): Promise<void>;
-}

package/src/types/index.ts

@@ -1,41 +0,0 @@
-export interface AnalysisOptions {
-  analysis_type: "general" | "ui_debug" | "error_detection" | "accessibility" | "performance" | "layout";
-  detail_level: "quick" | "detailed";
-  specific_focus?: string;
-  extract_text?: boolean;
-  detect_ui_elements?: boolean;
-  analyze_colors?: boolean;
-  check_accessibility?: boolean;
-  fetchTimeout?: number;
-}
-
-export interface ProcessingResult {
-  description: string;
-  analysis: string;
-  elements: DetectedElement[];
-  insights: string[];
-  recommendations: string[];
-  metadata: {
-    processing_time_ms: number;
-    model_used: string;
-    frames_analyzed?: number;
-  };
-}
-
-export interface DetectedElement {
-  type: string;
-  location: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  properties: Record<string, any>;
-}
-
-export interface VideoOptions extends AnalysisOptions {
-  max_frames?: number;
-  sample_rate?: number;
-}
-
-export type LogLevel = "debug" | "info" | "warn" | "error";

package/src/utils/cloudflare-r2.ts

@@ -1,107 +0,0 @@
-import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
-import { v4 as uuidv4 } from 'uuid';
-import mime from 'mime-types';
-import { logger } from './logger.js';
-
-export class CloudflareR2Client {
-  private s3Client: S3Client;
-  private bucketName: string;
-  private baseUrl: string;
-
-  constructor() {
-    // Check if required environment variables are set
-    const requiredVars = [
-      'CLOUDFLARE_CDN_ACCESS_KEY',
-      'CLOUDFLARE_CDN_SECRET_KEY', 
-      'CLOUDFLARE_CDN_ENDPOINT_URL',
-      'CLOUDFLARE_CDN_BUCKET_NAME',
-      'CLOUDFLARE_CDN_BASE_URL'
-    ];
-
-    const missing = requiredVars.filter(varName => !process.env[varName]);
-    if (missing.length > 0) {
-      throw new Error(`Missing required Cloudflare R2 environment variables: ${missing.join(', ')}`);
-    }
-
-    const config = {
-      region: 'auto',
-      endpoint: process.env.CLOUDFLARE_CDN_ENDPOINT_URL,
-      credentials: {
-        accessKeyId: process.env.CLOUDFLARE_CDN_ACCESS_KEY!,
-        secretAccessKey: process.env.CLOUDFLARE_CDN_SECRET_KEY!,
-      },
-    };
-
-    this.s3Client = new S3Client(config);
-    this.bucketName = process.env.CLOUDFLARE_CDN_BUCKET_NAME!;
-    this.baseUrl = process.env.CLOUDFLARE_CDN_BASE_URL!;
-  }
-
-  async uploadFile(buffer: Buffer, originalName: string): Promise<string> {
-    try {
-      const fileExtension = originalName.split('.').pop() || 'bin';
-      const mimeType = mime.lookup(originalName) || 'application/octet-stream';
-      const key = `human-mcp/${uuidv4()}.${fileExtension}`;
-
-      const command = new PutObjectCommand({
-        Bucket: this.bucketName,
-        Key: key,
-        Body: buffer,
-        ContentType: mimeType,
-        Metadata: {
-          originalName: originalName,
-          uploadedAt: new Date().toISOString(),
-          source: 'human-mcp-http-transport'
-        }
-      });
-
-      await this.s3Client.send(command);
-      
-      const publicUrl = `${this.baseUrl}/${key}`;
-      logger.info(`File uploaded to Cloudflare R2: ${publicUrl}`);
-      
-      return publicUrl;
-    } catch (error) {
-      logger.error('Failed to upload to Cloudflare R2:', error);
-      throw new Error(`Failed to upload file: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  async uploadBase64(base64Data: string, mimeType: string, originalName?: string): Promise<string> {
-    const buffer = Buffer.from(base64Data, 'base64');
-    const extension = mimeType.split('/')[1] || 'bin';
-    const fileName = originalName || `upload-${Date.now()}.${extension}`;
-    
-    return this.uploadFile(buffer, fileName);
-  }
-
-  isConfigured(): boolean {
-    try {
-      const requiredVars = [
-        'CLOUDFLARE_CDN_ACCESS_KEY',
-        'CLOUDFLARE_CDN_SECRET_KEY', 
-        'CLOUDFLARE_CDN_ENDPOINT_URL',
-        'CLOUDFLARE_CDN_BUCKET_NAME',
-        'CLOUDFLARE_CDN_BASE_URL'
-      ];
-      return requiredVars.every(varName => process.env[varName]);
-    } catch {
-      return false;
-    }
-  }
-}
-
-// Singleton instance with lazy initialization
-let cloudflareR2Instance: CloudflareR2Client | null = null;
-
-export function getCloudflareR2(): CloudflareR2Client | null {
-  if (!cloudflareR2Instance) {
-    try {
-      cloudflareR2Instance = new CloudflareR2Client();
-    } catch (error) {
-      logger.warn('Cloudflare R2 not configured:', error instanceof Error ? error.message : 'Unknown error');
-      return null;
-    }
-  }
-  return cloudflareR2Instance;
-}

package/src/utils/config.ts

@@ -1,123 +0,0 @@
-import { z } from "zod";
-
-const ConfigSchema = z.object({
-  gemini: z.object({
-    apiKey: z.string().min(1, "Google Gemini API key is required"),
-    model: z.string().default("gemini-2.5-flash"),
-  }),
-  transport: z.object({
-    type: z.enum(["stdio", "http", "both"]).default("stdio"),
-    http: z.object({
-      enabled: z.boolean().default(false),
-      port: z.number().default(3000),
-      host: z.string().default("0.0.0.0"),
-      sessionMode: z.enum(["stateful", "stateless"]).default("stateful"),
-      enableSse: z.boolean().default(true),
-      enableJsonResponse: z.boolean().default(true),
-      enableSseFallback: z.boolean().default(false),
-      ssePaths: z.object({
-        stream: z.string().default("/sse"),
-        message: z.string().default("/messages")
-      }).default({ stream: "/sse", message: "/messages" }),
-      security: z.object({
-        enableCors: z.boolean().default(true),
-        corsOrigins: z.array(z.string()).optional(),
-        enableDnsRebindingProtection: z.boolean().default(true),
-        allowedHosts: z.array(z.string()).default(["127.0.0.1", "localhost"]),
-        enableRateLimiting: z.boolean().default(false),
-        secret: z.string().optional(),
-      }).optional(),
-    }).optional(),
-  }),
-  server: z.object({
-    port: z.number().default(3000),
-    maxRequestSize: z.string().default("50MB"),
-    enableCaching: z.boolean().default(true),
-    cacheTTL: z.number().default(3600),
-    requestTimeout: z.number().default(300000), // 5 minutes
-    fetchTimeout: z.number().default(60000), // 60 seconds for HTTP requests
-  }),
-  security: z.object({
-    secret: z.string().optional(),
-    rateLimitRequests: z.number().default(100),
-    rateLimitWindow: z.number().default(60000),
-  }),
-  logging: z.object({
-    level: z.enum(["debug", "info", "warn", "error"]).default("info"),
-  }),
-  cloudflare: z.object({
-    projectName: z.string().optional().default("human-mcp"),
-    bucketName: z.string().optional(),
-    accessKey: z.string().optional(),
-    secretKey: z.string().optional(),
-    endpointUrl: z.string().optional(),
-    baseUrl: z.string().optional(),
-  }).optional(),
-});
-
-export type Config = z.infer<typeof ConfigSchema>;
-
-export function loadConfig(): Config {
-  const corsOrigins = process.env.HTTP_CORS_ORIGINS ? 
-    process.env.HTTP_CORS_ORIGINS.split(',').map(origin => origin.trim()) : 
-    undefined;
-  
-  const allowedHosts = process.env.HTTP_ALLOWED_HOSTS ? 
-    process.env.HTTP_ALLOWED_HOSTS.split(',').map(host => host.trim()) : 
-    ["127.0.0.1", "localhost"];
-
-  return ConfigSchema.parse({
-    gemini: {
-      apiKey: process.env.GOOGLE_GEMINI_API_KEY || "",
-      model: process.env.GOOGLE_GEMINI_MODEL || "gemini-2.5-flash",
-    },
-    transport: {
-      type: (process.env.TRANSPORT_TYPE as any) || "stdio",
-      http: {
-        enabled: process.env.TRANSPORT_TYPE === "http" || process.env.TRANSPORT_TYPE === "both",
-        port: parseInt(process.env.HTTP_PORT || "3000"),
-        host: process.env.HTTP_HOST || "0.0.0.0",
-        sessionMode: (process.env.HTTP_SESSION_MODE as any) || "stateful",
-        enableSse: process.env.HTTP_ENABLE_SSE !== "false",
-        enableJsonResponse: process.env.HTTP_ENABLE_JSON_RESPONSE !== "false",
-        enableSseFallback: process.env.HTTP_ENABLE_SSE_FALLBACK === "true",
-        ssePaths: {
-          stream: process.env.HTTP_SSE_STREAM_PATH || "/sse",
-          message: process.env.HTTP_SSE_MESSAGE_PATH || "/messages"
-        },
-        security: {
-          enableCors: process.env.HTTP_CORS_ENABLED !== "false",
-          corsOrigins,
-          enableDnsRebindingProtection: process.env.HTTP_DNS_REBINDING_ENABLED !== "false",
-          allowedHosts,
-          enableRateLimiting: process.env.HTTP_ENABLE_RATE_LIMITING === "true",
-          secret: process.env.HTTP_SECRET,
-        },
-      },
-    },
-    server: {
-      port: parseInt(process.env.PORT || "3000"),
-      maxRequestSize: process.env.MAX_REQUEST_SIZE || "50MB",
-      enableCaching: process.env.ENABLE_CACHING !== "false",
-      cacheTTL: parseInt(process.env.CACHE_TTL || "3600"),
-      requestTimeout: parseInt(process.env.REQUEST_TIMEOUT || "300000"),
-      fetchTimeout: parseInt(process.env.FETCH_TIMEOUT || "60000"),
-    },
-    security: {
-      secret: process.env.MCP_SECRET,
-      rateLimitRequests: parseInt(process.env.RATE_LIMIT_REQUESTS || "100"),
-      rateLimitWindow: parseInt(process.env.RATE_LIMIT_WINDOW || "60000"),
-    },
-    logging: {
-      level: (process.env.LOG_LEVEL as any) || "info",
-    },
-    cloudflare: {
-      projectName: process.env.CLOUDFLARE_CDN_PROJECT_NAME || "human-mcp",
-      bucketName: process.env.CLOUDFLARE_CDN_BUCKET_NAME,
-      accessKey: process.env.CLOUDFLARE_CDN_ACCESS_KEY,
-      secretKey: process.env.CLOUDFLARE_CDN_SECRET_KEY,
-      endpointUrl: process.env.CLOUDFLARE_CDN_ENDPOINT_URL,
-      baseUrl: process.env.CLOUDFLARE_CDN_BASE_URL,
-    },
-  });
-}