Как я научил TeamCity говорить с ИИ через MCP, или История одного протокола

{
    "mcpServers": {
        "teamcity": {
            "command": "docker",
            "args": [
                "run",
                "--rm",
                "-i",
                "-e",
                "TC_URL",
                "-e",
                "TC_TOKEN",
                "teamcity-mcp:latest",
                "--transport",
                "stdio"
            ],
            "env": {
                "TC_URL": "https://teamcity.com",
                "TC_TOKEN": "you-token-here"
            }
        }
    }
}

# Что попросил пользователь:
"Запусти билд для проекта MyApp"

# Что сгенерировал GPT:
curl -X POST https://teamcity.com/api/builds/trigger \
  -d '{"project": "MyApp", "action": "build"}' # 🚨 Неправильный endpoint и формат

Промпт: "Используй TeamCity REST API для получения списка билдов"
LLM: "Конечно! Вот запрос: GET /builds" 
Реальность: Endpoint /app/rest/builds, нужна аутентификация, локаторы, пагинация...

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   AI Agent      │    │   teamcity-mcp   │    │    TeamCity     │
│   (Claude)      │◄──►│     Server       │◄──►│    REST API     │
│                 │    │                  │    │                 │
└─────────────────┘    └──────────────────┘    └─────────────────┘
     JSON-RPC 2.0            Go 1.23+               HTTP/JSON

// Ресурс — просто данные
{
  "uri": "teamcity://builds/12345",
  "name": "Build #12345",
  "mimeType": "application/json",
  "text": "{\"id\": 12345, \"status\": \"SUCCESS\"}"
}

// Инструмент — функция с валидацией
{
  "name": "trigger_build",
  "inputSchema": {
    "type": "object",
    "properties": {
      "buildTypeId": {"type": "string", "pattern": "^[A-Za-z0-9_]+$"}
    },
    "required": ["buildTypeId"]
  }
}

# Клиент должен прислать HMAC-токен в заголовке
Authorization: Bearer your-hmac-secret-key

# А сервер использует TeamCity API токен для вызовов
TC_TOKEN=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...

C/C++     ████████████████████████████████████████ (performance)
Rust      ████████████████████████████████████████ (performance)
Go        ███████████████████████████████████████  (performance)
Java      ████████████████████████████████████     (performance)
Node.js   ████████████████████████████             (performance)
Python    ████████████████████                     (performance)

Python    ████████████████████████████████████████ (dev speed)
Go        ███████████████████████████████████████  (dev speed)
Node.js   ████████████████████████████████████     (dev speed)
Java      ████████████████████████████             (dev speed)
Rust      ████████████████████                     (dev speed)
C/C++     ████████████                             (dev speed)

// Конкурентность из коробки
go func() {
    // Горутина весит ~2KB памяти
    // vs ~2MB для thread в Java
    handleMCPRequest(request)
}()

// Каналы для синхронизации
results := make(chan BuildResult, 100)
go buildWorker(results)

// Веб-сокеты для MCP
github.com/gorilla/websocket v1.5.1

// Структурированное логирование
go.uber.org/zap v1.26.0

// Метрики
github.com/prometheus/client_golang v1.18.0

// Тестирование
github.com/stretchr/testify v1.8.4

type Cache struct {
    data map[string]cacheEntry
    mu   sync.RWMutex  // Читатели не блокируют друг друга
    ttl  time.Duration
}

type cacheEntry struct {
    value     interface{}
    expiresAt time.Time
    mutex     sync.Mutex  // Per-entry lock для cache stampede protection
}

func (c *Cache) GetOrFetch(key string, fetcher func() (interface{}, error)) (interface{}, error) {
    // Cache stampede protection: если несколько горутин запрашивают один ключ,
    // только одна будет делать fetch, остальные подождут
    c.mu.RLock()
    entry, exists := c.data[key]
    c.mu.RUnlock()
    
    if exists && time.Now().Before(entry.expiresAt) {
        metrics.RecordCacheHit()
        return entry.value, nil
    }
    
    // Только одна горутина на ключ будет делать fetch
    entry.mutex.Lock()
    defer entry.mutex.Unlock()
    
    // Double-check после получения lock
    if time.Now().Before(entry.expiresAt) {
        return entry.value, nil
    }
    
    value, err := fetcher()
    if err != nil {
        return nil, err
    }
    
    c.set(key, value)
    metrics.RecordCacheMiss()
    return value, nil
}

