@goonnguyen/human-mcp 1.3.0 → 2.0.0

package/tests/unit/cloudflare-r2.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect, beforeAll, mock } from 'bun:test';
-import { CloudflareR2Client, getCloudflareR2 } from '@/utils/cloudflare-r2';
-import type { MockS3Command, MockCloudflareR2Client } from '../types/test-types.js';
-
-// Mock the S3Client and PutObjectCommand
-mock.module('@aws-sdk/client-s3', () => ({
-  S3Client: mock(() => ({})),
-  PutObjectCommand: mock((params: MockS3Command) => ({ ...params }))
-}));
-
-describe('Cloudflare R2 Integration', () => {
-  beforeAll(() => {
-    // Set up test environment variables
-    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-account.r2.cloudflarestorage.com';
-    process.env.CLOUDFLARE_CDN_BUCKET_NAME = 'test-bucket';
-    process.env.CLOUDFLARE_CDN_BASE_URL = 'https://cdn.test.com';
-  });
-
-  it('should create CloudflareR2Client with correct configuration', () => {
-    expect(() => new CloudflareR2Client()).not.toThrow();
-  });
-
-  it('should throw error when required environment variables are missing', () => {
-    const originalAccessKey = process.env.CLOUDFLARE_CDN_ACCESS_KEY;
-    delete process.env.CLOUDFLARE_CDN_ACCESS_KEY;
-
-    expect(() => new CloudflareR2Client()).toThrow('Missing required Cloudflare R2 environment variables');
-    
-    process.env.CLOUDFLARE_CDN_ACCESS_KEY = originalAccessKey;
-  });
-
-  it('should check if Cloudflare R2 is configured', () => {
-    const client = new CloudflareR2Client();
-    expect(client.isConfigured()).toBe(true);
-  });
-
-  it('should return null when getCloudflareR2() called without configuration', () => {
-    // Temporarily remove configuration
-    const originalEnvs = {
-      CLOUDFLARE_CDN_ACCESS_KEY: process.env.CLOUDFLARE_CDN_ACCESS_KEY,
-      CLOUDFLARE_CDN_SECRET_KEY: process.env.CLOUDFLARE_CDN_SECRET_KEY,
-      CLOUDFLARE_CDN_ENDPOINT_URL: process.env.CLOUDFLARE_CDN_ENDPOINT_URL,
-      CLOUDFLARE_CDN_BUCKET_NAME: process.env.CLOUDFLARE_CDN_BUCKET_NAME,
-      CLOUDFLARE_CDN_BASE_URL: process.env.CLOUDFLARE_CDN_BASE_URL,
-    };
-
-    Object.keys(originalEnvs).forEach(key => delete process.env[key]);
-
-    const client = getCloudflareR2();
-    expect(client).toBeNull();
-
-    // Restore environment variables
-    Object.assign(process.env, originalEnvs);
-  });
-
-  it('should generate proper file keys with UUID', async () => {
-    const client = new CloudflareR2Client();
-    const testBuffer = Buffer.from('test file content');
-    
-    // Mock the S3 send method to capture the command
-    let capturedCommand: MockS3Command | undefined;
-    const mockSend = mock(async (command: MockS3Command) => {
-      capturedCommand = command;
-      return {};
-    });
-    
-    (client as unknown as MockCloudflareR2Client).s3Client.send = mockSend;
-
-    try {
-      await client.uploadFile(testBuffer, 'test.jpg');
-      
-      expect(capturedCommand).toBeDefined();
-      expect(capturedCommand!.input.Key).toMatch(/^human-mcp\/[a-f0-9-]{36}\.jpg$/);
-      expect(capturedCommand!.input.ContentType).toBe('image/jpeg');
-      expect(capturedCommand!.input.Metadata?.originalName).toBe('test.jpg');
-    } catch (error) {
-      // Expected to fail in test environment, but we captured the command
-    }
-  });
-
-  it('should handle base64 upload correctly', async () => {
-    const client = new CloudflareR2Client();
-    const testBase64 = Buffer.from('test image data').toString('base64');
-    
-    let capturedCommand: MockS3Command | undefined;
-    const mockSend = mock(async (command: MockS3Command) => {
-      capturedCommand = command;
-      return {};
-    });
-    
-    (client as unknown as MockCloudflareR2Client).s3Client.send = mockSend;
-
-    try {
-      await client.uploadBase64(testBase64, 'image/png', 'test.png');
-      
-      expect(capturedCommand).toBeDefined();
-      expect(capturedCommand!.input.Key).toMatch(/^human-mcp\/[a-f0-9-]{36}\.png$/);
-      expect(capturedCommand!.input.ContentType).toBe('image/png');
-    } catch (error) {
-      // Expected to fail in test environment
-    }
-  });
-
-  it('should handle upload errors gracefully', async () => {
-    const client = new CloudflareR2Client();
-    
-    const mockSend = mock(async () => {
-      throw new Error('Network error');
-    });
-    
-    (client as unknown as MockCloudflareR2Client).s3Client.send = mockSend;
-
-    await expect(client.uploadFile(Buffer.from('test'), 'test.jpg'))
-      .rejects.toThrow('Failed to upload file: Network error');
-  });
-});

