@goonnguyen/human-mcp 1.3.0 → 2.0.0

package/src/utils/errors.ts

@@ -1,40 +0,0 @@
-export class HumanMCPError extends Error {
-  constructor(
-    message: string,
-    public code: string,
-    public statusCode?: number
-  ) {
-    super(message);
-    this.name = "HumanMCPError";
-  }
-}
-
-export class ValidationError extends HumanMCPError {
-  constructor(message: string) {
-    super(message, "VALIDATION_ERROR", 400);
-  }
-}
-
-export class ProcessingError extends HumanMCPError {
-  constructor(message: string) {
-    super(message, "PROCESSING_ERROR", 500);
-  }
-}
-
-export class APIError extends HumanMCPError {
-  constructor(message: string, statusCode: number = 500) {
-    super(message, "API_ERROR", statusCode);
-  }
-}
-
-export function handleError(error: unknown): HumanMCPError {
-  if (error instanceof HumanMCPError) {
-    return error;
-  }
-  
-  if (error instanceof Error) {
-    return new ProcessingError(error.message);
-  }
-  
-  return new ProcessingError("An unknown error occurred");
-}

package/src/utils/logger.ts

@@ -1,49 +0,0 @@
-import type { LogLevel } from "@/types";
-
-class Logger {
-  private level: LogLevel;
-  
-  constructor() {
-    this.level = (process.env.LOG_LEVEL as LogLevel) || "info";
-  }
-  
-  private shouldLog(level: LogLevel): boolean {
-    const levels: LogLevel[] = ["debug", "info", "warn", "error"];
-    return levels.indexOf(level) >= levels.indexOf(this.level);
-  }
-  
-  private format(level: LogLevel, message: string, ...args: any[]): string {
-    const timestamp = new Date().toISOString();
-    const formatted = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
-    if (args.length > 0) {
-      return `${formatted} ${JSON.stringify(args)}`;
-    }
-    return formatted;
-  }
-  
-  debug(message: string, ...args: any[]) {
-    if (this.shouldLog("debug")) {
-      console.error(this.format("debug", message, ...args));
-    }
-  }
-  
-  info(message: string, ...args: any[]) {
-    if (this.shouldLog("info")) {
-      console.error(this.format("info", message, ...args));
-    }
-  }
-  
-  warn(message: string, ...args: any[]) {
-    if (this.shouldLog("warn")) {
-      console.error(this.format("warn", message, ...args));
-    }
-  }
-  
-  error(message: string, ...args: any[]) {
-    if (this.shouldLog("error")) {
-      console.error(this.format("error", message, ...args));
-    }
-  }
-}
-
-export const logger = new Logger();

package/tests/integration/http-transport-files.test.ts

