@daghis/teamcity-mcp 0.9.0 → 0.9.2

package/src/swagger/index.ts

@@ -1,220 +0,0 @@
-/**
- * Main module for TeamCity Swagger spec management
- */
-import { getConfig } from '@/config';
-import { info, error as logError, warn } from '@/utils/logger';
-
-import { SwaggerCache } from './swagger-cache';
-import { SwaggerFetcher, type SwaggerSpec } from './swagger-fetcher';
-import { SwaggerValidator } from './swagger-validator';
-
-export * from './swagger-fetcher';
-export * from './swagger-validator';
-export * from './swagger-cache';
-
-export interface SwaggerManagerConfig {
-  baseUrl?: string;
-  token?: string;
-  cacheDir?: string;
-  cacheTTL?: number;
-  forceRefresh?: boolean;
-}
-
-export class SwaggerManager {
-  private fetcher!: SwaggerFetcher;
-  private validator: SwaggerValidator;
-  private cache!: SwaggerCache;
-  private config: SwaggerManagerConfig;
-  private initialized: Promise<void>;
-
-  constructor(config: SwaggerManagerConfig = {}) {
-    this.config = config;
-    this.validator = new SwaggerValidator();
-
-    // Initialize synchronously
-    this.initialize();
-    this.initialized = Promise.resolve();
-  }
-
-  private initialize(): void {
-    // Get config from environment if not provided
-    const envConfig = getConfig();
-
-    this.config = {
-      baseUrl: this.config.baseUrl ?? envConfig.teamcity?.url ?? '',
-      token: this.config.token ?? envConfig.teamcity?.token ?? '',
-      cacheDir: this.config.cacheDir ?? '.cache',
-      cacheTTL: this.config.cacheTTL ?? 24 * 60 * 60 * 1000, // 24 hours
-      forceRefresh: this.config.forceRefresh ?? false,
-    };
-
-    if (this.config.baseUrl === '' || this.config.token === '') {
-      throw new Error('TeamCity base URL and token are required');
-    }
-
-    const baseUrl = this.config.baseUrl ?? '';
-    const token = this.config.token ?? '';
-    this.fetcher = new SwaggerFetcher({
-      baseUrl,
-      token,
-    });
-
-    this.cache = new SwaggerCache({
-      cacheDir: this.config.cacheDir ?? '.cache',
-      ttl: this.config.cacheTTL ?? 24 * 60 * 60 * 1000,
-    });
-
-    info('SwaggerManager initialized');
-  }
-
-  /**
-   * Get TeamCity Swagger specification (with caching)
-   */
-  async getSpec(): Promise<SwaggerSpec> {
-    await this.initialized;
-    const cacheKey = this.getCacheKey();
-
-    // Check cache first unless force refresh is requested
-    if (this.config.forceRefresh !== true) {
-      const cached = await this.cache.get(cacheKey);
-      if (cached) {
-        info('Using cached Swagger specification');
-        return cached;
-      }
-    }
-
-    // Fetch fresh spec
-    info('Fetching fresh Swagger specification from TeamCity');
-    const spec = await this.fetcher.fetchSpec();
-
-    // Validate the spec
-    const validation = this.validator.validateSpec(spec);
-    if (!validation.isValid) {
-      throw new Error(`Invalid Swagger specification: ${validation.errors?.join(', ')}`);
-    }
-
-    if (validation.warnings && validation.warnings.length > 0) {
-      warn('Swagger specification has warnings', { warnings: validation.warnings });
-    }
-
-    // Check TeamCity version compatibility
-    if (validation.teamCityVersion !== undefined && validation.teamCityVersion !== '') {
-      const isSupported = this.validator.isVersionSupported(validation.teamCityVersion);
-      if (!isSupported) {
-        warn('TeamCity version may not be fully supported', {
-          version: validation.teamCityVersion,
-          minSupported: '2020.1',
-        });
-      } else {
-        info('TeamCity version is supported', {
-          version: validation.teamCityVersion,
-        });
-      }
-    }
-
-    // Cache the validated spec
-    try {
-      await this.cache.set(cacheKey, spec);
-    } catch (err) {
-      // Caching failure is not critical
-      warn('Failed to cache Swagger spec', { error: err });
-    }
-
-    return spec;
-  }
-
-  /**
-   * Validate a Swagger specification
-   */
-  async validateSpec(spec?: SwaggerSpec): Promise<{
-    isValid: boolean;
-    version?: string;
-    teamCityVersion?: string;
-    errors?: string[];
-    warnings?: string[];
-  }> {
-    const specToValidate = spec ?? (await this.getSpec());
-    return this.validator.validateSpec(specToValidate);
-  }
-
-  /**
-   * Get TeamCity server information
-   */
-  async getServerInfo(): Promise<{
-    version: string | null;
-    connected: boolean;
-    specVersion?: string;
-  }> {
-    await this.initialized;
-    const connected = await this.fetcher.testConnection();
-    const version = await this.fetcher.getServerVersion();
-
-    let specVersion: string | undefined;
-    try {
-      const spec = await this.getSpec();
-      specVersion = spec.swagger ?? spec.openapi;
-    } catch (err) {
-      logError('Failed to get spec version', err instanceof Error ? err : new Error(String(err)));
-    }
-
-    const result: {
-      version: string | null;
-      connected: boolean;
-      specVersion?: string;
-    } = {
-      version,
-      connected,
-    };
-
-    if (specVersion !== undefined) {
-      result.specVersion = specVersion;
-    }
-
-    return result;
-  }
-
-  /**
-   * Clear cache
-   */
-  async clearCache(): Promise<void> {
-    await this.cache.clear();
-    info('Swagger cache cleared');
-  }
-
-  /**
-   * Get cache statistics
-   */
-  async getCacheStats(): Promise<{
-    size: number;
-    files: number;
-    oldestFile?: Date;
-    newestFile?: Date;
-  }> {
-    return await this.cache.getStats();
-  }
-
-  /**
-   * Generate cache key based on TeamCity URL
-   */
-  private getCacheKey(): string {
-    // Create a cache key based on the TeamCity URL
-    const baseUrl = this.config.baseUrl ?? '';
-    const url = new URL(baseUrl);
-    return `teamcity-swagger-${url.hostname}`;
-  }
-}
-
-/**
- * Singleton instance for convenience
- */
-let managerInstance: SwaggerManager | null = null;
-
-/**
- * Get or create SwaggerManager instance
- */
-export function getSwaggerManager(config?: SwaggerManagerConfig): SwaggerManager {
-  if (!managerInstance || config) {
-    managerInstance = new SwaggerManager(config);
-  }
-  return managerInstance;
-}