package/tests/unit/config.test.ts

@@ -1,40 +0,0 @@
-import { describe, it, expect, beforeEach } from "bun:test";
-import { loadConfig } from "../../src/utils/config.js";
-
-describe("Config", () => {
-  beforeEach(() => {
-    process.env.GOOGLE_GEMINI_API_KEY = "test-key";
-  });
-  
-  it("should load default configuration", () => {
-    process.env.LOG_LEVEL = "info"; // Override test setup
-    const config = loadConfig();
-    
-    expect(config.gemini.apiKey).toBe("test-key");
-    expect(config.gemini.model).toBe("gemini-2.5-flash");
-    expect(config.server.port).toBe(3000);
-    expect(config.logging.level).toBe("info");
-  });
-  
-  it("should override defaults with environment variables", () => {
-    process.env.PORT = "8080";
-    process.env.LOG_LEVEL = "debug";
-    process.env.GOOGLE_GEMINI_MODEL = "gemini-2.5-flash";
-    
-    const config = loadConfig();
-    
-    expect(config.server.port).toBe(8080);
-    expect(config.logging.level).toBe("debug");
-    expect(config.gemini.model).toBe("gemini-2.5-flash");
-  });
-  
-  it("should throw error for missing API key", () => {
-    // Clear environment variables set by other tests
-    delete process.env.GOOGLE_GEMINI_API_KEY;
-    delete process.env.PORT;
-    delete process.env.LOG_LEVEL;
-    delete process.env.GOOGLE_GEMINI_MODEL;
-    
-    expect(() => loadConfig()).toThrow();
-  });
-});