Latency comparison:
In-memory map:     ~10ns
Redis localhost:   ~100μs (в 10,000 раз медленнее!)
Redis network:     ~1ms   (в 100,000 раз медленнее!)

// LRU eviction при достижении лимита памяти
func (c *Cache) cleanup() {
    ticker := time.NewTicker(c.ttl / 2)
    for range ticker.C {
        c.mu.Lock()
        now := time.Now()
        for key, entry := range c.data {
            if now.After(entry.expiresAt) {
                delete(c.data, key)
            }
        }
        c.mu.Unlock()
    }
}

logger.Info("Triggering build",
    "buildTypeId", buildTypeId,
    "branchName", branchName,
    "requestId", requestId,
    "duration", duration.Seconds())

// Количество MCP запросов
mcp_requests_total{method="trigger_build",status="success"} 42

// Время ответа TeamCity API
teamcity_api_duration_seconds{endpoint="/app/rest/builds"} 0.123

// Статистика кэша
cache_hits_total 156
cache_misses_total 23

FROM golang:1.23-alpine AS builder
# ... сборка приложения
FROM scratch
COPY --from=builder /app/teamcity-mcp /teamcity-mcp
ENTRYPOINT ["/teamcity-mcp"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: teamcity-mcp
spec:
  replicas: 1  # Потому что stateful сервис
  # ... остальная конфигурация

# Обязательные
export TC_URL="https://your-teamcity-server.com"
export TC_TOKEN="your-api-token"

# Опциональные
export SERVER_SECRET="your-hmac-secret"
export LOG_LEVEL="info"
export CACHE_TTL="10s"

        /\
       /  \     E2E Tests (медленные, хрупкие, дорогие)
      /____\
     /      \
    /        \   Integration Tests
   /__________\
  /            \
 /              \ Unit Tests (быстрые, стабильные, дешёвые)
/________________\

      /\
     /  \    E2E
    /____\
   /      \
  /        \  Integration (больший фокус)
 /          \
/____________\
/            \
\    Unit    / Static Analysis (линтеры, типы)
 \__________/

// ❌ Плохо: мокаем всё подряд
func TestBadExample(t *testing.T) {
    mockTime := &MockTime{}
    mockLogger := &MockLogger{}
    mockMetrics := &MockMetrics{}
    mockCache := &MockCache{}
    mockTC := &MockTeamCityClient{}
    
    // Тест превращается в проверку взаимодействия моков
}

// ✅ Хорошо: мокаем только внешние зависимости
func TestTriggerBuild(t *testing.T) {
    mockTC := &MockTeamCityClient{}
    mockTC.On("TriggerBuild", mock.MatchedBy(func(req *TriggerRequest) bool {
        return req.BuildTypeID == "MyProject_Build" && 
               req.BranchName == "main"
    })).Return(&BuildResponse{ID: "12345"}, nil)
    
    // Реальные объекты для бизнес-логики
    cache := cache.New(10 * time.Second)
    logger := logging.NewTest()
    
    handler := NewHandler(mockTC, cache, logger)
    
    result, err := handler.TriggerBuild(context.Background(), &TriggerBuildRequest{
        BuildTypeID: "MyProject_Build",
        BranchName:  "main",
    })
    
    assert.NoError(t, err)
    assert.Equal(t, "12345", result.BuildID)
    mockTC.AssertExpectations(t)
}

// Dummy — заглушка, не используется в тесте
type DummyLogger struct{}
func (d *DummyLogger) Info(msg string, fields ...interface{}) {}

// Stub — возвращает заранее определённые данные
type StubTeamCity struct{}
func (s *StubTeamCity) GetBuilds() []Build { 
    return []Build{{ID: "123", Status: "SUCCESS"}} 
}

// Mock — проверяет взаимодействие
type MockTeamCity struct {
    mock.Mock
}
func (m *MockTeamCity) TriggerBuild(req *TriggerRequest) (*BuildResponse, error) {
    args := m.Called(req)
    return args.Get(0).(*BuildResponse), args.Error(1)
}

// Spy — записывает вызовы для последующей проверки
type SpyMetrics struct {
    calls []string
}
func (s *SpyMetrics) RecordRequest(method string) {
    s.calls = append(s.calls, method)
}

func TestMCPProtocol(t *testing.T) {
    // Запускаем реальный сервер
    server := setupTestServer(t)
    defer server.Close()
    
    // Тестируем MCP протокол
    response := sendMCPRequest(server.URL, initializeRequest)
    assert.Equal(t, "2024-11-05", response.ProtocolVersion)
}

name: CI/CD Pipeline
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-go@v4
      with:
        go-version: 1.23
    - run: make test

- name: Run Trivy vulnerability scanner
  uses: aquasecurity/trivy-action@master
  with:
    scan-type: 'fs'
    format: 'sarif'

// Counter — монотонно растущее значение
mcp_requests_total{method="trigger_build",status="success"} 42

// Gauge — текущее значение
active_connections 15
memory_usage_bytes 1048576

// Histogram — распределение значений
http_request_duration_seconds_bucket{le="0.1"} 100
http_request_duration_seconds_bucket{le="0.5"} 200
http_request_duration_seconds_bucket{le="1.0"} 250

{
  "timestamp": "2024-01-15T10:30:00Z",
  "level": "error",
  "message": "Failed to trigger build",
  "buildTypeId": "MyProject_Build",
  "error": "connection timeout",
  "trace_id": "abc123",
  "duration_ms": 5000
}

Request: trigger_build [total: 1.2s]
├── validate_request [50ms]
├── check_cache [5ms] ❌ cache miss
├── teamcity_api_call [1.1s] ⚠️ slow!
│   ├── auth [100ms]
│   ├── http_request [900ms] 🐌
│   └── parse_response [100ms]
└── update_cache [45ms]

// SLI (Service Level Indicators) — что измеряем
var (
    // Latency — как быстро отвечаем
    requestDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name: "mcp_request_duration_seconds",
            Help: "Time spent processing MCP requests",
            Buckets: []float64{0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0},
        },
        []string{"method", "status"},
    )
    
    // Throughput — сколько обрабатываем
    requestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "mcp_requests_total",
            Help: "Total number of MCP requests",
        },
        []string{"method", "status"},
    )
    
    // Error Rate — сколько падает
    errorsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "mcp_errors_total", 
            Help: "Total number of MCP errors",
        },
        []string{"method", "error_type"},
    )
    
    // Saturation — насколько загружены
    activeConnections = prometheus.NewGauge(
        prometheus.GaugeOpts{
            Name: "mcp_active_connections",
            Help: "Number of active MCP connections",
        },
    )
)

