@daghis/teamcity-mcp 0.9.1 → 0.9.2

package/src/utils/validation.ts

@@ -1,284 +0,0 @@
-/**
- * Validation utility functions
- * Standardized validation using Zod schemas for consistent error handling
- */
-import { z } from 'zod';
-
-import { MCPValidationError } from '@/middleware/error';
-import { errorLogger } from '@/utils/error-logger';
-
-/**
- * Common Zod schemas used throughout the application
- */
-export const CommonSchemas = {
-  /**
-   * TeamCity URL schema
-   */
-  teamCityUrl: z
-    .string()
-    .url()
-    .refine(
-      (url) => {
-        try {
-          const parsed = new URL(url);
-          return parsed.protocol === 'http:' || parsed.protocol === 'https:';
-        } catch {
-          return false;
-        }
-      },
-      {
-        message: 'Must be a valid HTTP or HTTPS URL',
-      }
-    ),
-
-  /**
-   * Build configuration ID schema
-   */
-  buildConfigId: z
-    .string()
-    .min(1, 'Build config ID cannot be empty')
-    .max(225, 'Build config ID cannot exceed 225 characters')
-    .regex(
-      /^[a-zA-Z0-9_.-]+$/,
-      'Build config ID can only contain letters, numbers, underscores, dots, and hyphens'
-    ),
-
-  /**
-   * Branch name schema
-   */
-  branchName: z
-    .string()
-    .min(1, 'Branch name cannot be empty')
-    .max(255, 'Branch name cannot exceed 255 characters')
-    .refine((branch) => !/[\s~^:?*[\]\\]/.test(branch), {
-      message: 'Branch name cannot contain spaces or special characters (~^:?*[]\\)',
-    }),
-
-  /**
-   * Build parameters schema
-   */
-  buildParameters: z.record(
-    z.string().max(100, 'Parameter key cannot exceed 100 characters'),
-    z.union([z.string(), z.number(), z.boolean(), z.null()])
-  ),
-
-  /**
-   * Pagination schema
-   */
-  pagination: z.object({
-    limit: z.number().int().min(1).max(1000).default(100),
-    offset: z.number().int().min(0).default(0),
-  }),
-
-  /**
-   * Date range schema
-   */
-  dateRange: z
-    .object({
-      from: z.string().datetime().optional(),
-      to: z.string().datetime().optional(),
-    })
-    .refine(
-      (data) => {
-        if (
-          data.from !== null &&
-          data.from !== undefined &&
-          data.from.length > 0 &&
-          data.to !== null &&
-          data.to !== undefined &&
-          data.to.length > 0
-        ) {
-          return new Date(data.from) <= new Date(data.to);
-        }
-        return true;
-      },
-      {
-        message: 'Start date must be before end date',
-      }
-    ),
-};
-
-/**
- * Validation result interface
- */
-export interface ValidationResult<T> {
-  success: boolean;
-  data?: T;
-  error?: MCPValidationError;
-}
-
-/**
- * Validate data against a Zod schema
- */
-export function validateWithSchema<T>(
-  data: unknown,
-  schema: z.ZodSchema<T>,
-  context?: { operation?: string; field?: string }
-): ValidationResult<T> {
-  try {
-    const validatedData = schema.parse(data);
-    return { success: true, data: validatedData };
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const validationError = new MCPValidationError(
-        `Validation failed${context?.field && context.field.length > 0 ? ` for field '${context.field}'` : ''}`,
-        error
-      );
-
-      errorLogger.logError('Validation error', validationError, {
-        operation: context?.operation,
-        field: context?.field,
-        errors: error.errors,
-      });
-
-      return { success: false, error: validationError };
-    }
-
-    // Unexpected error during validation
-    const unexpectedError = new MCPValidationError('Unexpected validation error', undefined);
-
-    errorLogger.logError(
-      'Unexpected validation error',
-      error instanceof Error ? error : new Error(String(error)),
-      context
-    );
-
-    return { success: false, error: unexpectedError };
-  }
-}
-
-/**
- * Validate and transform data with a Zod schema, throwing on error
- */
-export function validateAndTransform<T>(
-  data: unknown,
-  schema: z.ZodSchema<T>,
-  context?: { operation?: string; field?: string }
-): T {
-  const result = validateWithSchema(data, schema, context);
-
-  if (!result.success) {
-    throw result.error ?? new MCPValidationError('Validation failed');
-  }
-
-  return result.data as T;
-}
-
-/**
- * Create a validation middleware for MCP tools
- */
-export function createValidationMiddleware<T>(
-  schema: z.ZodSchema<T>
-): (data: unknown, toolName: string) => T {
-  return (data: unknown, toolName: string): T => {
-    return validateAndTransform(data, schema, {
-      operation: toolName,
-      field: 'input',
-    });
-  };
-}
-
-/**
- * Legacy validation functions (deprecated - use Zod schemas instead)
- */
-
-/**
- * @deprecated Use CommonSchemas.teamCityUrl.safeParse() instead
- * Validates a TeamCity server URL
- */
-export const validateTeamCityUrl = (url: string): boolean => {
-  // Deprecated: Use CommonSchemas.teamCityUrl.safeParse() instead
-
-  const result = CommonSchemas.teamCityUrl.safeParse(url);
-  return result.success;
-};
-
-/**
- * @deprecated Use CommonSchemas.buildConfigId.safeParse() instead
- * Validates a build configuration ID
- */
-export const validateBuildConfigId = (id: string): boolean => {
-  // Deprecated: Use CommonSchemas.buildConfigId.safeParse() instead
-
-  const result = CommonSchemas.buildConfigId.safeParse(id);
-  return result.success;
-};
-
-/**
- * @deprecated Use CommonSchemas.branchName.safeParse() instead
- * Validates a branch name
- */
-export const validateBranchName = (branch: string): boolean => {
-  // Deprecated: Use CommonSchemas.branchName.safeParse() instead
-
-  const result = CommonSchemas.branchName.safeParse(branch);
-  return result.success;
-};
-
-/**
- * @deprecated Use CommonSchemas.buildParameters.safeParse() instead
- * Validates build parameters
- */
-export const validateBuildParameters = (
-  params: Record<string, unknown>
-): { valid: boolean; errors: string[] } => {
-  // Deprecated: Use CommonSchemas.buildParameters.safeParse() instead
-
-  const result = CommonSchemas.buildParameters.safeParse(params);
-
-  if (result.success) {
-    return { valid: true, errors: [] };
-  }
-
-  const errors = result.error.errors.map((err) => `${err.path.join('.')}: ${err.message}`);
-
-  return { valid: false, errors };
-};
-
-/**
- * Sanitizes a string for use in TeamCity API calls
- */
-export const sanitizeString = (input: string, maxLength = 255): string => {
-  if (!input || typeof input !== 'string') {
-    return '';
-  }
-
-  // Remove control characters and trim
-  // eslint-disable-next-line no-control-regex
-  let sanitized = input.replace(/[\u0000-\u001F\u007F]/g, '').trim();
-
-  // Truncate if needed
-  if (sanitized.length > maxLength) {
-    sanitized = sanitized.substring(0, maxLength);
-  }
-
-  return sanitized;
-};
-
-/**
- * Create a sanitized string schema
- */
-export const createSanitizedStringSchema = (maxLength = 255) => {
-  return z.string().transform((val) => sanitizeString(val, maxLength));
-};
-
-/**
- * Validation helper for optional fields
- */
-export const optional = <T>(schema: z.ZodSchema<T>) => {
-  return schema.optional();
-};
-
-/**
- * Validation helper for nullable fields
- */
-export const nullable = <T>(schema: z.ZodSchema<T>) => {
-  return schema.nullable();
-};
-
-/**
- * Create an enum schema from an array of strings
- */
-export const createEnumSchema = <T extends string>(values: readonly T[]) => {
-  return z.enum(values as [T, ...T[]]);
-};