@@ -1,190 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, mock } from 'bun:test';
-import { fileInterceptorMiddleware } from '@/transports/http/file-interceptor';
-import type { Request, Response, NextFunction } from 'express';
-
-// Mock the Cloudflare R2 client
-mock.module('@/utils/cloudflare-r2', () => ({
-  CloudflareR2Client: mock(function() {
-    return {
-      uploadFile: mock(async (_buffer: Buffer, filename: string) => {
-        return `https://cdn.test.com/human-mcp/${filename}`;
-      }),
-      uploadBase64: mock(async (_data: string, _mimeType: string, filename?: string) => {
-        return `https://cdn.test.com/human-mcp/${filename || 'upload.jpg'}`;
-      }),
-      isConfigured: mock(() => true)
-    };
-  }),
-  getCloudflareR2: mock(() => ({
-    uploadFile: mock(async (_buffer: Buffer, filename: string) => {
-      return `https://cdn.test.com/human-mcp/${filename}`;
-    }),
-    uploadBase64: mock(async (_data: string, _mimeType: string, filename?: string) => {
-      return `https://cdn.test.com/human-mcp/${filename || 'upload.jpg'}`;
-    }),
-    isConfigured: mock(() => true)
-  }))
-}));
-
-// Logger is mocked globally in setup.ts
-
-// Mock fs/promises module for Bun compatibility
-mock.module('fs/promises', () => ({
-  access: mock(async () => { throw new Error('File not found'); }),
-  readFile: mock(async () => Buffer.from('fake image data')),
-  stat: mock(async () => ({ isFile: () => true }))
-}));
-
-describe('HTTP Transport File Handling', () => {
-  beforeAll(() => {
-    process.env.TRANSPORT_TYPE = 'http';
-    // Set required Cloudflare R2 environment variables for testing
-    process.env.CLOUDFLARE_CDN_ACCESS_KEY = 'test-access-key';
-    process.env.CLOUDFLARE_CDN_SECRET_KEY = 'test-secret-key';
-    process.env.CLOUDFLARE_CDN_ENDPOINT_URL = 'https://test.r2.cloudflarestorage.com';
-    process.env.CLOUDFLARE_CDN_BUCKET_NAME = 'test-bucket';
-    process.env.CLOUDFLARE_CDN_BASE_URL = 'https://cdn.test.com';
-  });
-
-  afterAll(() => {
-    delete process.env.TRANSPORT_TYPE;
-    delete process.env.CLOUDFLARE_CDN_ACCESS_KEY;
-    delete process.env.CLOUDFLARE_CDN_SECRET_KEY;
-    delete process.env.CLOUDFLARE_CDN_ENDPOINT_URL;
-    delete process.env.CLOUDFLARE_CDN_BUCKET_NAME;
-    delete process.env.CLOUDFLARE_CDN_BASE_URL;
-  });
-
-  it('should handle Claude Desktop virtual paths', async () => {
-    const req = {
-      body: {
-        method: 'tools/call',
-        params: {
-          arguments: {
-            source: '/mnt/user-data/uploads/test.png',
-            type: 'image'
-          }
-        },
-        id: 'test-id'
-      }
-    } as Request;
-
-    const res = {
-      status: mock(() => res),
-      json: mock(() => {}),
-    } as unknown as Response;
-
-    const next = mock(() => {}) as NextFunction;
-
-    await fileInterceptorMiddleware(req, res, next);
-
-    // Should provide helpful error when file not found
-    expect(res.status).toHaveBeenCalledWith(400);
-    expect(res.json).toHaveBeenCalledWith({
-      jsonrpc: '2.0',
-      error: {
-        code: -32602,
-        message: 'File not accessible via HTTP transport',
-        data: {
-          path: '/mnt/user-data/uploads/test.png',
-          suggestions: expect.arrayContaining([
-            'Upload the file using the /mcp/upload endpoint first'
-          ])
-        }
-      },
-      id: 'test-id'
-    });
-  });
-
-  it('should auto-upload local files in HTTP mode', async () => {
-    // For now, let's test that the middleware doesn't break when Cloudflare is not configured
-    // This is actually the expected behavior in a test environment
-    const req = {
-      body: {
-        method: 'tools/call',
-        params: {
-          arguments: {
-            source: '/local/path/image.jpg'
-          }
-        }
-      }
-    } as Request;
-
-    const res = {} as Response;
-    const next = mock(() => {}) as NextFunction;
-
-    await fileInterceptorMiddleware(req, res, next);
-
-    // Without proper Cloudflare configuration, the path should remain unchanged
-    // This is the correct behavior for the current implementation
-    expect(req.body.params.arguments.source).toBe('/local/path/image.jpg');
-    expect(next).toHaveBeenCalled();
-  });
-
-  it('should skip non-file fields', async () => {
-    const originalSource = 'https://example.com/image.jpg';
-    const req = {
-      body: {
-        method: 'tools/call',
-        params: {
-          arguments: {
-            source: originalSource,
-            otherField: 'some value'
-          }
-        }
-      }
-    } as Request;
-
-    const res = {} as Response;
-    const next = mock(() => {}) as NextFunction;
-
-    await fileInterceptorMiddleware(req, res, next);
-
-    // Should not modify URL sources
-    expect(req.body.params.arguments.source).toBe(originalSource);
-    expect(next).toHaveBeenCalled();
-  });
-
-  it('should skip non-tool-call requests', async () => {
-    const req = {
-      body: {
-        method: 'initialize',
-        params: {}
-      }
-    } as Request;
-
-    const res = {} as Response;
-    const next = mock(() => {}) as NextFunction;
-
-    await fileInterceptorMiddleware(req, res, next);
-
-    expect(next).toHaveBeenCalled();
-  });
-
-  it('should handle multiple file fields', async () => {
-    // Test that middleware processes multiple fields without breaking
-    const req = {
-      body: {
-        method: 'tools/call',
-        params: {
-          arguments: {
-            source1: '/path/image1.jpg',
-            source2: '/path/image2.png',
-            normalField: 'value'
-          }
-        }
-      }
-    } as Request;
-
-    const res = {} as Response;
-    const next = mock(() => {}) as NextFunction;
-
-    await fileInterceptorMiddleware(req, res, next);
-
-    // Without proper Cloudflare configuration, paths should remain unchanged
-    expect(req.body.params.arguments.source1).toBe('/path/image1.jpg');
-    expect(req.body.params.arguments.source2).toBe('/path/image2.png');
-    expect(req.body.params.arguments.normalField).toBe('value');
-    expect(next).toHaveBeenCalled();
-  });
-});

