@elliotding/ai-agent-mcp 0.1.25 → 0.1.26

package/src/utils/logger.ts

@@ -1,333 +0,0 @@
-/**
- * Logging Module
- * Structured logging using pino with daily file rotation.
- *
- * Files are named app-YYYY-MM-DD.log. Rotation is implemented by:
- *   1. Starting pino/file pointing at today's file (fixed fd, opened at startup).
- *   2. A midnight timer in the main thread spawns a fresh child process for the
- *      next day's file via a second pino instance — but that would mean two loggers.
- *
- * Practical solution used here:
- *   - Use pino-roll (daily, dateFormat: 'yyyy-MM-dd').
- *   - pino-roll produces  Logs/app.YYYY-MM-DD.1.log  (date + sequential counter).
- *   - At midnight + 2 s we rename the *previous* day's  app.YYYY-MM-DD.1.log
- *     → app-YYYY-MM-DD.log  so the canonical name is clean.
- *   - The active (today's) file keeps the pino-roll name until it rotates.
- *   - log-cleaner scans by mtime so it handles both naming conventions.
- */
-
-import pino from 'pino';
-import * as path from 'path';
-import * as fs from 'fs';
-import { config } from '../config';
-
-// Ensure logs directory exists (relative to project root)
-const logsDir = path.resolve(process.cwd(), config.logging.dir);
-if (!fs.existsSync(logsDir)) {
-  fs.mkdirSync(logsDir, { recursive: true });
-}
-
-/** ms until the next local midnight + 1 s buffer. */
-function msUntilMidnight(): number {
-  const now = new Date();
-  const next = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 1);
-  return next.getTime() - now.getTime();
-}
-
-/**
- * Rename yesterday's pino-roll file (app.YYYY-MM-DD.1.log)
- * to the canonical name (app-YYYY-MM-DD.log) once it has been rotated away.
- */
-function renameYesterdayLog(): void {
-  const d = new Date();
-  d.setDate(d.getDate() - 1);
-  const dateStr = [
-    d.getFullYear(),
-    String(d.getMonth() + 1).padStart(2, '0'),
-    String(d.getDate()).padStart(2, '0'),
-  ].join('-');
-
-  const src = path.join(logsDir, `app.${dateStr}.1.log`);
-  const dst = path.join(logsDir, `app-${dateStr}.log`);
-  if (fs.existsSync(src) && !fs.existsSync(dst)) {
-    try { fs.renameSync(src, dst); } catch { /* non-fatal */ }
-  }
-}
-
-// Fire rename at midnight + 2 s, then every 24 h.
-setTimeout(() => {
-  renameYesterdayLog();
-  setInterval(renameYesterdayLog, 24 * 60 * 60 * 1000).unref();
-}, msUntilMidnight() + 2000).unref();
-
-// Create pino logger with multi-target transport
-export const logger = pino({
-  level: config.logLevel,
-  timestamp: pino.stdTimeFunctions.isoTime,
-  base: {
-    service: 'csp-ai-agent-mcp',
-  },
-  transport: {
-    targets: [
-      // Console output (pretty format in development)
-      {
-        target: 'pino-pretty',
-        level: config.logLevel,
-        options: {
-          colorize: true,
-          translateTime: 'SYS:standard',
-          ignore: 'pid,hostname',
-          singleLine: false,
-        },
-      },
-      // Daily-rotating file output.
-      // Active file: Logs/app.YYYY-MM-DD.1.log
-      // After midnight rename: Logs/app-YYYY-MM-DD.log
-      {
-        target: 'pino-roll',
-        level: config.logLevel,
-        options: {
-          file: path.join(logsDir, 'app'),
-          frequency: 'daily',
-          dateFormat: 'yyyy-MM-dd',
-          mkdir: true,
-          sync: false,
-        },
-      },
-    ],
-  },
-});
-
-/**
- * Log MCP Tool call
- */
-export function logToolCall(
-  toolName: string,
-  userId: string,
-  params: Record<string, unknown>,
-  durationMs: number
-): void {
-  logger.info(
-    {
-      type: 'tool_call',
-      toolName,
-      userId,
-      params,
-      durationMs,
-    },
-    `Tool ${toolName} called by ${userId} (${durationMs}ms)`
-  );
-}
-
-/**
- * Log error with context
- */
-export function logError(error: Error, context?: Record<string, unknown>): void {
-  logger.error(
-    {
-      type: 'error',
-      error: {
-        message: error.message,
-        stack: error.stack,
-        name: error.name,
-      },
-      ...context,
-    },
-    error.message
-  );
-}
-
-/**
- * Log performance metrics
- */
-export function logPerformance(
-  operation: string,
-  durationMs: number,
-  metadata?: Record<string, unknown>
-): void {
-  logger.info(
-    {
-      type: 'performance',
-      operation,
-      durationMs,
-      ...metadata,
-    },
-    `${operation} completed in ${durationMs}ms`
-  );
-}
-
-/**
- * Log API request with detailed information
- */
-export function logApiRequest(
-  method: string,
-  url: string,
-  statusCode: number,
-  durationMs: number,
-  requestData?: unknown,
-  responseData?: unknown,
-  headers?: Record<string, string>
-): void {
-  logger.info(
-    {
-      type: 'api_request',
-      method,
-      url,
-      statusCode,
-      durationMs,
-      requestData: requestData ? JSON.stringify(requestData).substring(0, 500) : undefined,
-      responseData: responseData ? JSON.stringify(responseData).substring(0, 1000) : undefined,
-      headers: headers ? sanitizeHeaders(headers) : undefined,
-    },
-    `${method} ${url} - ${statusCode} (${durationMs}ms)`
-  );
-}
-
-/**
- * Log API error with full details
- */
-export function logApiError(
-  method: string,
-  url: string,
-  error: Error,
-  requestData?: unknown,
-  statusCode?: number
-): void {
-  logger.error(
-    {
-      type: 'api_error',
-      method,
-      url,
-      statusCode,
-      requestData: requestData ? JSON.stringify(requestData).substring(0, 500) : undefined,
-      error: {
-        message: error.message,
-        stack: error.stack,
-        name: error.name,
-      },
-    },
-    `API Error: ${method} ${url} - ${error.message}`
-  );
-}
-
-/**
- * Log tool execution step
- */
-export function logToolStep(
-  toolName: string,
-  step: string,
-  details?: Record<string, unknown>
-): void {
-  logger.debug(
-    {
-      type: 'tool_step',
-      toolName,
-      step,
-      ...details,
-    },
-    `[${toolName}] ${step}`
-  );
-}
-
-/**
- * Log tool execution result
- */
-export function logToolResult(
-  toolName: string,
-  success: boolean,
-  result?: unknown,
-  error?: Error
-): void {
-  const level = success ? 'info' : 'error';
-  logger[level](
-    {
-      type: 'tool_result',
-      toolName,
-      success,
-      result: result ? JSON.stringify(result).substring(0, 1000) : undefined,
-      error: error ? {
-        message: error.message,
-        stack: error.stack,
-        name: error.name,
-      } : undefined,
-    },
-    `[${toolName}] ${success ? 'Success' : 'Failed'}`
-  );
-}
-
-/**
- * Log authentication attempt
- */
-export function logAuthAttempt(
-  type: 'token_validation' | 'permission_check',
-  success: boolean,
-  details?: Record<string, unknown>
-): void {
-  const level = success ? 'info' : 'warn';
-  logger[level](
-    {
-      type: 'auth',
-      operation: type,
-      success,
-      ...details,
-    },
-    `Auth ${type}: ${success ? 'Success' : 'Failed'}`
-  );
-}
-
-/**
- * Log cache operation
- */
-export function logCacheOperation(
-  operation: 'get' | 'set' | 'delete' | 'hit' | 'miss',
-  key: string,
-  details?: Record<string, unknown>
-): void {
-  logger.debug(
-    {
-      type: 'cache',
-      operation,
-      key,
-      ...details,
-    },
-    `Cache ${operation}: ${key}`
-  );
-}
-
-/**
- * Sanitize headers to remove sensitive information
- */
-function sanitizeHeaders(headers: Record<string, string>): Record<string, string> {
-  const sanitized = { ...headers };
-  
-  // Mask Authorization header
-  if (sanitized['Authorization'] || sanitized['authorization']) {
-    const authKey = sanitized['Authorization'] ? 'Authorization' : 'authorization';
-    const authValue = sanitized[authKey];
-    if (authValue && authValue.startsWith('Bearer ')) {
-      const token = authValue.substring(7);
-      sanitized[authKey] = `Bearer ${token.substring(0, 10)}...${token.substring(token.length - 10)}`;
-    }
-  }
-  
-  return sanitized;
-}
-
-/**
- * Log Git operation
- */
-export function logGitOperation(
-  operation: string,
-  details: Record<string, unknown>,
-  durationMs: number
-): void {
-  logger.info(
-    {
-      type: 'git_operation',
-      operation,
-      ...details,
-      durationMs,
-    },
-    `Git ${operation} completed (${durationMs}ms)`
-  );
-}