package/tests/unit/eyes-analyze.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach, mock } from 'bun:test';
-import { registerEyesTool } from '@/tools/eyes/index';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { loadConfig } from '@/utils/config';
-import { MockHelpers, TestDataGenerators } from '../utils/index.js';
-
-// Import global mocks from setup
-import { globalMocks } from '../setup.js';
-
-// Mock fetch for URL operations
-const mockFetch = mock(async (url: string) => {
-  if (url.includes('error')) {
-    throw new Error('Fetch failed');
-  }
-  return new Response(TestDataGenerators.createMockImageBuffer(), {
-    status: 200,
-    headers: { 'content-type': 'image/jpeg' }
-  });
-});
-global.fetch = mockFetch as unknown as typeof fetch;
-
-// Mock Gemini client
-const mockGeminiModel = {
-  generateContent: mock(async () => ({
-    response: {
-      text: () => JSON.stringify(TestDataGenerators.createMockGeminiResponse())
-    }
-  }))
-};
-
-const mockGeminiClient = {
-  getModel: mock(() => mockGeminiModel)
-};
-
-mock.module('@/tools/eyes/utils/gemini-client', () => ({
-  GeminiClient: mock(() => mockGeminiClient)
-}));
-
-// Mock processors
-mock.module('@/tools/eyes/processors/image', () => ({
-  processImage: mock(async () => ({
-    analysis: JSON.stringify(TestDataGenerators.createMockGeminiResponse())
-  }))
-}));
-
-mock.module('@/tools/eyes/processors/video', () => ({
-  processVideo: mock(async () => ({
-    analysis: JSON.stringify(TestDataGenerators.createMockGeminiResponse())
-  }))
-}));
-
-mock.module('@/tools/eyes/processors/gif', () => ({
-  processGif: mock(async () => ({
-    analysis: JSON.stringify(TestDataGenerators.createMockGeminiResponse())
-  }))
-}));
-
-describe('Eyes Analyze Tool', () => {
-  let server: McpServer;
-
-  beforeAll(async () => {
-    process.env.GOOGLE_GEMINI_API_KEY = 'test-key';
-    
-    const config = loadConfig();
-
-    server = new McpServer({
-      name: 'test-server',
-      version: '1.0.0'
-    }, {
-      capabilities: {
-        tools: {}
-      }
-    });
-
-    await registerEyesTool(server, config);
-  });
-
-  afterAll(() => {
-    delete process.env.GOOGLE_GEMINI_API_KEY;
-  });
-
-  beforeEach(() => {
-    // Reset mocks before each test
-    MockHelpers.resetAllMocks({
-      mockGeminiModel,
-      mockGeminiClient,
-      mockFetch
-    });
-  });
-
-  describe('tool registration', () => {
-    it('should register eyes_analyze tool successfully', () => {
-      // Test that the registration process completed successfully
-      expect(server).toBeDefined();
-      expect(server).toBeInstanceOf(McpServer);
-    });
-
-    it('should register eyes_compare tool successfully', () => {
-      // Test that the registration process completed successfully
-      expect(server).toBeDefined();
-      expect(server).toBeInstanceOf(McpServer);
-    });
-
-    it('should register tools without errors', () => {
-      expect(server).toBeInstanceOf(McpServer);
-    });
-  });
-
-  describe('eyes_analyze schema validation', () => {
-    it('should validate schema registration without errors', () => {
-      // Test that schema registration completes successfully
-      expect(server).toBeDefined();
-    });
-
-    it('should handle mock processor calls', async () => {
-      // Test that the mocked processors can be called
-      const { processImage } = await import('@/tools/eyes/processors/image');
-      const result = await (processImage as unknown as () => Promise<{ analysis: string }>)();
-      expect(result.analysis).toContain('summary');
-    });
-
-    it('should handle mock Gemini client calls', () => {
-      // Test that the mocked Gemini client can be instantiated and called
-      expect(mockGeminiClient.getModel).toBeDefined();
-      expect(mockGeminiModel.generateContent).toBeDefined();
-    });
-  });
-
-  describe('eyes_compare schema validation', () => {
-    it('should validate comparison schema registration', () => {
-      // Test that comparison tool registration completes successfully
-      expect(server).toBeDefined();
-    });
-
-    it('should handle mock data generation', () => {
-      // Test that mock data generators work correctly
-      const compareRequest = TestDataGenerators.createMockCompareRequest();
-      expect(compareRequest.input1).toContain('data:image/png;base64');
-      expect(compareRequest.input2).toContain('data:image/png;base64');
-      expect(['pixel', 'structural', 'semantic']).toContain(compareRequest.comparison_type);
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle registration errors gracefully', () => {
-      // Test that error handling is set up correctly
-      expect(server).toBeInstanceOf(McpServer);
-    });
-  });
-});