package/tests/integration/server.test.ts

@@ -1,27 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, mock } from "bun:test";
-
-// Logger is mocked globally in setup.ts
-
-import { createServer } from "../../src/server.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-
-describe("MCP Server Integration", () => {
-  let server: McpServer;
-  
-  beforeAll(async () => {
-    process.env.GOOGLE_GEMINI_API_KEY = "test-key";
-    server = await createServer();
-  });
-  
-  afterAll(() => {
-    delete process.env.GOOGLE_GEMINI_API_KEY;
-  });
-  
-  it("should create server successfully", () => {
-    expect(server).toBeDefined();
-  });
-  
-  it("should be properly configured", () => {
-    expect(server).toBeInstanceOf(McpServer);
-  });
-});

package/tests/integration/sse-transport.test.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "bun:test";
-import { testServerManager } from "../utils/test-server-manager.js";
-
-describe("SSE Transport Integration", () => {
-  let baseUrl: string;
-
-  beforeAll(async () => {
-    const testServer = await testServerManager.startTestServer({
-      sessionMode: "stateful",
-      enableSse: true,
-      enableJsonResponse: true,
-      enableSseFallback: true,
-      ssePaths: {
-        stream: "/sse",
-        message: "/messages"
-      },
-      security: {
-        enableCors: true,
-        enableDnsRebindingProtection: true,
-        allowedHosts: ["127.0.0.1", "localhost"]
-      }
-    });
-
-    baseUrl = testServer.baseUrl;
-  });
-
-  afterAll(async () => {
-    await testServerManager.stopAllServers();
-  });
-
-  describe("health endpoint", () => {
-    it("should include SSE fallback status in health check", async () => {
-      const response = await fetch(`${baseUrl}/health`);
-      const health = await response.json() as {
-        status: string;
-        transport: string;
-        sseFallback: string;
-        ssePaths: { stream: string; message: string; };
-      };
-      
-      expect(health.status).toBe("healthy");
-      expect(health.transport).toBe("streamable-http");
-      expect(health.sseFallback).toBe("enabled");
-      expect(health.ssePaths).toEqual({
-        stream: "/sse",
-        message: "/messages"
-      });
-    });
-  });
-
-  describe("SSE endpoint availability", () => {
-    it("should reject GET /sse in stateless mode", async () => {
-      const response = await fetch(`${baseUrl}/sse`, {
-        method: "GET"
-      });
-      
-      // In current stateful mode, we expect different behavior
-      // This test would need a separate server instance with stateless config
-      // For now, just verify the endpoint exists
-      expect(response.status).toBeDefined();
-    });
-
-    it("should reject POST /messages without sessionId", async () => {
-      const response = await fetch(`${baseUrl}/messages`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          method: "initialize",
-          id: 1
-        })
-      });
-      
-      expect(response.status).toBe(400);
-      const error = await response.json() as { error: { message: string } };
-      expect(error.error.message).toContain("Missing sessionId");
-    });
-
-    it("should reject POST /messages with invalid sessionId", async () => {
-      const response = await fetch(`${baseUrl}/messages?sessionId=invalid`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          method: "initialize",
-          id: 1
-        })
-      });
-      
-      expect(response.status).toBe(400);
-      const error = await response.json() as { error: { message: string } };
-      expect(error.error.message).toContain("No active SSE session");
-    });
-  });
-
-  describe("transport mixing prevention", () => {
-    it("should prevent using streamable HTTP session ID on SSE endpoints", async () => {
-      // First create a streamable HTTP session
-      const initResponse = await fetch(`${baseUrl}/mcp`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          method: "initialize",
-          params: {
-            protocolVersion: "2024-11-05",
-            capabilities: {},
-            clientInfo: { name: "test", version: "1.0.0" }
-          },
-          id: 1
-        })
-      });
-
-      const sessionId = initResponse.headers.get("Mcp-Session-Id");
-      
-      if (sessionId) {
-        // Try to use this session ID on SSE message endpoint
-        const response = await fetch(`${baseUrl}/messages?sessionId=${sessionId}`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            jsonrpc: "2.0",
-            method: "ping",
-            id: 2
-          })
-        });
-        
-        expect(response.status).toBe(400);
-        const error = await response.json() as { error: { message: string } };
-        expect(error.error.message).toContain("streamable HTTP transport");
-      }
-    });
-  });
-});