package/tests/__mocks__/@modelcontextprotocol/sdk/server/index.js

@@ -1,31 +0,0 @@
-/**
- * Mock for @modelcontextprotocol/sdk/server/index.js
- */
-
-class Server {
-  constructor(serverInfo, options) {
-    this.serverInfo = serverInfo;
-    this.options = options;
-    this._capabilities = options?.capabilities;
-    this._requestHandlers = new Map();
-    this._connected = false;
-  }
-
-  setRequestHandler(schema, handler) {
-    this._requestHandlers.set(schema, handler);
-  }
-
-  async connect(transport) {
-    this._transport = transport;
-    this._connected = true;
-    return Promise.resolve();
-  }
-
-  async close() {
-    this._connected = false;
-    this._transport = null;
-    return Promise.resolve();
-  }
-}
-
-module.exports = { Server };

package/tests/__mocks__/@modelcontextprotocol/sdk/server/stdio.js

@@ -1,12 +0,0 @@
-/**
- * Mock for @modelcontextprotocol/sdk/server/stdio.js
- */
-
-class StdioServerTransport {
-  constructor() {
-    this.input = process.stdin;
-    this.output = process.stdout;
-  }
-}
-
-module.exports = { StdioServerTransport };

package/tests/__mocks__/@modelcontextprotocol/sdk/types.js

