@daghis/teamcity-mcp 0.1.2

package/src/types/config.ts

@@ -0,0 +1,140 @@
+/**
+ * Configuration type definitions
+ */
+import { z } from 'zod';
+
+// Environment variable schema
+export 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'),
+  TEAMCITY_URL: z.string().url().optional(),
+  TEAMCITY_TOKEN: z.string().optional(),
+});
+
+export type EnvConfig = z.infer<typeof EnvSchema>;
+
+// Server configuration
+export interface ServerConfiguration {
+  port: number;
+  host: string;
+  nodeEnv: 'development' | 'production' | 'test';
+  logLevel: 'debug' | 'info' | 'warn' | 'error';
+  mode: 'dev' | 'full';
+  cors: {
+    enabled: boolean;
+    origins: string[];
+  };
+  rateLimit: {
+    enabled: boolean;
+    windowMs: number;
+    maxRequests: number;
+  };
+  timeout: {
+    server: number;
+    request: number;
+  };
+}
+
+// TeamCity configuration
+export interface TeamCityConfiguration {
+  url: string;
+  token: string;
+  apiVersion: string;
+  timeout: number;
+  retryConfig: {
+    maxRetries: number;
+    retryDelay: number;
+    retryOnStatusCodes: number[];
+  };
+}
+
+// MCP configuration
+export interface MCPConfiguration {
+  name: string;
+  version: string;
+  protocolVersion: string;
+  capabilities: {
+    tools: boolean;
+    prompts: boolean;
+    resources: boolean;
+  };
+  tools: {
+    enabled: string[];
+    disabled: string[];
+  };
+}
+
+// Complete application configuration
+export interface ApplicationConfig {
+  server: ServerConfiguration;
+  teamcity?: TeamCityConfiguration;
+  mcp: MCPConfiguration;
+  features: {
+    realtime: boolean;
+    caching: boolean;
+    metrics: boolean;
+  };
+}
+
+// Configuration loader options
+export interface ConfigLoaderOptions {
+  envPath?: string;
+  configPath?: string;
+  overrides?: Partial<ApplicationConfig>;
+}
+
+// Tool configuration
+export interface ToolConfig {
+  name: string;
+  enabled: boolean;
+  mode: 'dev' | 'full' | 'both';
+  rateLimit?: {
+    maxCalls: number;
+    windowMs: number;
+  };
+  timeout?: number;
+  retryable?: boolean;
+}
+
+// Cache configuration
+export interface CacheConfig {
+  enabled: boolean;
+  ttl: number;
+  maxSize: number;
+  strategy: 'lru' | 'fifo';
+}
+
+// Metrics configuration
+export interface MetricsConfig {
+  enabled: boolean;
+  port: number;
+  path: string;
+  collectInterval: number;
+}
+
+// Security configuration
+export interface SecurityConfig {
+  authentication: {
+    enabled: boolean;
+    type: 'bearer' | 'api-key' | 'none';
+    header?: string;
+  };
+  encryption: {
+    enabled: boolean;
+    algorithm: string;
+  };
+  audit: {
+    enabled: boolean;
+    logLevel: 'all' | 'errors' | 'none';
+  };
+}
+
+// Runtime configuration that can be modified
+export interface RuntimeConfig {
+  maintenance: boolean;
+  readonly: boolean;
+  maxConcurrentRequests: number;
+  toolOverrides: Record<string, Partial<ToolConfig>>;
+}

package/src/types/index.ts