package/src/swagger/swagger-cache.ts

@@ -1,220 +0,0 @@
-/**
- * Cache manager for TeamCity Swagger specifications
- */
-import crypto from 'crypto';
-import fs from 'fs/promises';
-import path from 'path';
-
-import { debug, info, error as logError, warn } from '@/utils/logger';
-
-import type { SwaggerSpec } from './swagger-fetcher';
-
-export interface SwaggerCacheConfig {
-  cacheDir?: string;
-  ttl?: number; // Time to live in milliseconds
-}
-
-interface CachedSpec {
-  spec: SwaggerSpec;
-  timestamp: number;
-  hash?: string;
-}
-
-export class SwaggerCache {
-  private cacheDir: string;
-  private ttl: number;
-
-  constructor(config: SwaggerCacheConfig = {}) {
-    this.cacheDir = config.cacheDir ?? path.join(process.cwd(), '.cache');
-    this.ttl = config.ttl ?? 24 * 60 * 60 * 1000; // Default 24 hours
-
-    info('SwaggerCache initialized', {
-      cacheDir: this.cacheDir,
-      ttl: `${this.ttl / 1000 / 60 / 60} hours`,
-    });
-  }
-
-  /**
-   * Get cached spec if available and not expired
-   */
-  async get(key: string): Promise<SwaggerSpec | null> {
-    const filePath = this.getCacheFilePath(key);
-
-    try {
-      const data = await fs.readFile(filePath, 'utf-8');
-      const cached = JSON.parse(data) as CachedSpec;
-
-      // Check if cache is expired
-      const age = Date.now() - cached.timestamp;
-      if (age > this.ttl) {
-        info('Cache expired', {
-          key,
-          age: `${Math.round(age / 1000 / 60)} minutes`,
-          ttl: `${this.ttl / 1000 / 60} minutes`,
-        });
-        return null;
-      }
-
-      info('Cache hit', {
-        key,
-        age: `${Math.round(age / 1000 / 60)} minutes`,
-      });
-
-      return cached.spec;
-    } catch (err) {
-      if (err instanceof Error && err.message.includes('ENOENT')) {
-        debug('Cache miss - file not found', { key });
-      } else {
-        warn('Failed to read cache', { error: err });
-      }
-      return null;
-    }
-  }
-
-  /**
-   * Save spec to cache
-   */
-  async set(key: string, spec: SwaggerSpec): Promise<void> {
-    const filePath = this.getCacheFilePath(key);
-
-    try {
-      // Ensure cache directory exists
-      await fs.mkdir(this.cacheDir, { recursive: true });
-
-      // Create cached data with timestamp and hash
-      const cached: CachedSpec = {
-        spec,
-        timestamp: Date.now(),
-        hash: this.generateHash(spec),
-      };
-
-      // Write to cache file
-      await fs.writeFile(filePath, JSON.stringify(cached, null, 2), 'utf-8');
-
-      info('Spec cached successfully', {
-        key,
-        size: `${Math.round(JSON.stringify(cached).length / 1024)} KB`,
-      });
-    } catch (err) {
-      logError('Failed to cache spec', err instanceof Error ? err : new Error(String(err)));
-      throw new Error(
-        `Failed to cache spec: ${err instanceof Error ? err.message : 'Unknown error'}`
-      );
-    }
-  }
-
-  /**
-   * Clear cached spec
-   */
-  async clear(key?: string): Promise<void> {
-    try {
-      if (key !== undefined && key !== '') {
-        // Clear specific cache file
-        const filePath = this.getCacheFilePath(key);
-        await fs.unlink(filePath);
-        info('Cache cleared', { key });
-      } else {
-        // Clear all cache files
-        const files = await fs.readdir(this.cacheDir);
-        const jsonFiles = files.filter((f) => f.endsWith('.json'));
-
-        // Intentional sequential cleanup of small file list; IO is trivial and keeps logic simple
-        /* eslint-disable no-await-in-loop */
-        for (const file of jsonFiles) {
-          await fs.unlink(path.join(this.cacheDir, file));
-        }
-        /* eslint-enable no-await-in-loop */
-
-        info('All cache cleared', { count: jsonFiles.length });
-      }
-    } catch (err) {
-      if (err instanceof Error && err.message.includes('ENOENT')) {
-        debug('Cache file not found');
-      } else {
-        warn('Failed to clear cache', { error: err });
-      }
-    }
-  }
-
-  /**
-   * Check if cache exists and is valid
-   */
-  async isValid(key: string): Promise<boolean> {
-    const spec = await this.get(key);
-    return spec !== null;
-  }
-
-  /**
-   * Get cache statistics
-   */
-  async getStats(): Promise<{
-    size: number;
-    files: number;
-    oldestFile?: Date;
-    newestFile?: Date;
-  }> {
-    try {
-      const files = await fs.readdir(this.cacheDir);
-      const jsonFiles = files.filter((f) => f.endsWith('.json'));
-
-      let totalSize = 0;
-      let oldest: Date | undefined;
-      let newest: Date | undefined;
-
-      // Sequential stat calls; number of files is small and simplifies mtime tracking
-      /* eslint-disable no-await-in-loop */
-      for (const file of jsonFiles) {
-        const filePath = path.join(this.cacheDir, file);
-        const stats = await fs.stat(filePath);
-        totalSize += stats.size;
-
-        if (!oldest || stats.mtime < oldest) {
-          oldest = stats.mtime;
-        }
-        if (!newest || stats.mtime > newest) {
-          newest = stats.mtime;
-        }
-      }
-      /* eslint-enable no-await-in-loop */
-
-      const result: {
-        size: number;
-        files: number;
-        oldestFile?: Date;
-        newestFile?: Date;
-      } = {
-        size: totalSize,
-        files: jsonFiles.length,
-      };
-
-      if (oldest !== undefined) {
-        result.oldestFile = oldest;
-      }
-      if (newest !== undefined) {
-        result.newestFile = newest;
-      }
-
-      return result;
-    } catch (err) {
-      warn('Failed to get cache stats', { error: err });
-      return { size: 0, files: 0 };
-    }
-  }
-
-  /**
-   * Get cache file path for a key
-   */
-  private getCacheFilePath(key: string): string {
-    // Sanitize key for filesystem
-    const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, '_');
-    return path.join(this.cacheDir, `${safeKey}.json`);
-  }
-
-  /**
-   * Generate hash for spec content
-   */
-  private generateHash(spec: SwaggerSpec): string {
-    const content = JSON.stringify(spec);
-    return crypto.createHash('sha256').update(content).digest('hex').substring(0, 8);
-  }
-}

