@daghis/teamcity-mcp 0.1.2 → 0.1.3

package/src/middleware/global-error-handler.test.ts

@@ -1,239 +0,0 @@
-/**
- * Global error handler tests
- */
-import { AxiosError } from 'axios';
-
-import { errorLogger } from '@/utils/error-logger';
-
-import { MCPTeamCityError, MCPTimeoutError, MCPToolError } from './error';
-import { GlobalErrorHandler, globalErrorHandler } from './global-error-handler';
-
-// Mock the error logger
-jest.mock('@/utils/error-logger', () => ({
-  errorLogger: {
-    logError: jest.fn(),
-  },
-}));
-
-const mockErrorLogger = errorLogger.logError as jest.MockedFunction<typeof errorLogger.logError>;
-
-describe('GlobalErrorHandler', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    // Reset singleton
-    (GlobalErrorHandler as unknown as { instance?: GlobalErrorHandler }).instance = undefined;
-  });
-
-  describe('getInstance', () => {
-    it('should return singleton instance', () => {
-      const instance1 = GlobalErrorHandler.getInstance();
-      const instance2 = GlobalErrorHandler.getInstance();
-      expect(instance1).toBe(instance2);
-    });
-
-    it('should use provided options', () => {
-      const options = { includeStackTrace: false };
-      const instance = GlobalErrorHandler.getInstance(options);
-      expect(instance).toBeInstanceOf(GlobalErrorHandler);
-    });
-  });
-
-  describe('handleToolError', () => {
-    let handler: GlobalErrorHandler;
-
-    beforeEach(() => {
-      handler = new GlobalErrorHandler();
-    });
-
-    it('should handle MCPToolError', () => {
-      const mcpError = new MCPToolError('Tool error', 'TEST_CODE', 400);
-      const result = handler.handleToolError(mcpError, 'test-tool');
-
-      expect(result.success).toBe(false);
-      expect(result.error.code).toBe('TEST_CODE');
-      expect(result.error.message).toBe('Tool error');
-      expect(mockErrorLogger).toHaveBeenCalled();
-    });
-
-    it('should handle AxiosError', () => {
-      const axiosError = new AxiosError('Request failed');
-      axiosError.response = {
-        status: 404,
-        data: { message: 'Not found' },
-        statusText: 'Not Found',
-        headers: {},
-        config: {} as never,
-      };
-
-      const result = handler.handleToolError(axiosError, 'test-tool');
-
-      expect(result.success).toBe(false);
-      expect(result.error.code).toBe('TEAMCITY_ERROR');
-      expect(mockErrorLogger).toHaveBeenCalled();
-    });
-
-    it('should handle timeout errors', () => {
-      const timeoutError = new Error('Operation timeout');
-      const result = handler.handleToolError(timeoutError, 'test-tool');
-
-      expect(result.success).toBe(false);
-      expect(result.error.code).toBe('TIMEOUT_ERROR');
-    });
-
-    it('should handle rate limit errors', () => {
-      const rateLimitError = new Error('rate limit exceeded');
-      const result = handler.handleToolError(rateLimitError, 'test-tool');
-
-      expect(result.success).toBe(false);
-      expect(result.error.code).toBe('RATE_LIMIT_ERROR');
-    });
-
-    it('should handle unknown errors', () => {
-      const unknownError = 'string error';
-      const result = handler.handleToolError(unknownError, 'test-tool');
-
-      expect(result.success).toBe(false);
-      expect(result.error.code).toBe('INTERNAL_ERROR');
-    });
-
-    it('should not log when logging disabled', () => {
-      const handlerNoLog = new GlobalErrorHandler({ logErrors: false });
-      const error = new Error('Test error');
-
-      handlerNoLog.handleToolError(error, 'test-tool');
-
-      expect(mockErrorLogger).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('handleAsyncError', () => {
-    let handler: GlobalErrorHandler;
-
-    beforeEach(() => {
-      handler = new GlobalErrorHandler();
-    });
-
-    it('should transform and re-throw error', () => {
-      const error = new Error('Async error');
-
-      expect(() => {
-        handler.handleAsyncError(error, 'async-operation');
-      }).toThrow('Async error');
-
-      expect(mockErrorLogger).toHaveBeenCalled();
-    });
-
-    it('should handle AxiosError in async context', () => {
-      const axiosError = new AxiosError('Async request failed');
-      axiosError.response = {
-        status: 500,
-        data: {},
-        statusText: 'Internal Server Error',
-        headers: {},
-        config: {} as never,
-      };
-
-      expect(() => {
-        handler.handleAsyncError(axiosError, 'async-operation');
-      }).toThrow(MCPTeamCityError);
-    });
-  });
-
-  describe('transformAxiosError', () => {
-    let handler: GlobalErrorHandler;
-
-    beforeEach(() => {
-      handler = new GlobalErrorHandler();
-    });
-
-    it('should extract TeamCity error details', () => {
-      const axiosError = new AxiosError('Request failed');
-      axiosError.response = {
-        status: 400,
-        data: {
-          message: 'Build configuration not found',
-          errorCode: 'BC_NOT_FOUND',
-        },
-        statusText: 'Bad Request',
-        headers: {},
-        config: {} as never,
-      };
-
-      const result = handler.handleToolError(axiosError, 'test-tool');
-
-      expect(result.success).toBe(false);
-      expect(result.error.message).toBe('Build configuration not found');
-      expect(result.error.data).toMatchObject({
-        teamCityCode: 'BC_NOT_FOUND',
-      });
-    });
-  });
-
-  describe('sanitizeErrorMessage', () => {
-    let handler: GlobalErrorHandler;
-
-    beforeEach(() => {
-      handler = new GlobalErrorHandler({ sanitizeErrors: true });
-    });
-
-    it('should sanitize sensitive information', () => {
-      const sensitiveError = new Error('Failed with token=abc123 and password=secret');
-      const result = handler.handleToolError(sensitiveError, 'test-tool');
-
-      expect(result.error.message).toBe('Failed with token=*** and password=***');
-    });
-
-    it('should not sanitize in non-production mode', () => {
-      const handlerNoSanitize = new GlobalErrorHandler({ sanitizeErrors: false });
-      const sensitiveError = new Error('Failed with token=abc123');
-      const result = handlerNoSanitize.handleToolError(sensitiveError, 'test-tool');
-
-      expect(result.error.message).toBe('Failed with token=abc123');
-    });
-  });
-
-  describe('isRetryableError', () => {
-    let handler: GlobalErrorHandler;
-
-    beforeEach(() => {
-      handler = new GlobalErrorHandler();
-    });
-
-    it('should identify retryable TeamCity errors', () => {
-      const retryableError = new MCPTeamCityError('Server error', 500);
-      expect(handler.isRetryableError(retryableError)).toBe(true);
-
-      const nonRetryableError = new MCPTeamCityError('Bad request', 400);
-      expect(handler.isRetryableError(nonRetryableError)).toBe(false);
-    });
-
-    it('should identify retryable timeout errors', () => {
-      const timeoutError = new MCPTimeoutError('operation', 5000);
-      expect(handler.isRetryableError(timeoutError)).toBe(true);
-    });
-
-    it('should identify retryable network errors', () => {
-      const networkError = new AxiosError('Network error');
-      expect(handler.isRetryableError(networkError)).toBe(true);
-    });
-
-    it('should not retry client errors', () => {
-      const axiosError = new AxiosError('Client error');
-      axiosError.response = {
-        status: 400,
-        data: {},
-        statusText: 'Bad Request',
-        headers: {},
-        config: {} as never,
-      };
-
-      expect(handler.isRetryableError(axiosError)).toBe(false);
-    });
-  });
-});
-
-describe('globalErrorHandler singleton', () => {
-  it('should be available as singleton', () => {
-    expect(globalErrorHandler).toBeInstanceOf(GlobalErrorHandler);
-  });
-});

package/src/middleware/global-error-handler.ts

@@ -1,203 +0,0 @@
-/**
- * Global error handler for the MCP server
- * Provides centralized error handling, logging, and response formatting
- */
-import { AxiosError } from 'axios';
-
-import { ErrorContext, errorLogger } from '@/utils/error-logger';
-
-import {
-  ErrorResponse,
-  MCPRateLimitError,
-  MCPTeamCityError,
-  MCPTimeoutError,
-  MCPToolError,
-  formatError,
-} from './error';
-
-export interface GlobalErrorHandlerOptions {
-  includeStackTrace?: boolean;
-  sanitizeErrors?: boolean;
-  logErrors?: boolean;
-  defaultErrorMessage?: string;
-}
-
-/**
- * Global error handler class
- */
-export class GlobalErrorHandler {
-  private static instance: GlobalErrorHandler;
-
-  constructor(private readonly options: GlobalErrorHandlerOptions = {}) {
-    this.options = {
-      includeStackTrace: process.env['NODE_ENV'] !== 'production',
-      sanitizeErrors: process.env['NODE_ENV'] === 'production',
-      logErrors: true,
-      defaultErrorMessage: 'An unexpected error occurred',
-      ...options,
-    };
-  }
-
-  public static getInstance(options?: GlobalErrorHandlerOptions): GlobalErrorHandler {
-    if (GlobalErrorHandler.instance == null) {
-      GlobalErrorHandler.instance = new GlobalErrorHandler(options);
-    }
-    return GlobalErrorHandler.instance;
-  }
-
-  /**
-   * Handle error from MCP tool execution
-   */
-  handleToolError(error: unknown, toolName: string, context?: ErrorContext): ErrorResponse {
-    const enhancedContext: ErrorContext = {
-      ...context,
-      operation: toolName,
-      component: 'MCP_TOOL',
-    };
-
-    // Transform specific error types
-    const transformedError = this.transformError(error, enhancedContext);
-
-    // Log the error if enabled
-    if (this.options.logErrors) {
-      errorLogger.logError(
-        `Error in tool '${toolName}'`,
-        transformedError instanceof Error ? transformedError : new Error(String(transformedError)),
-        enhancedContext
-      );
-    }
-
-    // Format error response
-    return formatError(transformedError, enhancedContext);
-  }
-
-  /**
-   * Handle async operation errors
-   */
-  handleAsyncError(error: unknown, operationName: string, context?: ErrorContext): never {
-    const enhancedContext: ErrorContext = {
-      ...context,
-      operation: operationName,
-      component: 'ASYNC_HANDLER',
-    };
-
-    const transformedError = this.transformError(error, enhancedContext);
-
-    if (this.options.logErrors) {
-      errorLogger.logError(
-        `Async error in '${operationName}'`,
-        transformedError instanceof Error ? transformedError : new Error(String(transformedError)),
-        enhancedContext
-      );
-    }
-
-    throw transformedError;
-  }
-
-  /**
-   * Transform raw errors into structured MCP errors
-   */
-  private transformError(error: unknown, context: ErrorContext): Error {
-    // Already an MCP error
-    if (error instanceof MCPToolError) {
-      // Still sanitize the message if needed
-      if (this.options.sanitizeErrors) {
-        const sanitizedMessage = this.sanitizeErrorMessage(error.message);
-        return new MCPToolError(sanitizedMessage, error.code, error.statusCode, error.data);
-      }
-      return error;
-    }
-
-    // Axios/HTTP errors
-    if (error instanceof AxiosError) {
-      return this.transformAxiosError(error, context);
-    }
-
-    // Native errors
-    if (error instanceof Error) {
-      const sanitizedMessage = this.sanitizeErrorMessage(error.message);
-
-      // Check for specific error patterns
-      if (sanitizedMessage.includes('timeout') || error.name === 'TimeoutError') {
-        return new MCPTimeoutError(context.operation ?? 'unknown', 30000);
-      }
-
-      if (sanitizedMessage.includes('rate limit') || sanitizedMessage.includes('429')) {
-        return new MCPRateLimitError();
-      }
-
-      return new Error(sanitizedMessage);
-    }
-
-    // Unknown error types
-    return new Error(this.sanitizeErrorMessage(String(error)));
-  }
-
-  /**
-   * Transform Axios errors into MCPTeamCityError
-   */
-  private transformAxiosError(axiosError: AxiosError, context: ErrorContext): MCPTeamCityError {
-    const status = axiosError.response?.status ?? 500;
-    const data = axiosError.response?.data;
-
-    let message = axiosError.message;
-    let teamCityCode: string | undefined;
-
-    // Extract TeamCity-specific error information
-    if (data != null && typeof data === 'object') {
-      if ('message' in data && typeof data.message === 'string') {
-        message = data.message;
-      }
-      if ('errorCode' in data && typeof data.errorCode === 'string') {
-        teamCityCode = data.errorCode;
-      }
-    }
-
-    return new MCPTeamCityError(
-      this.sanitizeErrorMessage(message),
-      status,
-      teamCityCode,
-      context.requestId
-    );
-  }
-
-  /**
-   * Sanitize error messages for production
-   */
-  private sanitizeErrorMessage(message: string): string {
-    if (!this.options.sanitizeErrors) {
-      return message;
-    }
-
-    // Remove sensitive information patterns
-    return message
-      .replace(/token[=:]\s*[^\s&]+/gi, 'token=***')
-      .replace(/password[=:]\s*[^\s&]+/gi, 'password=***')
-      .replace(/apikey[=:]\s*[^\s&]+/gi, 'apikey=***')
-      .replace(/authorization:\s*[^\s&]+/gi, 'authorization: ***');
-  }
-
-  /**
-   * Check if error should be retried
-   */
-  isRetryableError(error: unknown): boolean {
-    if (error instanceof MCPTeamCityError) {
-      // Retry on temporary server errors
-      return error.statusCode >= 500 && error.statusCode < 600;
-    }
-
-    if (error instanceof MCPTimeoutError) {
-      return true;
-    }
-
-    if (error instanceof AxiosError) {
-      // Network errors or temporary server issues
-      return !error.response || (error.response.status >= 500 && error.response.status < 600);
-    }
-
-    return false;
-  }
-}
-
-// Export singleton instance
-export const globalErrorHandler = GlobalErrorHandler.getInstance();

package/src/middleware/index.ts

@@ -1,5 +0,0 @@
-/**
- * Middleware module exports
- */
-
-export * from './error';

package/src/server.ts

@@ -1,126 +0,0 @@
-/**
- * Simple MCP Server for TeamCity
- * Direct implementation without complex abstractions
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import {
-  CallToolRequestSchema,
-  ErrorCode,
-  ListToolsRequestSchema,
-  McpError,
-} from '@modelcontextprotocol/sdk/types.js';
-
-import { info, debug as logDebug, error as logError } from '@/utils/logger';
-
-import { getConfig } from './config';
-import { getAvailableTools, getMCPMode, getTool } from './tools';
-
-/**
- * Create a simple MCP server
- */
-export function createMCPServer(): Server {
-  return createSimpleServer();
-}
-
-export function createSimpleServer(): Server {
-  // Server initialization
-  const _config = getConfig();
-
-  // Load available tools to validate configuration
-  getAvailableTools();
-
-  const server = new Server(
-    {
-      name: 'teamcity-mcp',
-      version: '0.1.0',
-    },
-    {
-      capabilities: {
-        tools: {},
-        prompts: undefined,
-        resources: undefined,
-      },
-    }
-  );
-
-  // Register tool listing handler
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const currentTools = getAvailableTools(); // Get fresh list in case env changed
-    // Listing tools in current mode
-    info('MCP request: tools/list', { mode: getMCPMode(), count: currentTools.length });
-
-    const response = {
-      tools: currentTools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-      })),
-    };
-    logDebug('MCP response: tools/list', { count: response.tools.length, success: true });
-    return response;
-  });
-
-  // Register tool execution handler
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    // Executing tool with arguments
-    const started = Date.now();
-    info('MCP request: tools/call', { tool: name, args });
-
-    const tool = getTool(name);
-    if (!tool) {
-      // Unknown tool requested
-      const availableTools = getAvailableTools();
-      logError('MCP error: unknown tool', undefined, {
-        tool: name,
-        available: availableTools.map((t) => t.name),
-        mode: getMCPMode(),
-      });
-      throw new McpError(
-        ErrorCode.MethodNotFound,
-        `Unknown tool: ${name}. Available tools in ${getMCPMode().toUpperCase()} mode: ${availableTools.map((t) => t.name).join(', ')}`
-      );
-    }
-
-    try {
-      const result = await tool.handler(args ?? {});
-      // Tool executed successfully
-      // MCP SDK expects a specific format for tool responses
-      const response = {
-        content: result.content ?? [
-          { type: 'text', text: result.error ?? 'Tool executed successfully' },
-        ],
-      };
-      const duration = Date.now() - started;
-      const success = result?.success !== false;
-      logDebug('MCP response: tools/call', {
-        tool: name,
-        success,
-        duration,
-        contentTypes: response.content?.map((c) => c.type),
-      });
-      return response;
-    } catch (error) {
-      // Tool execution failed
-
-      if (error instanceof McpError) {
-        const duration = Date.now() - started;
-        logError('MCP error: tool call', error, { tool: name, success: false, duration });
-        throw error;
-      }
-
-      const duration = Date.now() - started;
-      logError('MCP error: tool call (unexpected)', error, {
-        tool: name,
-        success: false,
-        duration,
-      });
-      throw new McpError(
-        ErrorCode.InternalError,
-        `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  });
-
-  return server;
-}