@goonnguyen/human-mcp 1.3.0 → 2.0.0

package/tests/utils/mock-helpers.ts

@@ -1,99 +0,0 @@
-import { mock, type Mock } from 'bun:test';
-import type { MockError, MockHttpResponseData } from '../types/test-types.js';
-
-export interface MockedLogger {
-  info: Mock<() => void>;
-  error: Mock<() => void>;
-  warn: Mock<() => void>;
-  debug: Mock<() => void>;
-}
-
-export interface MockedFS {
-  readFileSync: Mock<() => Buffer>;
-  writeFileSync: Mock<() => void>;
-  existsSync: Mock<() => boolean>;
-  mkdirSync: Mock<() => void>;
-  unlinkSync: Mock<() => void>;
-}
-
-export interface MockedGeminiClient {
-  generateContent: Mock<() => Promise<any>>;
-  getGenerativeModel: Mock<() => any>;
-}
-
-export class MockHelpers {
-  static createLoggerMock(): MockedLogger {
-    return {
-      info: mock(() => {}),
-      error: mock(() => {}),
-      warn: mock(() => {}),
-      debug: mock(() => {})
-    };
-  }
-
-  static createFileSystemMock(): MockedFS {
-    return {
-      readFileSync: mock(() => Buffer.from('mock file content')),
-      writeFileSync: mock(() => {}),
-      existsSync: mock(() => true),
-      mkdirSync: mock(() => {}),
-      unlinkSync: mock(() => {})
-    };
-  }
-
-  static createGeminiClientMock(): MockedGeminiClient {
-    return {
-      generateContent: mock(() => Promise.resolve({
-        response: {
-          text: () => JSON.stringify({
-            summary: "Mock analysis result",
-            details: "Mock detailed analysis",
-            confidence: 0.95
-          })
-        }
-      })),
-      getGenerativeModel: mock(() => ({
-        generateContent: mock(() => Promise.resolve({
-          response: {
-            text: () => JSON.stringify({
-              summary: "Mock analysis result",
-              details: "Mock detailed analysis", 
-              confidence: 0.95
-            })
-          }
-        }))
-      }))
-    };
-  }
-
-  static resetAllMocks(mocks: Record<string, unknown>): void {
-    Object.values(mocks).forEach(mockObj => {
-      if (typeof mockObj === 'object' && mockObj !== null) {
-        Object.values(mockObj).forEach(mockFn => {
-          if (typeof mockFn === 'function' && 'mockRestore' in mockFn) {
-            (mockFn as Mock<any>).mockRestore();
-          }
-        });
-      }
-    });
-  }
-
-  static createMockResponse(data: MockHttpResponseData, status = 200): Response {
-    return new Response(JSON.stringify(data), {
-      status,
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    });
-  }
-
-  static createMockError(message: string, code?: string | number): MockError {
-    const error: MockError = { message };
-    if (code) {
-      error.code = code;
-    }
-    return error as MockError & Error;
-  }
-}
-
-export default MockHelpers;

package/tests/utils/test-data-generators.ts