package/tests/setup.ts

@@ -1,55 +0,0 @@
-import { beforeAll, afterAll, mock } from "bun:test";
-import { MockHelpers } from "./utils/mock-helpers.js";
-
-// Global mock instances
-export const globalMocks = {
-  logger: MockHelpers.createLoggerMock(),
-  fs: MockHelpers.createFileSystemMock(),
-  geminiClient: MockHelpers.createGeminiClientMock()
-};
-
-// Mock logger globally for all tests
-mock.module("@/utils/logger", () => ({
-  logger: globalMocks.logger
-}));
-
-// Mock fs module for Bun compatibility
-mock.module("fs", () => globalMocks.fs);
-
-// Mock Google Gemini client
-mock.module("@google/generative-ai", () => ({
-  GoogleGenerativeAI: mock(() => ({
-    getGenerativeModel: globalMocks.geminiClient.getGenerativeModel
-  }))
-}));
-
-beforeAll(() => {
-  // Set up test environment variables
-  process.env.GOOGLE_GEMINI_API_KEY = "test-api-key";
-  process.env.LOG_LEVEL = "error";
-  process.env.NODE_ENV = "test";
-  process.env.CLOUDFLARE_R2_ACCOUNT_ID = "test-account";
-  process.env.CLOUDFLARE_R2_ACCESS_KEY_ID = "test-access-key";
-  process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY = "test-secret";
-  process.env.CLOUDFLARE_R2_BUCKET = "test-bucket";
-  
-  // Initialize global test state
-  (globalThis as any).__TEST_MODE__ = true;
-});
-
-afterAll(() => {
-  // Clean up environment variables
-  delete process.env.GOOGLE_GEMINI_API_KEY;
-  delete process.env.LOG_LEVEL;
-  delete process.env.NODE_ENV;
-  delete process.env.CLOUDFLARE_R2_ACCOUNT_ID;
-  delete process.env.CLOUDFLARE_R2_ACCESS_KEY_ID;
-  delete process.env.CLOUDFLARE_R2_SECRET_ACCESS_KEY;
-  delete process.env.CLOUDFLARE_R2_BUCKET;
-  
-  // Clean up global test state
-  delete (globalThis as any).__TEST_MODE__;
-  
-  // Reset all mocks
-  MockHelpers.resetAllMocks(globalMocks);
-});

