@cyanheads/git-mcp-server 1.2.4 → 2.0.2

package/dist/utils/logger.js

@@ -0,0 +1,266 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import winston from 'winston';
+import { config } from '../config/index.js'; // Import config for logger name
+// Define the numeric severity for comparison (lower is more severe)
+const mcpLevelSeverity = {
+    emerg: 0, alert: 1, crit: 2, error: 3, warning: 4, notice: 5, info: 6, debug: 7
+};
+// Map MCP levels to Winston's core levels for file logging
+const mcpToWinstonLevel = {
+    debug: 'debug',
+    info: 'info',
+    notice: 'info', // Map notice to info for file logging
+    warning: 'warn',
+    error: 'error',
+    crit: 'error', // Map critical levels to error for file logging
+    alert: 'error',
+    emerg: 'error',
+};
+// Resolve __dirname for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Project root assumed two levels above utils/
+const projectRoot = path.resolve(__dirname, '..', '..');
+const logsDir = path.join(projectRoot, 'logs');
+// Security: ensure logsDir is within projectRoot
+const resolvedLogsDir = path.resolve(logsDir);
+const isLogsDirSafe = resolvedLogsDir === projectRoot || resolvedLogsDir.startsWith(projectRoot + path.sep);
+if (!isLogsDirSafe) {
+    // Use console.error here as logger might not be initialized or safe
+    console.error(`FATAL: logs directory "${resolvedLogsDir}" is outside project root "${projectRoot}". File logging disabled.`);
+}
+/**
+ * Singleton Logger wrapping Winston, adapted for MCP.
+ * Logs to files and optionally sends MCP notifications/message.
+ */
+class Logger {
+    static instance;
+    winstonLogger;
+    initialized = false;
+    mcpNotificationSender;
+    currentMcpLevel = 'info'; // Default MCP level
+    currentWinstonLevel = 'info'; // Default Winston level
+    constructor() { }
+    /**
+     * Initialize Winston logger for file transport. Must be called once at app start.
+     * Console transport is removed.
+     * @param level Initial minimum level to log ('info' default).
+     */
+    initialize(level = 'info') {
+        if (this.initialized) {
+            // Use console.warn as logger might be re-initializing
+            console.warn('Logger already initialized.');
+            return;
+        }
+        this.currentMcpLevel = level;
+        this.currentWinstonLevel = mcpToWinstonLevel[level];
+        // Ensure logs directory exists
+        if (isLogsDirSafe) {
+            try {
+                if (!fs.existsSync(resolvedLogsDir)) {
+                    fs.mkdirSync(resolvedLogsDir, { recursive: true });
+                    // Use console.log as logger isn't fully ready
+                    console.log(`Created logs directory: ${resolvedLogsDir}`);
+                }
+            }
+            catch (err) {
+                // Use console.error as logger isn't fully ready
+                console.error(`Error creating logs directory at ${resolvedLogsDir}: ${err.message}. File logging disabled.`);
+            }
+        }
+        // Common format for files
+        const fileFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), 
+        // Use JSON format for file logs for easier parsing
+        winston.format.json());
+        const transports = [];
+        // Add file transports only if the directory is safe
+        if (isLogsDirSafe) {
+            transports.push(
+            // Log levels equal to or more severe than the specified level
+            new winston.transports.File({ filename: path.join(resolvedLogsDir, 'error.log'), level: 'error', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'warn.log'), level: 'warn', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'info.log'), level: 'info', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'debug.log'), level: 'debug', format: fileFormat }), 
+            // Combined log captures everything based on the main logger level
+            new winston.transports.File({ filename: path.join(resolvedLogsDir, 'combined.log'), format: fileFormat }));
+        }
+        else {
+            // Use console.warn as logger isn't fully ready
+            console.warn("File logging disabled due to unsafe logs directory path.");
+        }
+        // Create logger with the initial Winston level and file transports
+        this.winstonLogger = winston.createLogger({
+            level: this.currentWinstonLevel, // Set Winston level for file logging
+            transports,
+            exitOnError: false
+        });
+        this.initialized = true;
+        // Log initialization message using the logger itself (will go to file)
+        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}`);
+    }
+    /**
+     * Sets the function used to send MCP 'notifications/message'.
+     * This should be called by the server logic once an MCP connection
+     * supporting logging is established.
+     * @param sender The function to call for sending notifications.
+     */
+    setMcpNotificationSender(sender) {
+        this.mcpNotificationSender = sender;
+        const status = sender ? 'enabled' : 'disabled';
+        this.info(`MCP notification sending ${status}.`);
+    }
+    /**
+     * Dynamically sets the minimum logging level for both file logging and MCP notifications.
+     * @param newLevel The new minimum MCP log level.
+     */
+    setLevel(newLevel) {
+        if (!this.ensureInitialized()) {
+            // Use console.error as logger state is uncertain
+            console.error("Cannot set level: Logger not initialized.");
+            return;
+        }
+        // Validate the level
+        if (!(newLevel in mcpLevelSeverity)) {
+            this.warning(`Invalid MCP log level provided: ${newLevel}. Level not changed.`);
+            return;
+        }
+        this.currentMcpLevel = newLevel;
+        this.currentWinstonLevel = mcpToWinstonLevel[newLevel];
+        this.winstonLogger.level = this.currentWinstonLevel; // Update Winston level for files
+        this.info(`Log level set. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}`);
+    }
+    /** Get singleton instance. */
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    /** Ensures the logger has been initialized. */
+    ensureInitialized() {
+        if (!this.initialized || !this.winstonLogger) {
+            // Use console.warn as this indicates a programming error (calling log before init)
+            console.warn('Logger not initialized; message dropped.');
+            return false;
+        }
+        return true;
+    }
+    /** Centralized log processing */
+    log(level, msg, context, error) {
+        if (!this.ensureInitialized())
+            return;
+        // Check if message level is severe enough for current setting
+        if (mcpLevelSeverity[level] > mcpLevelSeverity[this.currentMcpLevel]) {
+            return; // Skip logging if level is less severe than current setting
+        }
+        const logData = { ...context }; // Copy context
+        const winstonLevel = mcpToWinstonLevel[level];
+        // Log to Winston (files)
+        if (error) {
+            // Include error details for Winston file log
+            logData.error = { message: error.message, stack: error.stack };
+            this.winstonLogger.log(winstonLevel, msg, logData);
+        }
+        else {
+            this.winstonLogger.log(winstonLevel, msg, logData);
+        }
+        // Send MCP notification if sender is configured
+        if (this.mcpNotificationSender) {
+            // Prepare data for MCP: combine message and context/error info
+            const mcpDataPayload = { message: msg };
+            if (context) {
+                mcpDataPayload.context = context;
+            }
+            if (error) {
+                // Include simplified error info for MCP notification
+                mcpDataPayload.error = { message: error.message };
+                // Optionally include stack in debug mode? Be cautious about size.
+                if (this.currentMcpLevel === 'debug' && error.stack) {
+                    mcpDataPayload.error.stack = error.stack.substring(0, 500); // Limit stack trace size
+                }
+            }
+            try {
+                this.mcpNotificationSender(level, mcpDataPayload, config.mcpServerName);
+            }
+            catch (sendError) {
+                // Log failure to send MCP notification to file log
+                this.winstonLogger.error("Failed to send MCP log notification", {
+                    originalLevel: level,
+                    originalMessage: msg,
+                    sendError: sendError instanceof Error ? sendError.message : String(sendError),
+                    mcpPayload: mcpDataPayload // Log what we tried to send
+                });
+            }
+        }
+    }
+    // --- Public Logging Methods ---
+    /** Log debug message (level 7) */
+    debug(msg, context) {
+        this.log('debug', msg, context);
+    }
+    /** Log info message (level 6) */
+    info(msg, context) {
+        this.log('info', msg, context);
+    }
+    /** Log notice message (level 5) */
+    notice(msg, context) {
+        this.log('notice', msg, context);
+    }
+    /** Log warning message (level 4) */
+    warning(msg, context) {
+        this.log('warning', msg, context);
+    }
+    /** Log error message (level 3) */
+    error(msg, err, context) {
+        if (err instanceof Error) {
+            this.log('error', msg, context, err);
+        }
+        else {
+            // If err is not an Error object, treat it as additional context
+            const combinedContext = { ...(err || {}), ...(context || {}) };
+            this.log('error', msg, combinedContext);
+        }
+    }
+    /** Log critical message (level 2) */
+    crit(msg, err, context) {
+        if (err instanceof Error) {
+            this.log('crit', msg, context, err);
+        }
+        else {
+            const combinedContext = { ...(err || {}), ...(context || {}) };
+            this.log('crit', msg, combinedContext);
+        }
+    }
+    /** Log alert message (level 1) */
+    alert(msg, err, context) {
+        if (err instanceof Error) {
+            this.log('alert', msg, context, err);
+        }
+        else {
+            const combinedContext = { ...(err || {}), ...(context || {}) };
+            this.log('alert', msg, combinedContext);
+        }
+    }
+    /** Log emergency message (level 0) */
+    emerg(msg, err, context) {
+        if (err instanceof Error) {
+            this.log('emerg', msg, context, err);
+        }
+        else {
+            const combinedContext = { ...(err || {}), ...(context || {}) };
+            this.log('emerg', msg, combinedContext);
+        }
+    }
+    /** Log fatal message (alias for emergency, ensures process exit) */
+    fatal(msg, context, error) {
+        this.log('emerg', msg, context, error);
+        // Optionally add logic here to ensure process termination after logging fatal error
+        // Be careful with async operations here if you intend immediate exit.
+        // process.exit(1); // Consider if this is appropriate for your application's shutdown logic
+    }
+}
+// Export singleton instance
+export const logger = Logger.getInstance();
+// Initialize logger on import (can be configured later via setLevel/setMcpNotificationSender)
+// Read initial level from env var or default to 'info'
+const initialLogLevel = process.env.MCP_LOG_LEVEL || 'info';
+logger.initialize(initialLogLevel);

package/dist/utils/rateLimiter.js

@@ -0,0 +1,177 @@
+import { BaseErrorCode, McpError } from '../types-global/errors.js';
+import { logger } from './logger.js';
+/**
+ * Generic rate limiter that can be used across the application
+ */
+export class RateLimiter {
+    config;
+    /** Map storing rate limit data */
+    limits;
+    /** Cleanup interval timer */
+    cleanupTimer = null;
+    /** Default configuration */
+    static DEFAULT_CONFIG = {
+        windowMs: 15 * 60 * 1000, // 15 minutes
+        maxRequests: 100, // 100 requests per window
+        errorMessage: 'Rate limit exceeded. Please try again in {waitTime} seconds.',
+        skipInDevelopment: false,
+        cleanupInterval: 5 * 60 * 1000 // 5 minutes
+    };
+    /**
+     * Create a new rate limiter
+     * @param config Rate limiting configuration
+     */
+    constructor(config) {
+        this.config = config;
+        this.config = { ...RateLimiter.DEFAULT_CONFIG, ...config };
+        this.limits = new Map();
+        this.startCleanupTimer();
+        // Log initialization
+        logger.debug('RateLimiter initialized', {
+            windowMs: this.config.windowMs,
+            maxRequests: this.config.maxRequests,
+            cleanupInterval: this.config.cleanupInterval
+        });
+    }
+    /**
+     * Start the cleanup timer to periodically remove expired entries
+     */
+    startCleanupTimer() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        const interval = this.config.cleanupInterval ?? RateLimiter.DEFAULT_CONFIG.cleanupInterval;
+        if (interval) {
+            this.cleanupTimer = setInterval(() => {
+                this.cleanupExpiredEntries();
+            }, interval);
+            // Ensure the timer doesn't prevent the process from exiting
+            if (this.cleanupTimer.unref) {
+                this.cleanupTimer.unref();
+            }
+        }
+    }
+    /**
+     * Clean up expired rate limit entries to prevent memory leaks
+     */
+    cleanupExpiredEntries() {
+        const now = Date.now();
+        let expiredCount = 0;
+        // Use a synchronized approach to avoid race conditions during cleanup
+        for (const [key, entry] of this.limits.entries()) {
+            if (now >= entry.resetTime) {
+                this.limits.delete(key);
+                expiredCount++;
+            }
+        }
+        if (expiredCount > 0) {
+            logger.debug(`Cleaned up ${expiredCount} expired rate limit entries`, {
+                totalRemaining: this.limits.size
+            });
+        }
+    }
+    /**
+     * Update rate limiter configuration
+     * @param config New configuration options
+     */
+    configure(config) {
+        this.config = { ...this.config, ...config };
+        // Restart cleanup timer if interval changed
+        if (config.cleanupInterval !== undefined) {
+            this.startCleanupTimer();
+        }
+    }
+    /**
+     * Get current configuration
+     * @returns Current rate limit configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Reset all rate limits
+     */
+    reset() {
+        this.limits.clear();
+        logger.debug('Rate limiter reset, all limits cleared');
+    }
+    /**
+     * Check if a request exceeds the rate limit
+     * @param key Unique identifier for the request source
+     * @param context Optional request context
+     * @throws {McpError} If rate limit is exceeded
+     */
+    check(key, context) {
+        // Skip in development if configured
+        if (this.config.skipInDevelopment && process.env.NODE_ENV === 'development') {
+            return;
+        }
+        // Generate key using custom generator if provided
+        const limitKey = this.config.keyGenerator
+            ? this.config.keyGenerator(key, context)
+            : key;
+        const now = Date.now();
+        // Accessing and updating the limit entry within a single function scope
+        // ensures atomicity in Node.js's single-threaded event loop for Map operations.
+        const limit = () => {
+            // Get current entry or create a new one if it doesn't exist or is expired
+            const entry = this.limits.get(limitKey);
+            // Create new entry or reset if expired
+            if (!entry || now >= entry.resetTime) {
+                const newEntry = {
+                    count: 1,
+                    resetTime: now + this.config.windowMs
+                };
+                this.limits.set(limitKey, newEntry);
+                return newEntry;
+            }
+            // Check if limit exceeded
+            if (entry.count >= this.config.maxRequests) {
+                const waitTime = Math.ceil((entry.resetTime - now) / 1000);
+                const errorMessage = this.config.errorMessage?.replace('{waitTime}', waitTime.toString()) ||
+                    `Rate limit exceeded. Please try again in ${waitTime} seconds.`;
+                throw new McpError(BaseErrorCode.RATE_LIMITED, errorMessage, { waitTime, key: limitKey });
+            }
+            // Increment counter and return updated entry
+            entry.count++;
+            return entry;
+        };
+        // Execute the rate limiting logic
+        limit();
+    }
+    /**
+     * Get rate limit information for a key
+     * @param key The rate limit key
+     * @returns Current rate limit status or null if no record exists
+     */
+    getStatus(key) {
+        const entry = this.limits.get(key);
+        if (!entry) {
+            return null;
+        }
+        return {
+            current: entry.count,
+            limit: this.config.maxRequests,
+            remaining: Math.max(0, this.config.maxRequests - entry.count),
+            resetTime: entry.resetTime
+        };
+    }
+    /**
+     * Stop the cleanup timer when the limiter is no longer needed
+     */
+    dispose() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        // Clear all entries
+        this.limits.clear();
+    }
+}
+/**
+ * Create and export a default rate limiter instance
+ */
+export const rateLimiter = new RateLimiter({
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    maxRequests: 100 // 100 requests per window
+});

package/dist/utils/requestContext.js

@@ -0,0 +1,49 @@
+import { logger } from './logger.js';
+import { generateUUID } from './idGenerator.js'; // Import generateUUID
+// Direct instance for request context utilities
+const requestContextServiceInstance = {
+    config: {},
+    /**
+     * Configure service settings
+     * @param config New configuration
+     * @returns Updated configuration
+     */
+    configure(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+        logger.debug('RequestContext configuration updated', { config: this.config });
+        return { ...this.config };
+    },
+    /**
+     * Get current configuration
+     * @returns Current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    },
+    /**
+     * Create a request context with unique ID and timestamp
+     * @param additionalContext Additional context properties
+     * @returns Request context object
+     */
+    createRequestContext(additionalContext = {}) {
+        const requestId = generateUUID(); // Use imported generateUUID
+        const timestamp = new Date().toISOString();
+        return {
+            requestId,
+            timestamp,
+            ...additionalContext
+        };
+    },
+    // generateSecureRandomString function removed as it was unused and redundant
+};
+// Initialize logger message
+logger.debug('RequestContext service initialized');
+// Export the instance directly
+export const requestContextService = requestContextServiceInstance;
+// Removed delegate functions and default export for simplicity.
+// Users should import and use `requestContextService` directly.
+// e.g., import { requestContextService } from './requestContext.js';
+// requestContextService.createRequestContext();