@@ -1,217 +0,0 @@
-import type { MockAnalysisRequest, MockCompareRequest, MockGeminiResponse, MockComparisonResponse, MockHttpResponseData } from '../types/test-types.js';
-
-export class TestDataGenerators {
-  static createBase64Image(variant: 'small' | 'medium' | 'large' = 'small'): string {
-    // Different sized images for more realistic testing
-    const images = {
-      small: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
-      medium: 'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFklEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
-      large: 'iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAAOklEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJgggAAAABJRU5ErkJgggAAAABJRU5ErkJggg=='
-    };
-    return `data:image/png;base64,${images[variant]}`;
-  }
-
-  static createMockImageBuffer(size: number = 1024): Buffer {
-    // Create buffer with specified size for more realistic testing
-    const base64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==';
-    const buffer = Buffer.from(base64, 'base64');
-    // Pad buffer to reach desired size
-    return size > buffer.length ? Buffer.concat([buffer, Buffer.alloc(size - buffer.length)]) : buffer;
-  }
-
-  static createMockVideoFile(duration: number = 10): string {
-    // Mock MP4 file path with metadata
-    return `/tmp/test-video-${duration}s.mp4`;
-  }
-
-  static createMockGifFile(frames: number = 5): string {
-    // Mock GIF file path with metadata
-    return `/tmp/test-animation-${frames}frames.gif`;
-  }
-
-  static createMockAnalysisRequest(overrides: Partial<MockAnalysisRequest> = {}): MockAnalysisRequest {
-    const prompts = [
-      'Analyze the user interface elements and their layout',
-      'Focus on accessibility and usability issues',
-      'Identify any visual bugs or rendering problems',
-      'Review the overall design consistency',
-      'Check for mobile responsiveness indicators'
-    ];
-    
-    const selectedPrompt = prompts[Math.floor(Math.random() * prompts.length)];
-    
-    return {
-      input: TestDataGenerators.createBase64Image(),
-      detail_level: Math.random() > 0.5 ? 'detailed' : 'quick',
-      custom_prompt: selectedPrompt,
-      ...overrides
-    };
-  }
-
-  static createMockCompareRequest(overrides: Partial<MockCompareRequest> = {}): MockCompareRequest {
-    const prompts = [
-      'Compare the visual differences between these two UI states',
-      'Focus on layout and structural changes',
-      'Identify pixel-level differences and their impact',
-      'Compare accessibility features between versions',
-      'Analyze the user experience implications of changes'
-    ];
-    
-    const comparisonTypes: Array<'pixel' | 'structural' | 'semantic'> = ['pixel', 'structural', 'semantic'];
-    const selectedPrompt = prompts[Math.floor(Math.random() * prompts.length)];
-    const selectedType = comparisonTypes[Math.floor(Math.random() * comparisonTypes.length)];
-    
-    const baseRequest = {
-      input1: TestDataGenerators.createBase64Image('medium'),
-      input2: TestDataGenerators.createBase64Image('medium'),
-      comparison_type: selectedType as 'pixel' | 'structural' | 'semantic',
-      custom_prompt: selectedPrompt
-    };
-    
-    return Object.assign({}, baseRequest, overrides) as MockCompareRequest;
-  }
-
-  static createMockGeminiResponse(overrides: Partial<MockGeminiResponse> = {}): MockGeminiResponse {
-    const responses = [
-      {
-        summary: 'Screenshot shows a web application interface',
-        details: 'This image contains a modern web application with a navigation bar, sidebar, and main content area. The interface uses a clean design with blue accents.',
-        technical_details: {
-          dimensions: '1920x1080',
-          format: 'PNG',
-          colors: 'full color',
-          ui_elements: 'navigation, sidebar, content area'
-        },
-        confidence: 0.92,
-        recommendations: ['Consider improving color contrast', 'Add loading states for better UX']
-      },
-      {
-        summary: 'Mobile app screenshot with user interface elements',
-        details: 'This is a mobile application screenshot showing a login form with input fields and buttons. The design follows modern mobile UI patterns.',
-        technical_details: {
-          dimensions: '375x812',
-          format: 'JPEG',
-          colors: 'full color',
-          platform: 'mobile'
-        },
-        confidence: 0.88,
-        recommendations: ['Optimize for smaller screen sizes', 'Ensure touch targets are adequate']
-      },
-      {
-        summary: 'Code editor interface with syntax highlighting',
-        details: 'The image shows a code editor with syntax highlighting, line numbers, and a file tree. Multiple tabs are open showing different files.',
-        technical_details: {
-          dimensions: '1440x900',
-          format: 'PNG',
-          colors: 'dark theme',
-          editor: 'VS Code-like interface'
-        },
-        confidence: 0.96,
-        recommendations: ['Good use of syntax highlighting', 'Consider font size for readability']
-      }
-    ];
-    
-    const selectedResponse = responses[Math.floor(Math.random() * responses.length)];
-    return Object.assign({}, selectedResponse, overrides) as MockGeminiResponse;
-  }
-
-  static createMockComparisonResponse(overrides: Partial<MockComparisonResponse> = {}): MockComparisonResponse {
-    const responses = [
-      {
-        summary: 'Significant UI differences detected',
-        differences: [
-          'Button color changed from blue to green',
-          'Navigation bar height increased by 10px',
-          'New search icon added in header'
-        ],
-        similarity_score: 0.73,
-        analysis_method: 'semantic',
-        recommendations: [
-          'Review color accessibility standards',
-          'Test navigation changes with users',
-          'Ensure search functionality is intuitive'
-        ],
-        technical_details: {
-          image1_format: 'PNG',
-          image2_format: 'PNG',
-          comparison_method: 'semantic'
-        }
-      },
-      {
-        summary: 'Minor layout adjustments found',
-        differences: [
-          'Slight margin increase in content area',
-          'Font size reduced by 1px'
-        ],
-        similarity_score: 0.91,
-        analysis_method: 'structural',
-        recommendations: [
-          'Changes are minimal and unlikely to impact users',
-          'Consider A/B testing for optimal spacing'
-        ],
-        technical_details: {
-          image1_format: 'JPEG',
-          image2_format: 'PNG',
-          comparison_method: 'structural'
-        }
-      },
-      {
-        summary: 'Images are nearly identical',
-        differences: [],
-        similarity_score: 0.98,
-        analysis_method: 'pixel',
-        recommendations: ['No significant changes detected'],
-        technical_details: {
-          image1_format: 'PNG',
-          image2_format: 'PNG',
-          comparison_method: 'pixel'
-        }
-      }
-    ];
-    
-    const selectedResponse = responses[Math.floor(Math.random() * responses.length)];
-    return Object.assign({}, selectedResponse, overrides) as MockComparisonResponse;
-  }
-
-  static createMockFileStats() {
-    return {
-      isFile: () => true,
-      isDirectory: () => false,
-      size: 1024,
-      mtime: new Date(),
-      ctime: new Date()
-    };
-  }
-
-  static createMockHttpResponse(data: MockHttpResponseData, status = 200, headers: Record<string, string> = {}) {
-    return new Response(typeof data === 'string' ? data : JSON.stringify(data), {
-      status,
-      headers: {
-        'Content-Type': 'application/json',
-        ...headers
-      }
-    });
-  }
-
-  static createMockErrorResponse(message: string, status = 500) {
-    return new Response(JSON.stringify({ error: message }), {
-      status,
-      headers: { 'Content-Type': 'application/json' }
-    });
-  }
-
-  static generateRandomPort(): number {
-    return 3000 + Math.floor(Math.random() * 1000);
-  }
-
-  static createMockSessionData() {
-    return {
-      id: 'test-session-123',
-      created: Date.now(),
-      lastActivity: Date.now(),
-      data: {}
-    };
-  }
-}
-
-export default TestDataGenerators;