@@ -1,16 +0,0 @@
-/**
- * Mock for @modelcontextprotocol/sdk/types.js
- */
-
-const ListToolsRequestSchema = {
-  method: 'tools/list',
-};
-
-const CallToolRequestSchema = {
-  method: 'tools/call',
-};
-
-module.exports = {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-};

package/tests/development-tooling.test.ts

@@ -1,207 +0,0 @@
-/**
- * Tests for Development Tooling and Code Quality
- * Verifies that linting and formatting rules are properly configured
- */
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-
-import eslintConfig from '../.eslintrc.js';
-import packageJson from '../package.json';
-
-describe('Development Tooling and Code Quality', () => {
-  describe('ESLint Configuration', () => {
-    it('should have ESLint configuration file', () => {
-      const configPath = path.join(process.cwd(), '.eslintrc.js');
-      expect(fs.existsSync(configPath)).toBe(true);
-    });
-
-    it('should have TypeScript parser configured', () => {
-      expect(eslintConfig.parser).toBe('@typescript-eslint/parser');
-    });
-
-    it('should have TypeScript plugin configured', () => {
-      expect(eslintConfig.plugins).toContain('@typescript-eslint');
-    });
-
-    it('should have strict rules enabled', () => {
-      expect(eslintConfig.rules).toBeDefined();
-      expect(eslintConfig.rules['@typescript-eslint/no-explicit-any']).toBe('error');
-      expect(eslintConfig.rules['@typescript-eslint/strict-boolean-expressions']).toEqual([
-        'error',
-        expect.objectContaining({
-          allowString: true,
-          allowNumber: true,
-          allowNullableObject: true,
-          allowNullableBoolean: true,
-          allowNullableString: true,
-          allowNullableNumber: true,
-          allowAny: false,
-        }),
-      ]);
-    });
-
-    it('should successfully lint valid TypeScript code', () => {
-      const testFile = `
-export function testFunction(value: string): string {
-  return value.toUpperCase();
-}
-`;
-      // Put the temp file in tests directory which is covered by tsconfig
-      const tempFile = path.join(process.cwd(), 'tests', 'temp-test-lint.ts');
-      fs.writeFileSync(tempFile, testFile);
-
-      try {
-        const eslintJs = path.join(process.cwd(), 'node_modules', 'eslint', 'bin', 'eslint.js');
-        const node = process.execPath;
-        execSync(`"${node}" "${eslintJs}" ${tempFile}`, { stdio: 'pipe' });
-        // If no error is thrown, linting passed
-        expect(true).toBe(true);
-      } catch (error: unknown) {
-        // Linting failed
-        expect(error).toBeUndefined();
-      } finally {
-        fs.unlinkSync(tempFile);
-      }
-    });
-
-    it('should catch linting errors in invalid code', () => {
-      const testFile = `
-export function testFunction(value: any): any {
-  console.log(value)
-  return value
-}
-`;
-      // Put the temp file in tests directory which is covered by tsconfig
-      const tempFile = path.join(process.cwd(), 'tests', 'temp-test-lint-error.ts');
-      fs.writeFileSync(tempFile, testFile);
-
-      try {
-        const eslintJs = path.join(process.cwd(), 'node_modules', 'eslint', 'bin', 'eslint.js');
-        const node = process.execPath;
-        execSync(`"${node}" "${eslintJs}" ${tempFile}`, { stdio: 'pipe' });
-        // Should have thrown an error
-        expect(true).toBe(false);
-      } catch (error: unknown) {
-        // Expected to catch linting errors
-        expect(error).toBeDefined();
-      } finally {
-        fs.unlinkSync(tempFile);
-      }
-    });
-  });
-
-  describe('Prettier Configuration', () => {
-    it('should have Prettier configuration file', () => {
-      const configPath = path.join(process.cwd(), '.prettierrc');
-      expect(fs.existsSync(configPath)).toBe(true);
-    });
-
-    it('should have correct Prettier settings', () => {
-      const configContent = fs.readFileSync('.prettierrc', 'utf-8');
-      const config = JSON.parse(configContent);
-
-      expect(config.semi).toBe(true);
-      expect(config.trailingComma).toBe('es5');
-      expect(config.singleQuote).toBe(true);
-      expect(config.printWidth).toBe(100);
-      expect(config.tabWidth).toBe(2);
-    });
-
-    it('should format code according to Prettier rules', () => {
-      const unformattedCode = `const   test={foo:"bar",baz:42};`;
-      // Put the temp file in tests directory which is covered by tsconfig
-      const tempFile = path.join(process.cwd(), 'tests', 'temp-test-format.ts');
-      fs.writeFileSync(tempFile, unformattedCode);
-
-      try {
-        const prettierJs = path.join(
-          process.cwd(),
-          'node_modules',
-          'prettier',
-          'bin',
-          'prettier.cjs'
-        );
-        const node = process.execPath;
-        execSync(`"${node}" "${prettierJs}" --write ${tempFile}`, { stdio: 'pipe' });
-        const formattedCode = fs.readFileSync(tempFile, 'utf-8');
-
-        // Check that code was formatted
-        expect(formattedCode).toContain("const test = { foo: 'bar', baz: 42 };");
-      } finally {
-        fs.unlinkSync(tempFile);
-      }
-    });
-  });
-
-  describe('Git Hooks Configuration', () => {
-    it('does not require pre-commit hook', () => {
-      const preCommitHook = path.join(process.cwd(), '.husky/pre-commit');
-      expect(fs.existsSync(preCommitHook)).toBe(false);
-    });
-
-    it('does not require lint-staged configuration', () => {
-      const pkg = packageJson as unknown as Record<string, unknown>;
-      expect(Object.prototype.hasOwnProperty.call(pkg, 'lint-staged')).toBe(false);
-    });
-  });
-
-  describe('Development Scripts', () => {
-    it('should have dev script configured', () => {
-      expect(packageJson.scripts.dev).toBeDefined();
-    });
-
-    it('should have lint script configured', () => {
-      expect(packageJson.scripts.lint).toBeDefined();
-    });
-
-    it('should have format script configured', () => {
-      expect(packageJson.scripts.format).toBeDefined();
-    });
-
-    it('should have build script configured', () => {
-      expect(packageJson.scripts.build).toBeDefined();
-    });
-
-    it('should have test script configured', () => {
-      expect(packageJson.scripts.test).toBeDefined();
-    });
-  });
-
-  describe('Code Quality Integration', () => {
-    it('should pass linting for all source files', () => {
-      try {
-        const result = execSync('npm run lint', { stdio: 'pipe' });
-        expect(result).toBeDefined();
-      } catch (error: unknown) {
-        // If linting fails, show the error
-        const err = error as { stdout?: Buffer };
-        console.error('Linting failed:', err.stdout?.toString());
-        expect(err).toBeUndefined();
-      }
-    });
-
-    it('should have consistent formatting across all files', () => {
-      try {
-        // Check if files need formatting
-        const prettierJs = path.join(
-          process.cwd(),
-          'node_modules',
-          'prettier',
-          'bin',
-          'prettier.cjs'
-        );
-        const node = process.execPath;
-        const result = execSync(`"${node}" "${prettierJs}" --check "src/**/*.{ts,tsx}"`, {
-          stdio: 'pipe',
-        });
-        expect(result).toBeDefined();
-      } catch (error: unknown) {
-        // Files need formatting
-        const err = error as { stdout?: Buffer };
-        console.error('Files need formatting:', err.stdout?.toString());
-        expect(err).toBeUndefined();
-      }
-    });
-  });
-});