# Что обещаем пользователям
slos:
  availability: 99.9%  # Uptime
  latency_p95: 500ms   # 95% запросов быстрее 500ms
  latency_p99: 1000ms  # 99% запросов быстрее 1s
  error_rate: <1%      # Меньше 1% ошибок

# Сколько запросов обрабатываем
mcp_requests_total{method="trigger_build",status="success"} 42

# Как быстро отвечает TeamCity
teamcity_api_duration_seconds{endpoint="/builds"} 0.123

# Насколько эффективен кэш
cache_hit_ratio 0.87

func (h *HealthHandler) ReadinessCheck() error {
    // Проверяем доступность TeamCity
    if err := h.teamcity.Ping(); err != nil {
        return fmt.Errorf("TeamCity unavailable: %w", err)
    }
    return nil
}

Human: Посмотри на этот PR и запусти соответствующие тесты

AI: Анализирую изменения в PR #123...
    Обнаружены изменения в модуле `auth`
    Запускаю билд Auth_UnitTests...
    Билд #456 запущен, статус: RUNNING
    Ожидаемое время выполнения: 3 минуты

Human: Почему билды Auth_Service падают последние 2 дня?

AI: Анализирую историю сборок Auth_Service...
    Найдено 23 неудачных билда за последние 48 часов
    Основные причины:
    - 67% падений из-за "connection timeout to database"
    - 21% из-за "test_user_permissions failed"
    - 12% из-за "insufficient memory"
    
    Рекомендую проверить подключение к БД и увеличить memory limit

Human: Подготовь релиз версии 1.2.3

AI: Проверяю готовность к релизу...
    ✅ Все тесты прошли успешно
    ✅ Билд main ветки зелёный
    ✅ Артефакты собраны
    
    Запускаю билд Release_Deploy с параметром VERSION=1.2.3...
    Билд #789 запущен. Артефакты будут доступны через 5 минут.

// Управление агентами
type AgentManager interface {
    EnableAgent(agentID string) error
    DisableAgent(agentID string) error  
    RestartAgent(agentID string) error
}

