@daghis/teamcity-mcp 0.1.2

package/src/utils/validation.ts

@@ -0,0 +1,284 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,207 @@
+/**
+ * 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

@@ -0,0 +1,68 @@
+#!/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);
+});