package/tests/utils/test-server-manager.ts

@@ -1,172 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { startHttpTransport } from "../../src/transports/http/server.js";
-import type { HttpTransportConfig, HttpServerHandle } from "../../src/transports/types.js";
-
-export class TestServerManager {
-  private servers: Map<number, HttpServerHandle> = new Map();
-  private usedPorts: Set<number> = new Set();
-
-  /**
-   * Get a random available port for testing using OS-level port checking
-   */
-  async getAvailablePort(): Promise<number> {
-    // Try sequential ports starting from a random high port
-    const basePort = 4000 + Math.floor(Math.random() * 1000);
-    const maxAttempts = 50;
-
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const port = basePort + attempt;
-      
-      if (!this.usedPorts.has(port) && await this.isPortAvailable(port)) {
-        this.usedPorts.add(port);
-        return port;
-      }
-    }
-
-    throw new Error(`Unable to find available port after ${maxAttempts} attempts (tried ${basePort} to ${basePort + maxAttempts - 1})`);
-  }
-
-  /**
-   * Check if a port is available using Node.js net module
-   */
-  private async isPortAvailable(port: number): Promise<boolean> {
-    return new Promise((resolve) => {
-      const net = require('net');
-      const server = net.createServer();
-      
-      server.listen(port, '127.0.0.1', () => {
-        server.close(() => {
-          resolve(true);
-        });
-      });
-      
-      server.on('error', () => {
-        resolve(false);
-      });
-    });
-  }
-
-  /**
-   * Start a test server with the given configuration
-   */
-  async startTestServer(config: Partial<HttpTransportConfig> = {}): Promise<{
-    server: HttpServerHandle;
-    port: number;
-    baseUrl: string;
-  }> {
-    const port = await this.getAvailablePort();
-    
-    // Create a basic MCP server for testing
-    const mcpServer = new McpServer(
-      {
-        name: "test-server",
-        version: "1.0.0"
-      },
-      {
-        capabilities: {
-          tools: {}
-        }
-      }
-    );
-
-    const serverConfig: HttpTransportConfig = {
-      port,
-      host: "127.0.0.1",
-      sessionMode: "stateful",
-      enableSse: true,
-      enableJsonResponse: true,
-      enableSseFallback: true,
-      ssePaths: {
-        stream: "/sse",
-        message: "/messages"
-      },
-      security: {
-        enableCors: true,
-        enableDnsRebindingProtection: true,
-        allowedHosts: ["127.0.0.1", "localhost"]
-      },
-      ...config
-    };
-
-    const server = await startHttpTransport(mcpServer, serverConfig);
-    this.servers.set(port, server);
-
-    // Wait for server to be ready
-    await this.waitForServerReady(port);
-
-    return {
-      server,
-      port,
-      baseUrl: `http://127.0.0.1:${port}`
-    };
-  }
-
-  /**
-   * Wait for server to be ready by checking health endpoint
-   */
-  private async waitForServerReady(port: number, timeout = 15000): Promise<void> {
-    const startTime = Date.now();
-    let lastError: Error | undefined;
-    
-    while (Date.now() - startTime < timeout) {
-      try {
-        const response = await fetch(`http://127.0.0.1:${port}/health`, {
-          signal: AbortSignal.timeout(2000)
-        });
-        
-        if (response.ok) {
-          const health = await response.json() as { status: string };
-          if (health.status === 'healthy') {
-            // Give the server a bit more time to fully initialize
-            await new Promise(resolve => setTimeout(resolve, 200));
-            return;
-          }
-        }
-      } catch (error) {
-        lastError = error as Error;
-        // Server not ready yet, continue waiting
-      }
-      
-      await new Promise(resolve => setTimeout(resolve, 250));
-    }
-    
-    throw new Error(`Server on port ${port} did not become ready within ${timeout}ms. Last error: ${lastError?.message || 'Unknown'}`);
-  }
-
-  /**
-   * Stop a specific server by port
-   */
-  async stopServer(port: number): Promise<void> {
-    const server = this.servers.get(port);
-    if (server) {
-      await server.close();
-      this.servers.delete(port);
-      this.usedPorts.delete(port);
-    }
-  }
-
-  /**
-   * Stop all test servers
-   */
-  async stopAllServers(): Promise<void> {
-    const stopPromises = Array.from(this.servers.keys()).map(port => this.stopServer(port));
-    await Promise.all(stopPromises);
-  }
-
-  /**
-   * Get the number of active servers
-   */
-  getActiveServerCount(): number {
-    return this.servers.size;
-  }
-
-  /**
-   * Check if any servers are still running
-   */
-  hasActiveServers(): boolean {
-    return this.servers.size > 0;
-  }
-}
-
-// Global test server manager instance
-export const testServerManager = new TestServerManager();

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "jsx": "react-jsx",
-    "allowJs": true,
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "baseUrl": "./src",
-    "paths": {
-      "@/*": ["*"]
-    }
-  },
-  "include": ["src/**/*", "tests/**/*"],
-  "exclude": ["node_modules", "dist"]
-}