// Управление проектами  
type ProjectManager interface {
    CreateProject(spec *ProjectSpec) (*Project, error)
    UpdateProject(id string, spec *ProjectSpec) error
    ArchiveProject(id string) error
}

// TeamCity WebHook -> MCP Event Stream
type EventStream struct {
    subscribers map[string]chan Event
    mu          sync.RWMutex
}

func (e *EventStream) Subscribe(clientID string) <-chan Event {
    ch := make(chan Event, 100)
    e.mu.Lock()
    e.subscribers[clientID] = ch
    e.mu.Unlock()
    return ch
}

// MCP Event для AI агента
type BuildEvent struct {
    Type      string `json:"type"`      // "build.started", "build.finished"
    BuildID   string `json:"buildId"`
    Status    string `json:"status"`
    Duration  int    `json:"duration"`
    Timestamp string `json:"timestamp"`
}

type BatchRequest struct {
    Operations []Operation `json:"operations"`
    MaxConcurrency int     `json:"maxConcurrency"`
}

func (h *Handler) ExecuteBatch(ctx context.Context, req *BatchRequest) (*BatchResponse, error) {
    semaphore := make(chan struct{}, req.MaxConcurrency)
    results := make([]OperationResult, len(req.Operations))
    
    var wg sync.WaitGroup
    for i, op := range req.Operations {
        wg.Add(1)
        go func(idx int, operation Operation) {
            defer wg.Done()
            semaphore <- struct{}{}        // Acquire
            defer func() { <-semaphore }() // Release
            
            results[idx] = h.executeOperation(ctx, operation)
        }(i, op)
    }
    
    wg.Wait()
    return &BatchResponse{Results: results}, nil
}

# Анализ паттернов падений билдов
class BuildFailurePredictor:
    def __init__(self):
        self.model = RandomForestClassifier()
        
    def extract_features(self, build_history):
        return {
            'time_since_last_commit': ...,
            'changed_files_count': ...,
            'test_count_delta': ...,
            'branch_age_days': ...,
            'author_failure_rate': ...,
        }
    
    def predict_failure_probability(self, build_context):
        features = self.extract_features(build_context)
        return self.model.predict_proba([features])[0][1]

# Интеграция с MCP
{
    "name": "predict_build_failure",
    "description": "Predict build failure probability",
    "inputSchema": {
        "type": "object", 
        "properties": {
            "buildTypeId": {"type": "string"},
            "branchName": {"type": "string"}
        }
    }
}

// Абстракция над разными CI/CD системами
type CIProvider interface {
    ListProjects() ([]Project, error)
    TriggerBuild(req *BuildRequest) (*Build, error)
    GetBuildStatus(buildID string) (*BuildStatus, error)
}

// Конкретные реализации
type TeamCityProvider struct { /* ... */ }
type JenkinsProvider struct { /* ... */ }
type GitLabCIProvider struct { /* ... */ }
type GitHubActionsProvider struct { /* ... */ }

// MCP сервер работает с любым провайдером
func NewMCPServer(provider CIProvider) *Server {
    return &Server{provider: provider}
}

// React компонент для мониторинга MCP сессий
interface MCPSession {
    id: string;
    clientId: string;
    startTime: Date;
    requestCount: number;
    activeTools: string[];
    lastActivity: Date;
}

const MCPDashboard: React.FC = () => {
    const [sessions, setSessions] = useState<MCPSession[]>([]);
    
    return (
        <div>
            <h2>Active MCP Sessions</h2>
            {sessions.map(session => (
                <SessionCard key={session.id} session={session} />
            ))}
        </div>
    );
};

# Prometheus + Grafana + Jaeger
monitoring:
  metrics: prometheus      # Временные ряды
  visualization: grafana   # Дашборды  
  tracing: jaeger         # Распределённая трассировка
  logs: loki              # Логи как метрики
  alerting: alertmanager  # Уведомления

# Статический анализ
golangci-lint run

# Fuzzing тестирование  
go test -fuzz=FuzzMCPHandler

# Load testing
k6 run load_test.js

# Chaos engineering
chaos-monkey --target=teamcity-mcp

# Vulnerability scanning
trivy fs .
snyk test

# SAST (Static Application Security Testing)
semgrep --config=auto .
gosec ./...

# Container security
docker scout cves teamcity-mcp:latest