package/src/swagger/swagger-fetcher.ts

@@ -1,126 +0,0 @@
-/**
- * TeamCity Swagger specification fetcher
- */
-import axios, { type AxiosInstance } from 'axios';
-
-import { info, error as logError } from '@/utils/logger';
-
-export interface SwaggerFetcherConfig {
-  baseUrl: string;
-  token: string;
-  timeout?: number;
-}
-
-export interface SwaggerSpec {
-  swagger?: string;
-  openapi?: string;
-  info: {
-    version: string;
-    title: string;
-    description?: string;
-  };
-  paths: Record<string, unknown>;
-  [key: string]: unknown;
-}
-
-export class SwaggerFetcher {
-  private client: AxiosInstance;
-
-  constructor(config: SwaggerFetcherConfig) {
-    // Remove trailing slash from base URL
-    const baseUrl = config.baseUrl.replace(/\/$/, '');
-
-    this.client = axios.create({
-      baseURL: baseUrl,
-      timeout: config.timeout ?? 30000,
-      headers: {
-        Authorization: `Bearer ${config.token}`,
-        Accept: 'application/json',
-      },
-    });
-
-    info('SwaggerFetcher initialized', {
-      baseUrl,
-      timeout: config.timeout ?? 30000,
-    });
-  }
-
-  /**
-   * Fetch the Swagger/OpenAPI specification from TeamCity
-   */
-  async fetchSpec(): Promise<SwaggerSpec> {
-    try {
-      info('Fetching TeamCity Swagger specification...');
-
-      const response = await this.client.get<SwaggerSpec>('/app/rest/swagger.json');
-
-      if (response.status !== 200) {
-        throw new Error(`Failed to fetch Swagger spec: ${response.status}`);
-      }
-
-      const spec = response.data;
-
-      info('Successfully fetched Swagger specification', {
-        version: spec.swagger ?? spec.openapi ?? 'unknown',
-        title: spec.info?.title,
-        pathCount: Object.keys(spec.paths ?? {}).length,
-      });
-
-      return spec;
-    } catch (err) {
-      logError(
-        'Failed to fetch TeamCity Swagger spec',
-        err instanceof Error ? err : new Error(String(err))
-      );
-
-      if (axios.isAxiosError(err)) {
-        if (err.code === 'ECONNABORTED' || err.message.includes('timeout')) {
-          throw new Error(`Failed to fetch TeamCity Swagger spec: Request timeout`);
-        }
-        if (err.response?.status === 401) {
-          throw new Error(`Failed to fetch TeamCity Swagger spec: Authentication failed`);
-        }
-        if (err.response?.status === 404) {
-          throw new Error(`Failed to fetch TeamCity Swagger spec: Endpoint not found`);
-        }
-      }
-
-      throw new Error(
-        `Failed to fetch TeamCity Swagger spec: ${err instanceof Error ? err.message : 'Unknown error'}`
-      );
-    }
-  }
-
-  /**
-   * Test connection to TeamCity server
-   */
-  async testConnection(): Promise<boolean> {
-    try {
-      const response = await this.client.get('/app/rest/server');
-      return response.status === 200;
-    } catch (err) {
-      logError(
-        'TeamCity connection test failed',
-        err instanceof Error ? err : new Error(String(err))
-      );
-      return false;
-    }
-  }
-
-  /**
-   * Get TeamCity server version
-   */
-  async getServerVersion(): Promise<string | null> {
-    try {
-      const response = await this.client.get('/app/rest/server');
-      const data = response.data as { version?: string };
-      return data.version ?? null;
-    } catch (err) {
-      logError(
-        'Failed to get TeamCity server version',
-        err instanceof Error ? err : new Error(String(err))
-      );
-      return null;
-    }
-  }
-}