package/tests/unit/formatters.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { createPrompt, parseAnalysisResponse } from "../../src/tools/eyes/utils/formatters.js";
-import type { AnalysisOptions } from "../../src/types/index.js";
-
-describe("Formatters", () => {
-  describe("createPrompt", () => {
-    it("should create UI debug prompt", () => {
-      const options: AnalysisOptions = {
-        analysis_type: "ui_debug",
-        detail_level: "detailed"
-      };
-      
-      const prompt = createPrompt(options);
-      
-      expect(prompt).toContain("UI debugging expert");
-      expect(prompt).toContain("layout issues");
-      expect(prompt).toContain("thorough analysis");
-    });
-    
-    it("should create accessibility prompt", () => {
-      const options: AnalysisOptions = {
-        analysis_type: "accessibility", 
-        detail_level: "quick"
-      };
-      
-      const prompt = createPrompt(options);
-      
-      expect(prompt).toContain("accessibility expert");
-      expect(prompt).toContain("WCAG guidelines");
-      expect(prompt).toContain("Provide a concise analysis");
-    });
-    
-    it("should include specific focus when provided", () => {
-      const options: AnalysisOptions = {
-        analysis_type: "general",
-        detail_level: "detailed",
-        specific_focus: "login form errors"
-      };
-      
-      const prompt = createPrompt(options);
-      
-      expect(prompt).toContain("login form errors");
-    });
-  });
-  
-  describe("parseAnalysisResponse", () => {
-    it("should parse structured response", () => {
-      const response = `
-        OVERVIEW: This is a test analysis
-        
-        KEY FINDINGS: Found several issues
-        
-        DETAILED ANALYSIS: Detailed breakdown of issues
-        
-        UI ELEMENTS: Button at 100,200 size 150x50
-        
-        RECOMMENDATIONS: Fix the layout issues
-        
-        DEBUGGING INSIGHTS: Consider responsive design
-      `;
-      
-      const parsed = parseAnalysisResponse(response);
-      
-      expect(parsed.description).toContain("This is a test analysis");
-      expect(parsed.analysis).toContain("Detailed breakdown of issues");
-      expect(parsed.recommendations).toContain("Fix the layout issues");
-      expect(parsed.insights).toContain("Consider responsive design");
-      expect(parsed.elements).toHaveLength(1);
-      expect(parsed.elements?.[0]?.location).toEqual({
-        x: 100, y: 200, width: 150, height: 50
-      });
-    });
-    
-    it("should handle missing sections gracefully", () => {
-      const response = "Simple analysis without sections";
-      
-      const parsed = parseAnalysisResponse(response);
-      
-      expect(parsed.description).toBe("Simple analysis without sections");
-      expect(parsed.analysis).toBe("Simple analysis without sections");
-      expect(parsed.elements).toEqual([]);
-      expect(parsed.insights).toEqual([]);
-    });
-  });
-});

package/tests/unit/sse-routes.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { SSEManager } from "../../src/transports/http/sse-routes.js";
-import type { HttpTransportConfig } from "../../src/transports/types.js";
-import type { Response } from "express";
-
-describe("SSEManager", () => {
-  let sseManager: SSEManager;
-  let config: HttpTransportConfig;
-
-  beforeEach(() => {
-    config = {
-      port: 3000,
-      sessionMode: "stateful",
-      enableSseFallback: true,
-      ssePaths: {
-        stream: "/sse",
-        message: "/messages"
-      },
-      security: {
-        enableDnsRebindingProtection: true,
-        allowedHosts: ["127.0.0.1", "localhost"]
-      }
-    };
-    sseManager = new SSEManager(config);
-  });
-
-  afterEach(async () => {
-    await sseManager.cleanup();
-  });
-
-  describe("session management", () => {
-    it("should start with zero sessions", () => {
-      expect(sseManager.getSessionCount()).toBe(0);
-      expect(sseManager.hasSession("non-existent")).toBe(false);
-    });
-
-    it("should track session existence correctly", () => {
-      // Mock response object for testing
-      const mockRes = {
-        setHeader: () => {},
-        write: () => {},
-        end: () => {},
-        on: () => {},
-        removeAllListeners: () => {}
-      } as unknown as Response;
-
-      const transport = sseManager.createSession("/messages", mockRes);
-      
-      expect(sseManager.getSessionCount()).toBe(1);
-      expect(sseManager.hasSession(transport.sessionId)).toBe(true);
-      expect(sseManager.getSession(transport.sessionId)).toBe(transport);
-    });
-
-    it("should return null for non-existent session", () => {
-      expect(sseManager.getSession("non-existent-id")).toBe(null);
-    });
-
-    it("should cleanup sessions correctly", async () => {
-      const mockRes = {
-        setHeader: () => {},
-        write: () => {},
-        end: () => {},
-        on: () => {},
-        removeAllListeners: () => {}
-      } as unknown as Response;
-
-      sseManager.createSession("/messages", mockRes);
-      expect(sseManager.getSessionCount()).toBe(1);
-
-      await sseManager.cleanup();
-      expect(sseManager.getSessionCount()).toBe(0);
-    });
-  });
-
-  describe("configuration handling", () => {
-    it("should use security configuration from config", () => {
-      const mockRes = {
-        setHeader: () => {},
-        write: () => {},
-        end: () => {},
-        on: () => {},
-        removeAllListeners: () => {}
-      } as unknown as Response;
-
-      const transport = sseManager.createSession("/messages", mockRes);
-      
-      // Transport should be created successfully with security config
-      expect(transport).toBeDefined();
-      expect(transport.sessionId).toBeDefined();
-    });
-  });
-});

