@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/src/api-client.ts

@@ -1,307 +0,0 @@
-/**
- * Simple TeamCity API Client
- * Direct API wrapper without dependency injection or complex abstractions
- */
-import axios, { AxiosInstance } from 'axios';
-import axiosRetry from 'axios-retry';
-
-import { getTeamCityToken, getTeamCityUrl } from '@/config';
-import {
-  addRequestId,
-  logAndTransformError,
-  logResponse,
-  validateConfiguration,
-} from '@/teamcity/auth';
-import { TeamCityAPIError, isRetryableError } from '@/teamcity/errors';
-import { info } from '@/utils/logger';
-
-import { AgentApi } from './teamcity-client/api/agent-api';
-import { AgentPoolApi } from './teamcity-client/api/agent-pool-api';
-import { BuildApi } from './teamcity-client/api/build-api';
-import { BuildQueueApi } from './teamcity-client/api/build-queue-api';
-import { BuildTypeApi } from './teamcity-client/api/build-type-api';
-import { HealthApi } from './teamcity-client/api/health-api';
-import { ProjectApi } from './teamcity-client/api/project-api';
-import { ServerApi } from './teamcity-client/api/server-api';
-import { TestOccurrenceApi } from './teamcity-client/api/test-occurrence-api';
-import { VcsRootApi } from './teamcity-client/api/vcs-root-api';
-import { Configuration } from './teamcity-client/configuration';
-
-export class TeamCityAPI {
-  private static instance: TeamCityAPI;
-  private axiosInstance: AxiosInstance;
-  private config: Configuration;
-
-  // API instances
-  public builds: BuildApi;
-  public projects: ProjectApi;
-  public buildTypes: BuildTypeApi;
-  public buildQueue: BuildQueueApi;
-  public tests: TestOccurrenceApi;
-  public vcsRoots: VcsRootApi;
-  public agents: AgentApi;
-  public agentPools: AgentPoolApi;
-  public server: ServerApi;
-  public health: HealthApi;
-
-  private constructor(baseUrl: string, token: string) {
-    // Remove trailing slash from base URL
-    const basePath = baseUrl.replace(/\/$/, '');
-
-    // Validate configuration
-    const validation = validateConfiguration(basePath, token);
-    if (!validation.isValid) {
-      throw new Error(`Invalid TeamCity configuration: ${validation.errors.join(', ')}`);
-    }
-
-    // Create axios instance with basic config and default headers
-    this.axiosInstance = axios.create({
-      baseURL: basePath,
-      timeout: 30000,
-      headers: {
-        Authorization: `Bearer ${token}`,
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-      },
-    });
-
-    // Configure retry with exponential backoff and error classification
-    axiosRetry(this.axiosInstance, {
-      retries: 3,
-      retryDelay: (retryCount, error) => {
-        const reqId = (error?.config as { requestId?: string } | undefined)?.requestId;
-        const tcError = TeamCityAPIError.fromAxiosError(error, reqId);
-        // Prefer Retry-After when present (seconds), else exponential backoff
-        const retryAfter =
-          typeof (tcError as unknown as { retryAfter?: number }).retryAfter === 'number'
-            ? ((tcError as unknown as { retryAfter?: number }).retryAfter as number) * 1000
-            : undefined;
-        return retryAfter ?? Math.min(1000 * Math.pow(2, Math.max(0, retryCount - 1)), 8000);
-      },
-      retryCondition: (error) => {
-        const reqId = (error?.config as { requestId?: string } | undefined)?.requestId;
-        const tcError = TeamCityAPIError.fromAxiosError(error, reqId);
-        return isRetryableError(tcError);
-      },
-    });
-
-    // Attach interceptors: request ID, response logging, and error transform
-    this.axiosInstance.interceptors.request.use((config) => addRequestId(config));
-    this.axiosInstance.interceptors.response.use(logResponse, logAndTransformError);
-
-    // Create configuration for generated API clients
-    this.config = new Configuration({
-      basePath,
-      accessToken: token,
-      baseOptions: {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          Accept: 'application/json',
-        },
-      },
-    });
-
-    // Initialize API clients
-    this.builds = new BuildApi(this.config, basePath, this.axiosInstance);
-    this.projects = new ProjectApi(this.config, basePath, this.axiosInstance);
-    this.buildTypes = new BuildTypeApi(this.config, basePath, this.axiosInstance);
-    this.buildQueue = new BuildQueueApi(this.config, basePath, this.axiosInstance);
-    this.tests = new TestOccurrenceApi(this.config, basePath, this.axiosInstance);
-    this.vcsRoots = new VcsRootApi(this.config, basePath, this.axiosInstance);
-    this.agents = new AgentApi(this.config, basePath, this.axiosInstance);
-    this.agentPools = new AgentPoolApi(this.config, basePath, this.axiosInstance);
-    this.server = new ServerApi(this.config, basePath, this.axiosInstance);
-    this.health = new HealthApi(this.config, basePath, this.axiosInstance);
-
-    info('TeamCityAPI initialized', { baseUrl: basePath });
-  }
-
-  /**
-   * Get or create singleton instance
-   * @param baseUrl Optional base URL for testing
-   * @param token Optional token for testing
-   */
-  static getInstance(baseUrl?: string, token?: string): TeamCityAPI {
-    // If parameters are provided, create a new instance (for testing)
-    if (baseUrl && token) {
-      this.instance = new TeamCityAPI(baseUrl, token);
-      return this.instance;
-    }
-
-    // Otherwise use singleton pattern with centralized config
-    if (this.instance == null) {
-      const baseUrl = getTeamCityUrl();
-      const tokenStr = getTeamCityToken();
-      this.instance = new TeamCityAPI(baseUrl, tokenStr);
-    }
-    return this.instance;
-  }
-
-  /**
-   * Test connection to TeamCity server
-   */
-  async testConnection(): Promise<boolean> {
-    try {
-      await this.projects.getAllProjects(undefined, '$long,project($short)');
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Simple helper methods for common operations
-   */
-
-  async listProjects(locator?: string) {
-    const response = await this.projects.getAllProjects(locator);
-    return response.data;
-  }
-
-  async getProject(projectId: string) {
-    const response = await this.projects.getProject(projectId);
-    return response.data;
-  }
-
-  async listBuilds(locator?: string) {
-    const response = await this.builds.getAllBuilds(locator);
-    return response.data;
-  }
-
-  async getBuild(buildId: string) {
-    const response = await this.builds.getBuild(buildId);
-    return response.data;
-  }
-
-  async triggerBuild(buildTypeId: string, branchName?: string, comment?: string) {
-    const response = await this.buildQueue.addBuildToQueue(
-      false, // moveToTop
-      {
-        buildType: { id: buildTypeId },
-        branchName,
-        comment: { text: comment },
-        personal: false,
-      }
-    );
-    return response.data;
-  }
-
-  async getBuildLog(buildId: string) {
-    // Fetch raw build log as plain text. Prefer the HTML download endpoint,
-    // then fall back to the REST log endpoint with plain text.
-    // Ensure headers/responseType request text rather than JSON.
-    try {
-      const response = await this.axiosInstance.get(`/downloadBuildLog.html`, {
-        params: { buildId },
-        headers: { Accept: 'text/plain' },
-        responseType: 'text',
-        transformResponse: [(data) => data],
-      });
-      return response.data as string;
-    } catch (primaryError) {
-      // Fallback to REST endpoint (plain text)
-      const response = await this.axiosInstance.get(`/app/rest/builds/id:${buildId}/log`, {
-        params: { plain: true },
-        headers: { Accept: 'text/plain' },
-        responseType: 'text',
-        transformResponse: [(data) => data],
-      });
-      return response.data as string;
-    }
-  }
-
-  /**
-   * Fetch a chunk of the build log by line range.
-   * Attempts server-side pagination first; falls back to client-side slicing.
-   */
-  async getBuildLogChunk(
-    buildId: string,
-    options?: { startLine?: number; lineCount?: number }
-  ): Promise<{
-    lines: string[];
-    startLine: number;
-    nextStartLine?: number;
-    totalLines?: number;
-  }> {
-    const startLine = options?.startLine ?? 0;
-    const lineCount = options?.lineCount ?? 500;
-
-    // Try REST endpoint with start/count support (if available)
-    try {
-      const response = await this.axiosInstance.get(`/app/rest/builds/id:${buildId}/log`, {
-        params: {
-          plain: true,
-          start: startLine,
-          count: lineCount,
-        },
-        headers: { Accept: 'text/plain' },
-        responseType: 'text',
-        transformResponse: [(data) => data],
-      });
-      const text = (response.data as string) ?? '';
-      // Normalize newlines and split into lines consistently
-      const lines = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-      // Some servers may include an extra trailing empty line
-      if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
-
-      return {
-        lines,
-        startLine,
-        nextStartLine: lines.length === lineCount ? startLine + lines.length : undefined,
-      };
-    } catch {
-      // Fallback: fetch full log then slice locally
-      const full = await this.getBuildLog(buildId);
-      const allLines = full.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
-      if (allLines.length > 0 && allLines[allLines.length - 1] === '') allLines.pop();
-      const start = Math.max(0, Math.min(startLine, allLines.length));
-      const end = Math.min(allLines.length, start + lineCount);
-      const slice = allLines.slice(start, end);
-      return {
-        lines: slice,
-        startLine: start,
-        nextStartLine: end < allLines.length ? end : undefined,
-        totalLines: allLines.length,
-      };
-    }
-  }
-
-  async listBuildTypes(projectId?: string) {
-    const locator = projectId ? `affectedProject:(id:${projectId})` : undefined;
-    const response = await this.buildTypes.getAllBuildTypes(locator);
-    return response.data;
-  }
-
-  async getBuildType(buildTypeId: string) {
-    const response = await this.buildTypes.getBuildType(buildTypeId);
-    return response.data;
-  }
-
-  async listTestFailures(buildId: string) {
-    const response = await this.tests.getAllTestOccurrences(`build:(id:${buildId}),status:FAILURE`);
-    return response.data;
-  }
-
-  async listVcsRoots(projectId?: string) {
-    const locator = projectId ? `affectedProject:(id:${projectId})` : undefined;
-    const response = await this.vcsRoots.getAllVcsRoots(locator);
-    return response.data;
-  }
-
-  async listAgents() {
-    const response = await this.agents.getAllAgents();
-    return response.data;
-  }
-
-  async listAgentPools() {
-    const response = await this.agentPools.getAllAgentPools();
-    return response.data;
-  }
-
-  /**
-   * Reset instance (mainly for testing)
-   */
-  static reset() {
-    this.instance = null as unknown as TeamCityAPI;
-  }
-}

package/src/config/index.ts

@@ -1,286 +0,0 @@
-/**
- * Configuration management for TeamCity MCP Server
- */
-import dotenv from 'dotenv';
-import { z } from 'zod';
-
-import type { ApplicationConfig } from '@/types/config';
-
-// Load environment variables
-dotenv.config();
-
-// Environment variable schema
-const envSchema = z.object({
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
-  PORT: z.string().default('3000').transform(Number),
-  LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
-  MCP_MODE: z.enum(['dev', 'full']).default('dev'),
-  // Accept primary and alias names for TeamCity credentials
-  TEAMCITY_URL: z.string().url().optional(),
-  TEAMCITY_SERVER_URL: z.string().url().optional(),
-  TEAMCITY_TOKEN: z.string().optional(),
-  TEAMCITY_API_TOKEN: z.string().optional(),
-  // TeamCity connection and behavior knobs
-  TEAMCITY_TIMEOUT: z.string().optional(),
-  TEAMCITY_MAX_CONCURRENT: z.string().optional(),
-  TEAMCITY_KEEP_ALIVE: z.string().optional(),
-  TEAMCITY_COMPRESSION: z.string().optional(),
-  // Retry
-  TEAMCITY_RETRY_ENABLED: z.string().optional(),
-  TEAMCITY_MAX_RETRIES: z.string().optional(),
-  TEAMCITY_RETRY_DELAY: z.string().optional(),
-  TEAMCITY_MAX_RETRY_DELAY: z.string().optional(),
-  // Pagination
-  TEAMCITY_PAGE_SIZE: z.string().optional(),
-  TEAMCITY_MAX_PAGE_SIZE: z.string().optional(),
-  TEAMCITY_AUTO_FETCH_ALL: z.string().optional(),
-  // Circuit breaker
-  TEAMCITY_CIRCUIT_BREAKER: z.string().optional(),
-  TEAMCITY_CB_FAILURE_THRESHOLD: z.string().optional(),
-  TEAMCITY_CB_RESET_TIMEOUT: z.string().optional(),
-  TEAMCITY_CB_SUCCESS_THRESHOLD: z.string().optional(),
-});
-
-/**
- * Load and validate configuration from environment variables
- */
-export function loadConfig(): ApplicationConfig {
-  // Parse and validate environment variables
-  const env = envSchema.parse(process.env);
-
-  // Build configuration object
-  const config: ApplicationConfig = {
-    server: {
-      port: env.PORT,
-      host: '0.0.0.0',
-      nodeEnv: env.NODE_ENV,
-      logLevel: env.LOG_LEVEL,
-      mode: env.MCP_MODE,
-      cors: {
-        enabled: true,
-        origins: ['*'], // In production, specify allowed origins
-      },
-      rateLimit: {
-        enabled: env.NODE_ENV === 'production',
-        windowMs: 15 * 60 * 1000, // 15 minutes
-        maxRequests: 100,
-      },
-      timeout: {
-        server: 30000,
-        request: 10000,
-      },
-    },
-    mcp: {
-      name: 'teamcity-mcp',
-      version: '0.1.0',
-      protocolVersion: '1.0.0',
-      capabilities: {
-        tools: true,
-        prompts: false,
-        resources: false,
-      },
-      tools: {
-        enabled: [],
-        disabled: [],
-      },
-    },
-    features: {
-      realtime: false, // WebSocket/SSE support
-      caching: env.NODE_ENV === 'production',
-      metrics: false,
-    },
-  };
-
-  // Resolve TeamCity credentials from primary or alias vars
-  const tcUrl = env.TEAMCITY_URL ?? env.TEAMCITY_SERVER_URL;
-  const tcToken = env.TEAMCITY_TOKEN ?? env.TEAMCITY_API_TOKEN;
-  // Add TeamCity configuration if credentials are provided
-  if (tcUrl !== undefined && tcToken !== undefined) {
-    config.teamcity = {
-      url: tcUrl,
-      token: tcToken,
-      apiVersion: 'latest',
-      timeout: 30000,
-      retryConfig: {
-        maxRetries: 3,
-        retryDelay: 1000,
-        retryOnStatusCodes: [429, 500, 502, 503, 504],
-      },
-    };
-  }
-
-  return config;
-}
-
-/**
- * Get the current configuration
- * Caches the configuration after first load
- */
-let cachedConfig: ApplicationConfig | null = null;
-
-export function getConfig(): ApplicationConfig {
-  if (!cachedConfig) {
-    cachedConfig = loadConfig();
-  }
-  return cachedConfig;
-}
-
-/**
- * Reset configuration cache (useful for testing)
- */
-export function resetConfigCache(): void {
-  cachedConfig = null;
-}
-
-/**
- * Check if running in production mode
- */
-export function isProduction(): boolean {
-  return process.env['NODE_ENV'] === 'production';
-}
-
-/**
- * Check if running in development mode
- */
-export function isDevelopment(): boolean {
-  return process.env['NODE_ENV'] === 'development';
-}
-
-/**
- * Check if running in test mode
- */
-export function isTest(): boolean {
-  return process.env['NODE_ENV'] === 'test';
-}
-
-/**
- * Get MCP mode (dev or full)
- */
-export function getMCPMode(): 'dev' | 'full' {
-  // Always respect explicit MCP_MODE; default to 'dev'.
-  // Unit tests that need full mode should mock getMCPMode or set MCP_MODE explicitly.
-  return (process.env['MCP_MODE'] as 'dev' | 'full') ?? 'dev';
-}
-
-/**
- * Helper to parse boolean-like env flags: treat 'false' exactly as false, 'true' as true; undefined → defaultValue
- */
-function parseBoolFlag(value: string | undefined, defaultValue: boolean): boolean {
-  if (value === undefined) return defaultValue;
-  if (value.toLowerCase() === 'false') return false;
-  if (value.toLowerCase() === 'true') return true;
-  return defaultValue;
-}
-
-/**
- * Expose normalized TeamCity-related runtime options (centralized validation)
- */
-export function getTeamCityConnectionOptions(): {
-  timeout: number;
-  maxConcurrentRequests: number;
-  keepAlive: boolean;
-  compression: boolean;
-} {
-  const env = envSchema.parse(process.env);
-  return {
-    timeout: Number.parseInt(env.TEAMCITY_TIMEOUT ?? '30000', 10),
-    maxConcurrentRequests: Number.parseInt(env.TEAMCITY_MAX_CONCURRENT ?? '10', 10),
-    keepAlive: parseBoolFlag(env.TEAMCITY_KEEP_ALIVE, true),
-    compression: parseBoolFlag(env.TEAMCITY_COMPRESSION, true),
-  };
-}
-
-export function getTeamCityRetryOptions(): {
-  enabled: boolean;
-  maxRetries: number;
-  baseDelay: number;
-  maxDelay: number;
-} {
-  const env = envSchema.parse(process.env);
-  return {
-    enabled: parseBoolFlag(env.TEAMCITY_RETRY_ENABLED, true),
-    maxRetries: Number.parseInt(env.TEAMCITY_MAX_RETRIES ?? '3', 10),
-    baseDelay: Number.parseInt(env.TEAMCITY_RETRY_DELAY ?? '1000', 10),
-    maxDelay: Number.parseInt(env.TEAMCITY_MAX_RETRY_DELAY ?? '30000', 10),
-  };
-}
-
-export function getTeamCityPaginationOptions(): {
-  defaultPageSize: number;
-  maxPageSize: number;
-  autoFetchAll: boolean;
-} {
-  const env = envSchema.parse(process.env);
-  return {
-    defaultPageSize: Number.parseInt(env.TEAMCITY_PAGE_SIZE ?? '100', 10),
-    maxPageSize: Number.parseInt(env.TEAMCITY_MAX_PAGE_SIZE ?? '1000', 10),
-    autoFetchAll: parseBoolFlag(env.TEAMCITY_AUTO_FETCH_ALL, false),
-  };
-}
-
-export function getTeamCityCircuitBreakerOptions(): {
-  enabled: boolean;
-  failureThreshold: number;
-  resetTimeout: number;
-  successThreshold: number;
-} {
-  const env = envSchema.parse(process.env);
-  return {
-    enabled: parseBoolFlag(env.TEAMCITY_CIRCUIT_BREAKER, true),
-    failureThreshold: Number.parseInt(env.TEAMCITY_CB_FAILURE_THRESHOLD ?? '5', 10),
-    resetTimeout: Number.parseInt(env.TEAMCITY_CB_RESET_TIMEOUT ?? '60000', 10),
-    successThreshold: Number.parseInt(env.TEAMCITY_CB_SUCCESS_THRESHOLD ?? '2', 10),
-  };
-}
-
-/**
- * Convenience: fetch all TeamCity option groups at once
- */
-export function getTeamCityOptions(): {
-  connection: ReturnType<typeof getTeamCityConnectionOptions>;
-  retry: ReturnType<typeof getTeamCityRetryOptions>;
-  pagination: ReturnType<typeof getTeamCityPaginationOptions>;
-  circuitBreaker: ReturnType<typeof getTeamCityCircuitBreakerOptions>;
-} {
-  return {
-    connection: getTeamCityConnectionOptions(),
-    retry: getTeamCityRetryOptions(),
-    pagination: getTeamCityPaginationOptions(),
-    circuitBreaker: getTeamCityCircuitBreakerOptions(),
-  };
-}
-
-/**
- * Get TeamCity URL from configuration
- */
-export function getTeamCityUrl(): string {
-  const config = getConfig();
-  if (!config.teamcity?.url || config.teamcity.url.length === 0) {
-    // In test mode, provide a stable dummy URL so unit tests can mock HTTP calls
-    if (isTest()) {
-      return 'https://teamcity.example.com';
-    }
-    throw new Error('TeamCity URL not configured. Please set TEAMCITY_URL environment variable.');
-  }
-  return config.teamcity.url;
-}
-
-/**
- * Get TeamCity token from configuration
- */
-export function getTeamCityToken(): string {
-  const config = getConfig();
-  if (!config.teamcity?.token || config.teamcity.token.length === 0) {
-    // In test mode, provide a stable dummy token so unit tests can mock HTTP calls
-    if (isTest()) {
-      return 'test-token';
-    }
-    throw new Error(
-      'TeamCity token not configured. Please set TEAMCITY_TOKEN environment variable.'
-    );
-  }
-  return config.teamcity.token;
-}
-
-// Export type alias for backward compatibility
-export type Config = ApplicationConfig;

package/src/errors/index.ts

@@ -1,25 +0,0 @@
-/**
- * Central export for all error classes
- */
-
-export {
-  TeamCityAPIError,
-  TeamCityAuthenticationError,
-  TeamCityAuthorizationError,
-  TeamCityNotFoundError,
-  TeamCityValidationError,
-  TeamCityRateLimitError,
-  TeamCityServerError,
-  TeamCityNetworkError,
-  TeamCityRequestError,
-  TeamCityTimeoutError,
-  BuildNotFoundError,
-  BuildAccessDeniedError,
-  BuildConfigurationNotFoundError,
-  BuildConfigurationPermissionError,
-  BuildStepNotFoundError,
-  PermissionDeniedError,
-  ValidationError,
-  isRetryableError,
-  getRetryDelay,
-} from '@/teamcity/errors';