@@ -0,0 +1,171 @@
+/**
+ * Type definitions for TeamCity MCP Server
+ */
+
+// MCP Tool Types
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>; // JSON Schema structure
+  handler: ToolHandler;
+}
+
+// ToolResponse type
+export interface ToolResponse {
+  content?: Array<{ type: string; text: string }>;
+  error?: string;
+  success?: boolean;
+  data?: unknown;
+}
+
+export type ToolHandler = (params: unknown) => Promise<ToolResponse>;
+
+// Configuration Types
+export interface ServerConfig {
+  port: number;
+  nodeEnv: 'development' | 'production' | 'test';
+  logLevel: 'debug' | 'info' | 'warn' | 'error';
+  mode: 'dev' | 'full';
+}
+
+export interface TeamCityConfig {
+  url: string;
+  token: string;
+}
+
+export interface AppConfig {
+  server: ServerConfig;
+  teamcity: TeamCityConfig;
+}
+
+// TeamCity API Types
+export interface BuildConfiguration {
+  id: string;
+  name: string;
+  projectId: string;
+  description?: string;
+  parameters?: Record<string, string>;
+}
+
+export interface Build {
+  id: number;
+  buildTypeId: string;
+  number: string;
+  status: BuildStatus;
+  state: BuildState;
+  branchName?: string;
+  startDate?: string;
+  finishDate?: string;
+  queuedDate: string;
+  statusText?: string;
+}
+
+export type BuildStatus = 'SUCCESS' | 'FAILURE' | 'ERROR' | 'UNKNOWN';
+export type BuildState = 'queued' | 'running' | 'finished';
+
+export interface TestOccurrence {
+  id: string;
+  name: string;
+  status: 'SUCCESS' | 'FAILURE' | 'IGNORED';
+  duration: number;
+  details?: string;
+  stackTrace?: string;
+}
+
+export interface Project {
+  id: string;
+  name: string;
+  parentProjectId?: string;
+  description?: string;
+  archived: boolean;
+}
+
+// Request/Response Types
+export interface TriggerBuildRequest {
+  buildTypeId: string;
+  branchName?: string;
+  parameters?: Record<string, string>;
+  comment?: string;
+}
+
+export interface TriggerBuildResponse {
+  id: number;
+  buildTypeId: string;
+  state: BuildState;
+  href: string;
+}
+
+export interface BuildStatusRequest {
+  buildId: number;
+}
+
+export interface BuildStatusResponse {
+  id: number;
+  state: BuildState;
+  status?: BuildStatus;
+  percentComplete?: number;
+  statusText?: string;
+}
+
+// Error Types
+export class MCPError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public statusCode?: number
+  ) {
+    super(message);
+    this.name = 'MCPError';
+  }
+}
+
+export class TeamCityAPIError extends Error {
+  constructor(
+    message: string,
+    public statusCode: number,
+    public response?: unknown
+  ) {
+    super(message);
+    this.name = 'TeamCityAPIError';
+  }
+}
+
+// Type guard for Error objects
+export function isError(value: unknown): value is Error {
+  return value instanceof Error;
+}
+
+// Type guard for ZodError-like objects
+export interface ZodErrorLike {
+  name: 'ZodError';
+  errors: Array<{
+    path: (string | number)[];
+    message: string;
+    code: string;
+  }>;
+}
+
+export function isZodError(value: unknown): value is ZodErrorLike {
+  return (
+    isError(value) &&
+    value.name === 'ZodError' &&
+    'errors' in value &&
+    Array.isArray((value as { errors: unknown }).errors)
+  );
+}
+
+// Utility Types
+export type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+export type AsyncReturnType<T extends (...args: unknown[]) => Promise<unknown>> = T extends (
+  ...args: unknown[]
+) => Promise<infer R>
+  ? R
+  : unknown;
+
+// Re-export specific module types
+export * from './mcp';
+export * from './teamcity';
+export * from './config';

package/src/types/mcp.ts