package/tests/utils/error-scenarios.ts

@@ -1,198 +0,0 @@
-import { mock } from 'bun:test';
-import type { MockError } from '../types/test-types.js';
-
-export class ErrorScenarios {
-  /**
-   * Common network errors for testing
-   */
-  static networkErrors = {
-    CONNECTION_REFUSED: new Error('ECONNREFUSED: Connection refused'),
-    TIMEOUT: new Error('ETIMEDOUT: Request timeout'),
-    DNS_ERROR: new Error('ENOTFOUND: DNS lookup failed'),
-    SSL_ERROR: new Error('SSL certificate verification failed'),
-    NETWORK_UNREACHABLE: new Error('ENETUNREACH: Network is unreachable')
-  };
-
-  /**
-   * HTTP error responses
-   */
-  static httpErrors = {
-    NOT_FOUND: { status: 404, error: 'Resource not found' },
-    UNAUTHORIZED: { status: 401, error: 'Unauthorized access' },
-    FORBIDDEN: { status: 403, error: 'Forbidden' },
-    SERVER_ERROR: { status: 500, error: 'Internal server error' },
-    BAD_GATEWAY: { status: 502, error: 'Bad gateway' },
-    SERVICE_UNAVAILABLE: { status: 503, error: 'Service unavailable' },
-    RATE_LIMITED: { status: 429, error: 'Too many requests' }
-  };
-
-  /**
-   * API specific errors
-   */
-  static apiErrors = {
-    GEMINI_API_ERROR: new Error('Gemini API quota exceeded'),
-    GEMINI_INVALID_KEY: new Error('Invalid Gemini API key'),
-    GEMINI_MODEL_UNAVAILABLE: new Error('Gemini model temporarily unavailable'),
-    CLOUDFLARE_R2_ERROR: new Error('Cloudflare R2 upload failed'),
-    FILE_NOT_FOUND: new Error('ENOENT: File not found'),
-    PERMISSION_DENIED: new Error('EACCES: Permission denied'),
-    DISK_FULL: new Error('ENOSPC: No space left on device')
-  };
-
-  /**
-   * Create a mock that fails with a specific error
-   */
-  static createFailingMock<T>(error: Error | MockError): ReturnType<typeof mock> {
-    return mock(async (..._args: any[]): Promise<T> => {
-      throw error;
-    });
-  }
-
-  /**
-   * Create a mock that fails intermittently
-   */
-  static createIntermittentMock<T>(
-    successValue: T, 
-    error: Error | MockError, 
-    failureRate = 0.5
-  ): ReturnType<typeof mock> {
-    return mock(async (..._args: any[]): Promise<T> => {
-      if (Math.random() < failureRate) {
-        throw error;
-      }
-      return successValue;
-    });
-  }
-
-  /**
-   * Create a mock that times out
-   */
-  static createTimeoutMock<T>(delay = 5000): ReturnType<typeof mock> {
-    return mock(async (..._args: any[]): Promise<T> => {
-      await new Promise(resolve => setTimeout(resolve, delay));
-      throw new Error('Request timeout');
-    });
-  }
-
-  /**
-   * Create a mock fetch that returns HTTP errors
-   */
-  static createErrorResponse(errorType: keyof typeof ErrorScenarios.httpErrors): Response {
-    const error = ErrorScenarios.httpErrors[errorType];
-    return new Response(JSON.stringify({ error: error.error }), {
-      status: error.status,
-      statusText: error.error,
-      headers: { 'Content-Type': 'application/json' }
-    });
-  }
-
-  /**
-   * Create test scenarios for network resilience
-   */
-  static createNetworkResilienceTests() {
-    return {
-      'should handle connection refused': {
-        error: ErrorScenarios.networkErrors.CONNECTION_REFUSED,
-        expectedMessage: 'Connection refused'
-      },
-      'should handle timeout': {
-        error: ErrorScenarios.networkErrors.TIMEOUT,
-        expectedMessage: 'Request timeout'
-      },
-      'should handle DNS errors': {
-        error: ErrorScenarios.networkErrors.DNS_ERROR,
-        expectedMessage: 'DNS lookup failed'
-      },
-      'should handle SSL errors': {
-        error: ErrorScenarios.networkErrors.SSL_ERROR,
-        expectedMessage: 'SSL certificate verification failed'
-      }
-    };
-  }
-
-  /**
-   * Create test scenarios for API errors
-   */
-  static createAPIErrorTests() {
-    return {
-      'should handle Gemini API quota exceeded': {
-        error: ErrorScenarios.apiErrors.GEMINI_API_ERROR,
-        expectedMessage: 'Gemini API quota exceeded'
-      },
-      'should handle invalid API key': {
-        error: ErrorScenarios.apiErrors.GEMINI_INVALID_KEY,
-        expectedMessage: 'Invalid Gemini API key'
-      },
-      'should handle model unavailable': {
-        error: ErrorScenarios.apiErrors.GEMINI_MODEL_UNAVAILABLE,
-        expectedMessage: 'model temporarily unavailable'
-      },
-      'should handle file upload errors': {
-        error: ErrorScenarios.apiErrors.CLOUDFLARE_R2_ERROR,
-        expectedMessage: 'upload failed'
-      }
-    };
-  }
-
-  /**
-   * Create test scenarios for file system errors
-   */
-  static createFileSystemErrorTests() {
-    return {
-      'should handle file not found': {
-        error: ErrorScenarios.apiErrors.FILE_NOT_FOUND,
-        expectedMessage: 'File not found'
-      },
-      'should handle permission denied': {
-        error: ErrorScenarios.apiErrors.PERMISSION_DENIED,
-        expectedMessage: 'Permission denied'
-      },
-      'should handle disk full': {
-        error: ErrorScenarios.apiErrors.DISK_FULL,
-        expectedMessage: 'No space left on device'
-      }
-    };
-  }
-
-  /**
-   * Simulate retry logic testing
-   */
-  static createRetryMock<T>(
-    finalResult: T,
-    failures: (Error | MockError)[],
-    maxRetries = 3
-  ): ReturnType<typeof mock> {
-    let attemptCount = 0;
-    
-    return mock(async (..._args: any[]): Promise<T> => {
-      if (attemptCount < failures.length && attemptCount < maxRetries) {
-        attemptCount++;
-        throw failures[attemptCount - 1];
-      }
-      attemptCount++;
-      return finalResult;
-    });
-  }
-
-  /**
-   * Test concurrent failure scenarios
-   */
-  static createConcurrentFailureMock<T>(
-    results: (T | Error)[]
-  ): ReturnType<typeof mock> {
-    let callIndex = 0;
-    
-    return mock(async (..._args: any[]): Promise<T> => {
-      const result = results[callIndex % results.length];
-      callIndex++;
-      
-      if (result instanceof Error) {
-        throw result;
-      }
-      
-      return result as T;
-    });
-  }
-}
-
-export default ErrorScenarios;

package/tests/utils/index.ts

@@ -1,3 +0,0 @@
-export { TestServerManager, testServerManager } from './test-server-manager.js';
-export { MockHelpers } from './mock-helpers.js';
-export { TestDataGenerators } from './test-data-generators.js';