@cyanheads/git-mcp-server 2.0.1 → 2.0.3

package/dist/utils/internal/logger.js

@@ -0,0 +1,254 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import winston from 'winston';
+import { config } from '../../config/index.js';
+// 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);
+// Calculate project root robustly (works from src/ or dist/)
+const isRunningFromDist = __dirname.includes(path.sep + 'dist' + path.sep);
+const levelsToGoUp = isRunningFromDist ? 3 : 2;
+const pathSegments = Array(levelsToGoUp).fill('..');
+const projectRoot = path.resolve(__dirname, ...pathSegments);
+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 added conditionally.
+     * @param level Initial minimum level to log ('info' default).
+     */
+    async initialize(level = 'info') {
+        if (this.initialized) {
+            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 });
+                    console.log(`Created logs directory: ${resolvedLogsDir}`);
+                }
+            }
+            catch (err) {
+                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 }), winston.format.json());
+        const transports = [];
+        // Add file transports only if the directory is safe
+        if (isLogsDirSafe) {
+            transports.push(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 }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'combined.log'), format: fileFormat }));
+        }
+        else {
+            console.warn("File logging disabled due to unsafe logs directory path.");
+        }
+        // Conditionally add Console transport only if:
+        // 1. MCP level is 'debug'
+        // 2. stdout is a TTY (interactive terminal, not piped)
+        if (this.currentMcpLevel === 'debug' && process.stdout.isTTY) {
+            const consoleFormat = winston.format.combine(winston.format.colorize(), winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+                let metaString = '';
+                const metaCopy = { ...meta };
+                if (metaCopy.error && typeof metaCopy.error === 'object') {
+                    const errorObj = metaCopy.error;
+                    if (errorObj.message)
+                        metaString += `\n  Error: ${errorObj.message}`;
+                    if (errorObj.stack)
+                        metaString += `\n  Stack: ${String(errorObj.stack).split('\n').map((l) => `    ${l}`).join('\n')}`;
+                    delete metaCopy.error;
+                }
+                if (Object.keys(metaCopy).length > 0) {
+                    try {
+                        const remainingMetaJson = JSON.stringify(metaCopy, null, 2);
+                        if (remainingMetaJson !== '{}')
+                            metaString += `\n  Meta: ${remainingMetaJson}`;
+                    }
+                    catch (stringifyError) {
+                        metaString += `\n  Meta: [Error stringifying metadata: ${stringifyError.message}]`;
+                    }
+                }
+                return `${timestamp} ${level}: ${message}${metaString}`;
+            }));
+            transports.push(new winston.transports.Console({
+                level: 'debug',
+                format: consoleFormat,
+            }));
+            console.log(`Console logging enabled at level: debug (stdout is TTY)`);
+        }
+        else if (this.currentMcpLevel === 'debug' && !process.stdout.isTTY) {
+            console.log(`Console logging skipped: Level is debug, but stdout is not a TTY (likely stdio transport).`);
+        }
+        // Create logger with the initial Winston level and configured transports
+        this.winstonLogger = winston.createLogger({
+            level: this.currentWinstonLevel,
+            transports,
+            exitOnError: false
+        });
+        this.initialized = true;
+        await Promise.resolve(); // Yield to event loop
+        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${process.stdout.isTTY && this.currentMcpLevel === 'debug' ? 'enabled' : 'disabled'}`);
+    }
+    /**
+     * Sets the function used to send MCP 'notifications/message'.
+     */
+    setMcpNotificationSender(sender) {
+        this.mcpNotificationSender = sender;
+        const status = sender ? 'enabled' : 'disabled';
+        this.info(`MCP notification sending ${status}.`);
+    }
+    /**
+     * Dynamically sets the minimum logging level.
+     */
+    setLevel(newLevel) {
+        if (!this.ensureInitialized()) {
+            console.error("Cannot set level: Logger not initialized.");
+            return;
+        }
+        if (!(newLevel in mcpLevelSeverity)) {
+            this.warning(`Invalid MCP log level provided: ${newLevel}. Level not changed.`);
+            return;
+        }
+        const oldLevel = this.currentMcpLevel;
+        this.currentMcpLevel = newLevel;
+        this.currentWinstonLevel = mcpToWinstonLevel[newLevel];
+        this.winstonLogger.level = this.currentWinstonLevel;
+        // Add or remove console transport based on the new level and TTY status
+        const consoleTransport = this.winstonLogger.transports.find(t => t instanceof winston.transports.Console);
+        const shouldHaveConsole = newLevel === 'debug' && process.stdout.isTTY;
+        if (shouldHaveConsole && !consoleTransport) {
+            // Add console transport
+            const consoleFormat = winston.format.combine( /* ... same format as in initialize ... */); // TODO: Extract format to avoid duplication
+            this.winstonLogger.add(new winston.transports.Console({ level: 'debug', format: consoleFormat }));
+            this.info('Console logging dynamically enabled.');
+        }
+        else if (!shouldHaveConsole && consoleTransport) {
+            // Remove console transport
+            this.winstonLogger.remove(consoleTransport);
+            this.info('Console logging dynamically disabled.');
+        }
+        if (oldLevel !== newLevel) {
+            this.info(`Log level changed. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${shouldHaveConsole ? 'enabled' : 'disabled'}`);
+        }
+    }
+    /** 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) {
+            console.warn('Logger not initialized; message dropped.');
+            return false;
+        }
+        return true;
+    }
+    /** Centralized log processing */
+    log(level, msg, context, error) {
+        if (!this.ensureInitialized())
+            return;
+        if (mcpLevelSeverity[level] > mcpLevelSeverity[this.currentMcpLevel]) {
+            return;
+        }
+        const logData = { ...context };
+        const winstonLevel = mcpToWinstonLevel[level];
+        if (error) {
+            this.winstonLogger.log(winstonLevel, msg, { ...logData, error: error });
+        }
+        else {
+            this.winstonLogger.log(winstonLevel, msg, logData);
+        }
+        if (this.mcpNotificationSender) {
+            const mcpDataPayload = { message: msg };
+            if (context)
+                mcpDataPayload.context = context;
+            if (error) {
+                mcpDataPayload.error = { message: error.message };
+                if (this.currentMcpLevel === 'debug' && error.stack) {
+                    mcpDataPayload.error.stack = error.stack.substring(0, 500);
+                }
+            }
+            try {
+                this.mcpNotificationSender(level, mcpDataPayload, config.mcpServerName);
+            }
+            catch (sendError) {
+                this.winstonLogger.error("Failed to send MCP log notification", {
+                    originalLevel: level,
+                    originalMessage: msg,
+                    sendError: sendError instanceof Error ? sendError.message : String(sendError),
+                    mcpPayload: mcpDataPayload
+                });
+            }
+        }
+    }
+    // --- Public Logging Methods ---
+    debug(msg, context) { this.log('debug', msg, context); }
+    info(msg, context) { this.log('info', msg, context); }
+    notice(msg, context) { this.log('notice', msg, context); }
+    warning(msg, context) { this.log('warning', msg, context); }
+    error(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('error', msg, combinedContext, errorObj);
+    }
+    crit(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('crit', msg, combinedContext, errorObj);
+    }
+    alert(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('alert', msg, combinedContext, errorObj);
+    }
+    emerg(msg, err, context) {
+        const errorObj = err instanceof Error ? err : undefined;
+        const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
+        this.log('emerg', msg, combinedContext, errorObj);
+    }
+    fatal(msg, context, error) {
+        this.log('emerg', msg, context, error);
+    }
+}
+// Export singleton instance
+export const logger = Logger.getInstance();

package/{build/utils → dist/utils/internal}/requestContext.js

@@ -1,5 +1,6 @@
 import { logger } from './logger.js';
-import { generateUUID } from './idGenerator.js'; // Import generateUUID
+// Import utils from the main barrel file (generateUUID from ../security/idGenerator.js)
+import { generateUUID } from '../index.js';
 // Direct instance for request context utilities
 const requestContextServiceInstance = {
     config: {},
@@ -39,8 +40,6 @@ const requestContextServiceInstance = {
     },
     // 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.

package/dist/utils/metrics/index.js

@@ -0,0 +1 @@
+export * from './tokenCounter.js';

package/{build/utils → dist/utils/metrics}/tokenCounter.js

@@ -1,7 +1,7 @@
 import { encoding_for_model } from 'tiktoken';
-import { BaseErrorCode } from '../types-global/errors.js'; // Import BaseErrorCode and McpError
-import { ErrorHandler } from './errorHandler.js'; // Import ErrorHandler
-import { logger } from './logger.js';
+import { BaseErrorCode } from '../../types-global/errors.js';
+// Import utils from the main barrel file (ErrorHandler, logger, RequestContext from ../internal/*)
+import { ErrorHandler, logger } from '../index.js';
 // Define the model used specifically for token counting
 const TOKENIZATION_MODEL = 'gpt-4o'; // Note this is strictly for token counting, not the model used for inference
 /**

package/dist/utils/parsing/dateParser.js

@@ -0,0 +1,62 @@
+import * as chrono from 'chrono-node';
+// Import utils from the main barrel file (logger, ErrorHandler, RequestContext from ../internal/*)
+import { logger, ErrorHandler } from '../index.js';
+import { BaseErrorCode } from '../../types-global/errors.js'; // Corrected path
+/**
+ * Parses a natural language date string into a Date object.
+ *
+ * @param text The natural language date string (e.g., "tomorrow", "in 5 days", "2024-01-15").
+ * @param context The request context for logging and error tracking.
+ * @param refDate Optional reference date for parsing relative dates. Defaults to now.
+ * @returns A Date object representing the parsed date, or null if parsing fails.
+ * @throws McpError if parsing fails unexpectedly.
+ */
+async function parseDateString(text, context, refDate) {
+    const operation = 'parseDateString';
+    const logContext = { ...context, operation, inputText: text, refDate };
+    logger.debug(`Attempting to parse date string: "${text}"`, logContext);
+    return await ErrorHandler.tryCatch(async () => {
+        const parsedDate = chrono.parseDate(text, refDate, { forwardDate: true });
+        if (parsedDate) {
+            logger.debug(`Successfully parsed "${text}" to ${parsedDate.toISOString()}`, logContext);
+            return parsedDate;
+        }
+        else {
+            logger.warning(`Failed to parse date string: "${text}"`, logContext);
+            return null;
+        }
+    }, {
+        operation,
+        context: logContext,
+        input: { text, refDate },
+        errorCode: BaseErrorCode.PARSING_ERROR,
+    });
+}
+/**
+ * Parses a natural language date string and returns detailed parsing results.
+ *
+ * @param text The natural language date string.
+ * @param context The request context for logging and error tracking.
+ * @param refDate Optional reference date for parsing relative dates. Defaults to now.
+ * @returns An array of chrono.ParsedResult objects, or an empty array if parsing fails.
+ * @throws McpError if parsing fails unexpectedly.
+ */
+async function parseDateStringDetailed(text, context, refDate) {
+    const operation = 'parseDateStringDetailed';
+    const logContext = { ...context, operation, inputText: text, refDate };
+    logger.debug(`Attempting detailed parse of date string: "${text}"`, logContext);
+    return await ErrorHandler.tryCatch(async () => {
+        const results = chrono.parse(text, refDate, { forwardDate: true });
+        logger.debug(`Detailed parse of "${text}" resulted in ${results.length} result(s)`, logContext);
+        return results;
+    }, {
+        operation,
+        context: logContext,
+        input: { text, refDate },
+        errorCode: BaseErrorCode.PARSING_ERROR,
+    });
+}
+export const dateParser = {
+    parse: parseDateStringDetailed,
+    parseDate: parseDateString,
+};

package/dist/utils/parsing/index.js

@@ -0,0 +1,2 @@
+export * from './jsonParser.js';
+export * from './dateParser.js';

package/{build/utils → dist/utils/parsing}/jsonParser.js

@@ -1,6 +1,7 @@
 import { parse as parsePartialJson, Allow as PartialJsonAllow } from 'partial-json';
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
-import { logger } from './logger.js'; // Import logger
+import { BaseErrorCode, McpError } from '../../types-global/errors.js';
+// Import utils from the main barrel file (logger, RequestContext from ../internal/*)
+import { logger } from '../index.js';
 /**
  * Enum mirroring partial-json's Allow constants for specifying
  * what types of partial JSON structures are permissible during parsing.

package/{build/utils → dist/utils/security}/idGenerator.js

@@ -1,6 +1,5 @@
-import { randomBytes } from 'crypto';
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
-import { logger } from './logger.js';
+import { randomBytes, randomUUID as cryptoRandomUUID } from 'crypto'; // Import cryptoRandomUUID
+import { BaseErrorCode, McpError } from '../../types-global/errors.js'; // Corrected path
 /**
  * Generic ID Generator class for creating and managing unique identifiers
  */
@@ -34,7 +33,7 @@ export class IdGenerator {
             acc[prefix.toLowerCase()] = type;
             return acc;
         }, {});
-        logger.debug('Entity prefixes updated', { entityPrefixes: this.entityPrefixes });
+        // Removed logger call from setEntityPrefixes to prevent logging before initialization
     }
     /**
      * Get all registered entity prefixes
@@ -144,5 +143,5 @@ export class IdGenerator {
 export const idGenerator = new IdGenerator();
 // For standalone use as a UUID generator
 export const generateUUID = () => {
-    return crypto.randomUUID();
+    return cryptoRandomUUID(); // Use imported cryptoRandomUUID
 };

package/dist/utils/security/index.js

@@ -0,0 +1,3 @@
+export * from './sanitization.js';
+export * from './rateLimiter.js';
+export * from './idGenerator.js';

package/{build/utils → dist/utils/security}/rateLimiter.js

@@ -1,5 +1,7 @@
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
-import { logger } from './logger.js';
+import { BaseErrorCode, McpError } from '../../types-global/errors.js';
+// Import config and utils
+import { environment } from '../../config/index.js'; // Import environment from config
+import { logger } from '../index.js';
 /**
  * Generic rate limiter that can be used across the application
  */
@@ -26,12 +28,7 @@ export class RateLimiter {
         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
-        });
+        // Removed logger call from constructor to prevent logging before initialization
     }
     /**
      * Start the cleanup timer to periodically remove expired entries
@@ -102,8 +99,8 @@ export class RateLimiter {
      * @throws {McpError} If rate limit is exceeded
      */
     check(key, context) {
-        // Skip in development if configured
-        if (this.config.skipInDevelopment && process.env.NODE_ENV === 'development') {
+        // Skip in development if configured, using the validated environment from config
+        if (this.config.skipInDevelopment && environment === 'development') {
             return;
         }
         // Generate key using custom generator if provided

package/{build/utils → dist/utils/security}/sanitization.js

@@ -1,8 +1,9 @@
 import path from 'path';
 import sanitizeHtml from 'sanitize-html';
 import validator from 'validator';
-import { BaseErrorCode, McpError } from '../types-global/errors.js';
-import { logger } from './logger.js';
+import { BaseErrorCode, McpError } from '../../types-global/errors.js';
+// Import utils from the main barrel file (logger from ../internal/logger.js)
+import { logger } from '../index.js';
 /**
  * Sanitization class for handling various input sanitization tasks
  */
@@ -31,7 +32,7 @@ export class Sanitization {
      * Private constructor to enforce singleton pattern
      */
     constructor() {
-        logger.debug('Sanitization service initialized with modern libraries');
+        // Removed logger call from constructor to prevent logging before initialization
     }
     /**
      * Get the singleton Sanitization instance

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyanheads/git-mcp-server",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "An MCP (Model Context Protocol) server providing tools to interact with Git repositories. Enables LLMs and AI agents to perform Git operations like clone, commit, push, pull, branch, diff, log, status, and more via the MCP standard.",
   "type": "module",
   "license": "Apache-2.0",
@@ -17,42 +17,46 @@
     "node": ">=18.0.0"
   },
   "bin": {
-    "git-mcp-server": "./build/index.js"
+    "git-mcp-server": "./dist/index.js"
   },
   "files": [
-    "build"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
-    "prepare": "npm run build",
-    "watch": "tsc --watch",
-    "inspector": "npx @modelcontextprotocol/inspector build/index.js",
-    "clean": "ts-node scripts/clean.ts",
-    "tree": "ts-node scripts/tree.ts",
-    "rebuild": "npm run clean && npm run build"
+    "build": "tsc && node --loader ts-node/esm scripts/make-executable.ts dist/index.js",
+    "start": "node dist/index.js",
+    "start:stdio": "MCP_LOG_LEVEL=debug MCP_TRANSPORT_TYPE=stdio node dist/index.js",
+    "start:http": "MCP_LOG_LEVEL=debug MCP_TRANSPORT_TYPE=http node dist/index.js",
+    "rebuild": "ts-node --esm scripts/clean.ts && npm run build",
+    "tree": "ts-node --esm scripts/tree.ts",
+    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
+    "clean": "ts-node --esm scripts/clean.ts"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.10.2",
-    "@types/node": "^22.15.3",
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/node": "^22.15.4",
     "@types/sanitize-html": "^2.15.0",
-    "@types/validator": "13.15.0",
+    "@types/validator": "^13.15.0",
+    "chrono-node": "^2.8.0",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "ignore": "^7.0.4",
-    "openai": "^4.96.2",
+    "jsonwebtoken": "^9.0.2",
+    "openai": "^4.97.0",
     "partial-json": "^0.1.7",
     "sanitize-html": "^2.16.0",
     "tiktoken": "^1.0.21",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
-    "validator": "13.15.0",
+    "validator": "^13.15.0",
     "winston": "^3.17.0",
     "winston-daily-rotate-file": "^5.0.0",
     "yargs": "^17.7.2",
-    "zod": "^3.24.3"
+    "zod": "^3.24.4"
   },
   "keywords": [
     "typescript",