package/tests/types/api-responses.ts

@@ -1,35 +0,0 @@
-/**
- * Type definitions for API responses used in tests
- */
-
-export interface HealthCheckResponse {
-  status: string;
-  transport: string;
-  sseFallback: string;
-  ssePaths: {
-    stream: string;
-    message: string;
-  };
-}
-
-export interface ErrorResponse {
-  error: {
-    message: string;
-  };
-}
-
-export interface MCPResponse {
-  jsonrpc: string;
-  id: number;
-  result?: any;
-  error?: {
-    code: number;
-    message: string;
-  };
-}
-
-export interface SessionResponse {
-  sessionId: string;
-  transport: string;
-  mode: string;
-}

package/tests/types/test-types.ts

@@ -1,105 +0,0 @@
-// Common test types to improve type safety across test files
-
-export interface MockError {
-  message: string;
-  code?: string | number;
-}
-
-export interface MockGeminiResponse {
-  summary: string;
-  details: string;
-  technical_details?: Record<string, any>;
-  confidence: number;
-  recommendations?: string[];
-}
-
-export interface MockComparisonResponse {
-  summary: string;
-  differences: any[];
-  similarity_score: number;
-  analysis_method: string;
-  recommendations: string[];
-  technical_details: Record<string, string>;
-}
-
-export interface MockAnalysisRequest {
-  input: string;
-  detail_level: 'quick' | 'detailed';
-  custom_prompt?: string;
-  max_frames?: number;
-  source?: string;
-  type?: 'image' | 'video' | 'gif';
-  prompt?: string;
-}
-
-export interface MockCompareRequest {
-  input1: string;
-  input2: string;
-  comparison_type: 'pixel' | 'structural' | 'semantic';
-  custom_prompt?: string;
-  source1?: string;
-  source2?: string;
-}
-
-export interface MockHttpResponseData {
-  status?: string;
-  data?: any;
-  error?: string;
-  [key: string]: any;
-}
-
-export interface MockS3Command {
-  Bucket: string;
-  Key: string;
-  Body?: Buffer | string;
-  ContentType?: string;
-  [key: string]: any;
-}
-
-export interface MockCloudflareR2Client {
-  s3Client: {
-    send: (command: MockS3Command) => Promise<any>;
-  };
-  uploadFile: (buffer: Buffer, filename: string) => Promise<string>;
-  uploadBase64: (data: string, mimeType: string, filename?: string) => Promise<string>;
-  isConfigured: () => boolean;
-}
-
-export interface MockSSEConfig {
-  security?: {
-    enableCors?: boolean;
-    enableDnsRebindingProtection?: boolean;
-    allowedHosts?: string[];
-  };
-  sessionMode?: 'stateful' | 'stateless';
-  enableSse?: boolean;
-  enableJsonResponse?: boolean;
-  enableSseFallback?: boolean;
-  ssePaths?: {
-    stream: string;
-    message: string;
-  };
-}
-
-// Generic mock function type
-export type MockFunction<T extends (...args: any[]) => any> = T & {
-  mock: {
-    calls: Parameters<T>[];
-    results: { value: ReturnType<T> }[];
-  };
-  mockRestore?: () => void;
-  mockImplementation?: (impl: T) => void;
-  mockRejectedValue?: (value: any) => void;
-  mockRejectedValueOnce?: (value: any) => void;
-  mockResolvedValue?: (value: ReturnType<T>) => void;
-  mockResolvedValueOnce?: (value: ReturnType<T>) => void;
-};
-
-// Extend global types for test environment
-declare global {
-  namespace globalThis {
-    var __TEST_MODE__: boolean;
-  }
-}
-
-export {};