package/tests/e2e/cleanup.ts

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-import { MCPTestClient } from './mcp-client';
-
-function parseArgs(argv: string[]): { pattern: string; olderThanHours: number } {
-  const args = argv.slice(2);
-  let pattern = '^(E2E|MCP_E2E)';
-  let olderThanHours = 2;
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a === '--pattern' && i + 1 < args.length) pattern = args[++i] ?? pattern;
-    else if ((a === '--older-than-hours' || a === '--hours') && i + 1 < args.length) {
-      const next = args[++i] ?? String(olderThanHours);
-      const parsed = parseInt(next, 10);
-      olderThanHours = Number.isNaN(parsed) ? olderThanHours : parsed;
-    }
-  }
-  return { pattern, olderThanHours };
-}
-
-function extractTimestamp(str: string): number | null {
-  const m = str.match(/(\d{13})$/);
-  const ts = m?.[1];
-  if (typeof ts === 'string') return parseInt(ts, 10);
-  return null;
-}
-
-async function main(): Promise<void> {
-  const { pattern, olderThanHours } = parseArgs(process.argv);
-  const now = Date.now();
-  const cutoff = now - olderThanHours * 3600 * 1000;
-  const re = new RegExp(pattern);
-
-  const client = new MCPTestClient({ mode: 'full' });
-  await client.connect();
-  try {
-    const list = await client.callTool('list_projects', { all: true, maxPages: 50 });
-    const items: Array<{ id?: string; name?: string }> = (
-      typeof list === 'object' && list !== null && 'items' in (list as Record<string, unknown>)
-        ? (((list as { items?: unknown[] }).items as unknown[] | undefined) ?? [])
-        : []
-    ) as Array<{ id?: string; name?: string }>;
-    const targets = items.filter((p) => {
-      const id = String(p.id ?? '');
-      const name = String(p.name ?? '');
-      if (!re.test(id) && !re.test(name)) return false;
-      const ts = extractTimestamp(name) ?? extractTimestamp(id);
-      return ts != null ? ts < cutoff : true;
-    });
-
-    for (const p of targets) {
-      const id = String(p.id ?? '');
-      if (!id) continue;
-      try {
-        const res = await client.callTool('delete_project', { projectId: id });
-        process.stdout.write(`Deleted project ${id}: ${JSON.stringify(res)}\n`);
-      } catch (e) {
-        process.stderr.write(`Failed to delete ${id}: ${String(e)}\n`);
-      }
-    }
-  } finally {
-    await client.close();
-  }
-}
-
-main().catch((e) => {
-  console.error(e);
-  process.exit(1);
-});