@@ -0,0 +1,80 @@
+/**
+ * MCP-specific type definitions
+ */
+
+export interface MCPRequest {
+  jsonrpc: '2.0';
+  id: string | number;
+  method: string;
+  params?: unknown;
+}
+
+export interface MCPResponse {
+  jsonrpc: '2.0';
+  id: string | number;
+  result?: unknown;
+  error?: MCPErrorResponse;
+}
+
+export interface MCPErrorResponse {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+
+export interface MCPToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+export interface MCPServerInfo {
+  name: string;
+  version: string;
+  protocolVersion: string;
+  capabilities: MCPCapabilities;
+}
+
+export interface MCPCapabilities {
+  tools?: boolean;
+  prompts?: boolean;
+  resources?: boolean;
+}
+
+export interface MCPToolCall {
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface MCPToolResult {
+  toolCallId: string;
+  content: Array<{
+    type: 'text' | 'image' | 'error';
+    text?: string;
+    image?: string;
+    error?: string;
+  }>;
+}
+
+export enum MCPErrorCode {
+  ParseError = -32700,
+  InvalidRequest = -32600,
+  MethodNotFound = -32601,
+  InvalidParams = -32602,
+  InternalError = -32603,
+  ServerError = -32000,
+}
+
+export interface MCPSession {
+  id: string;
+  clientInfo?: {
+    name: string;
+    version: string;
+  };
+  startTime: Date;
+  lastActivity: Date;
+}

package/src/types/project.ts

@@ -0,0 +1,128 @@
+/**
+ * Project-related type definitions for TeamCity
+ */
+
+/**
+ * Metadata for a TeamCity project
+ */
+export interface ProjectMetadata {
+  /** The public project ID */
+  id: string;
+
+  /** The public project name */
+  name: string;
+
+  /** Optional project description */
+  description?: string;
+
+  /** REST API link to this project */
+  href: string;
+
+  /** Web URL for viewing the project in TeamCity UI */
+  webUrl: string;
+
+  /** Parent project ID, or '_Root' for top-level projects */
+  parentProjectId: string;
+
+  /** Whether the project is archived */
+  archived: boolean;
+
+  /** Number of build configurations in this project */
+  buildTypesCount?: number;
+
+  /** Number of subprojects */
+  subprojectsCount?: number;
+
+  /** Depth in the project hierarchy (0 for root, 1 for top-level, etc.) */
+  depth?: number;
+}
+
+/**
+ * Hierarchy information for a project
+ */
+export interface ProjectHierarchy {
+  /** Parent project information */
+  parentProject?: {
+    id: string;
+    name: string;
+    href?: string;
+  };
+
+  /** List of ancestor projects from immediate parent to root */
+  ancestorProjects?: Array<{
+    id: string;
+    name: string;
+    href?: string;
+  }>;
+
+  /** Child projects (direct descendants only) */
+  childProjects?: Array<{
+    id: string;
+    name: string;
+    href?: string;
+    buildTypesCount?: number;
+  }>;
+}
+
+/**
+ * Complete project information including metadata and hierarchy
+ */
+export interface ProjectInfo extends ProjectMetadata, ProjectHierarchy {
+  /** Additional project features if requested */
+  features?: Array<{
+    type: string;
+    properties?: Record<string, string>;
+  }>;
+
+  /** Project parameters if requested */
+  parameters?: Record<string, string>;
+}
+
+/**
+ * Parameters for listing projects
+ */
+export interface ProjectListParams {
+  /** Filter by project name (supports wildcards) */
+  name?: string;
+
+  /** Filter by archived status */
+  archived?: boolean;
+
+  /** Filter by parent project ID */
+  parentProjectId?: string;
+
+  /** Include hierarchy information */
+  includeHierarchy?: boolean;
+
+  /** Pagination: number of results to return */
+  limit?: number;
+
+  /** Pagination: offset for results */
+  offset?: number;
+}
+
+/**
+ * Result of a project list operation
+ */
+export interface ProjectListResult {
+  /** List of projects matching the criteria */
+  projects: ProjectInfo[];
+
+  /** Metadata about the result set */
+  metadata: {
+    /** Number of projects in this response */
+    count: number;
+
+    /** Offset used for this query */
+    offset: number;
+
+    /** Limit used for this query */
+    limit: number;
+
+    /** Whether more results are available */
+    hasMore: boolean;
+
+    /** Total count of matching projects (if available) */
+    totalCount?: number;
+  };
+}