@cyanheads/git-mcp-server 2.0.2 → 2.0.4

package/dist/utils/{sanitization.js → 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.2",
+  "version": "2.0.4",
   "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",
@@ -25,8 +25,8 @@
   "scripts": {
     "build": "tsc && node --loader ts-node/esm scripts/make-executable.ts dist/index.js",
     "start": "node dist/index.js",
-    "start:stdio": "MCP_TRANSPORT_TYPE=stdio node dist/index.js",
-    "start:http": "MCP_TRANSPORT_TYPE=http 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",
@@ -36,24 +36,27 @@
     "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",

package/dist/types-global/mcp.js

@@ -1,59 +0,0 @@
-// Type definitions for the MCP (Message Control Protocol) protocol
-// and standard JSON-RPC 2.0 structures
-// Standard JSON-RPC 2.0 Error Codes
-export var JsonRpcErrorCode;
-(function (JsonRpcErrorCode) {
-    JsonRpcErrorCode[JsonRpcErrorCode["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-    JsonRpcErrorCode[JsonRpcErrorCode["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-    JsonRpcErrorCode[JsonRpcErrorCode["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-    JsonRpcErrorCode[JsonRpcErrorCode["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-    JsonRpcErrorCode[JsonRpcErrorCode["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-    // -32000 to -32099 are reserved for implementation-defined server-errors.
-    JsonRpcErrorCode[JsonRpcErrorCode["SERVER_ERROR_START"] = -32000] = "SERVER_ERROR_START";
-    JsonRpcErrorCode[JsonRpcErrorCode["SERVER_ERROR_END"] = -32099] = "SERVER_ERROR_END";
-})(JsonRpcErrorCode || (JsonRpcErrorCode = {}));
-// ==================================
-// Helper Functions (Updated for JSON-RPC context)
-// ==================================
-/**
- * Creates a JSON-RPC 2.0 Success Response containing an McpToolResult.
- */
-export const createJsonRpcToolSuccessResponse = (id, text) => ({
-    jsonrpc: "2.0",
-    result: {
-        content: [{ type: "text", text }]
-    },
-    id
-});
-/**
- * Creates a JSON-RPC 2.0 Error Response.
- */
-export const createJsonRpcErrorResponse = (id, code, message, data) => ({
-    jsonrpc: "2.0",
-    error: {
-        code,
-        message,
-        ...(data !== undefined && { data }) // Include data only if provided
-    },
-    id
-});
-/**
- * Creates a JSON-RPC 2.0 Success Response containing an McpResourceResult.
- */
-export const createJsonRpcResourceSuccessResponse = (id, uri, text, mimeType) => ({
-    jsonrpc: "2.0",
-    result: {
-        contents: [{ uri, text, mimeType }]
-    },
-    id
-});
-// Note: PromptResponse helper might need adjustment depending on how prompts fit into JSON-RPC
-export const createPromptResponse = (text, role = "assistant") => ({
-    messages: [{
-            role,
-            content: {
-                type: "text",
-                text
-            }
-        }]
-});

package/dist/types-global/tool.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/logger.js

@@ -1,266 +0,0 @@
-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);