package/src/utils/validation.ts

@@ -1,262 +0,0 @@
-/**
- * Request Validation Utilities
- * Enhanced validation with clear error messages
- */
-
-export interface ValidationError {
-  field: string;
-  message: string;
-  expected?: string;
-  received?: any;
-  suggestion?: string;
-}
-
-export class RequestValidationError extends Error {
-  public errors: ValidationError[];
-  public statusCode: number;
-
-  constructor(errors: ValidationError[], statusCode = 400) {
-    const message = errors.map(e => `${e.field}: ${e.message}`).join('; ');
-    super(message);
-    this.name = 'RequestValidationError';
-    this.errors = errors;
-    this.statusCode = statusCode;
-  }
-
-  toJSON() {
-    return {
-      error: 'Validation Error',
-      message: this.message,
-      details: this.errors,
-    };
-  }
-}
-
-/**
- * Validate required field
- */
-export function validateRequired(
-  value: any,
-  fieldName: string
-): ValidationError | null {
-  if (value === undefined || value === null || value === '') {
-    return {
-      field: fieldName,
-      message: `Missing required field: '${fieldName}'`,
-      expected: 'non-empty value',
-      received: typeof value,
-    };
-  }
-  return null;
-}
-
-/**
- * Validate string type
- */
-export function validateString(
-  value: any,
-  fieldName: string
-): ValidationError | null {
-  if (typeof value !== 'string') {
-    return {
-      field: fieldName,
-      message: `Field '${fieldName}' must be a string`,
-      expected: 'string',
-      received: typeof value,
-    };
-  }
-  return null;
-}
-
-/**
- * Validate enum value
- */
-export function validateEnum(
-  value: any,
-  fieldName: string,
-  allowedValues: readonly string[]
-): ValidationError | null {
-  if (!allowedValues.includes(value)) {
-    // Find closest match for suggestion
-    const suggestion = findClosestMatch(value, allowedValues);
-    
-    return {
-      field: fieldName,
-      message: `Field '${fieldName}' has invalid value`,
-      expected: `one of: ${allowedValues.map(v => `'${v}'`).join(', ')}`,
-      received: value,
-      suggestion: suggestion ? `Did you mean '${suggestion}'?` : undefined,
-    };
-  }
-  return null;
-}
-
-/**
- * Validate array type
- */
-export function validateArray(
-  value: any,
-  fieldName: string
-): ValidationError | null {
-  if (!Array.isArray(value)) {
-    return {
-      field: fieldName,
-      message: `Field '${fieldName}' must be an array`,
-      expected: 'array',
-      received: typeof value,
-    };
-  }
-  return null;
-}
-
-/**
- * Validate object type
- */
-export function validateObject(
-  value: any,
-  fieldName: string
-): ValidationError | null {
-  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-    return {
-      field: fieldName,
-      message: `Field '${fieldName}' must be an object`,
-      expected: 'object',
-      received: Array.isArray(value) ? 'array' : typeof value,
-    };
-  }
-  return null;
-}
-
-/**
- * Validate boolean type
- */
-export function validateBoolean(
-  value: any,
-  fieldName: string
-): ValidationError | null {
-  if (typeof value !== 'boolean') {
-    return {
-      field: fieldName,
-      message: `Field '${fieldName}' must be a boolean`,
-      expected: 'boolean (true or false)',
-      received: typeof value,
-    };
-  }
-  return null;
-}
-
-/**
- * Validate number type
- */
-export function validateNumber(
-  value: any,
-  fieldName: string
-): ValidationError | null {
-  if (typeof value !== 'number' || isNaN(value)) {
-    return {
-      field: fieldName,
-      message: `Field '${fieldName}' must be a number`,
-      expected: 'number',
-      received: typeof value,
-    };
-  }
-  return null;
-}
-
-/**
- * Find closest string match (simple Levenshtein distance)
- */
-function findClosestMatch(
-  value: string,
-  candidates: readonly string[]
-): string | null {
-  if (!value || typeof value !== 'string') {
-    return null;
-  }
-
-  let minDistance = Infinity;
-  let closest: string | null = null;
-
-  for (const candidate of candidates) {
-    const distance = levenshteinDistance(
-      value.toLowerCase(),
-      candidate.toLowerCase()
-    );
-    if (distance < minDistance && distance <= 2) {
-      // Only suggest if distance is small
-      minDistance = distance;
-      closest = candidate;
-    }
-  }
-
-  return closest;
-}
-
-/**
- * Calculate Levenshtein distance between two strings
- */
-function levenshteinDistance(a: string, b: string): number {
-  const matrix: number[][] = [];
-
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0]![j] = j;
-  }
-
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i]![j] = matrix[i - 1]![j - 1]!;
-      } else {
-        matrix[i]![j] = Math.min(
-          matrix[i - 1]![j - 1]! + 1, // substitution
-          matrix[i]![j - 1]! + 1, // insertion
-          matrix[i - 1]![j]! + 1 // deletion
-        );
-      }
-    }
-  }
-
-  return matrix[b.length]![a.length]!;
-}
-
-/**
- * Validate SSE connection parameters
- */
-export function validateSSEConnectionParams(_body: any): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  // Validate Authorization header (will be checked in middleware)
-  // No body parameters required for SSE connection
-
-  return errors;
-}
-
-/**
- * Validate message parameters
- */
-export function validateMessageParams(body: any): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  // sessionId is required
-  const sessionIdError = validateRequired(body.sessionId, 'sessionId');
-  if (sessionIdError) {
-    errors.push(sessionIdError);
-  } else {
-    const sessionIdTypeError = validateString(body.sessionId, 'sessionId');
-    if (sessionIdTypeError) {
-      errors.push(sessionIdTypeError);
-    }
-  }
-
-  // message is required
-  const messageError = validateRequired(body.message, 'message');
-  if (messageError) {
-    errors.push(messageError);
-  }
-
-  return errors;
-}