@cyanheads/git-mcp-server 1.2.4 → 2.0.2

package/dist/utils/sanitization.js

@@ -0,0 +1,371 @@
+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';
+/**
+ * Sanitization class for handling various input sanitization tasks
+ */
+export class Sanitization {
+    static instance;
+    /** Default list of sensitive fields for sanitizing logs */
+    sensitiveFields = [
+        'password', 'token', 'secret', 'key', 'apiKey', 'auth',
+        'credential', 'jwt', 'ssn', 'credit', 'card', 'cvv', 'authorization'
+    ];
+    /** Default sanitize-html configuration */
+    defaultHtmlSanitizeConfig = {
+        allowedTags: [
+            'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'a', 'ul', 'ol',
+            'li', 'b', 'i', 'strong', 'em', 'strike', 'code', 'hr', 'br',
+            'div', 'table', 'thead', 'tbody', 'tr', 'th', 'td', 'pre'
+        ],
+        allowedAttributes: {
+            'a': ['href', 'name', 'target'],
+            'img': ['src', 'alt', 'title', 'width', 'height'],
+            '*': ['class', 'id', 'style']
+        },
+        preserveComments: false
+    };
+    /**
+     * Private constructor to enforce singleton pattern
+     */
+    constructor() {
+        logger.debug('Sanitization service initialized with modern libraries');
+    }
+    /**
+     * Get the singleton Sanitization instance
+     * @returns Sanitization instance
+     */
+    static getInstance() {
+        if (!Sanitization.instance) {
+            Sanitization.instance = new Sanitization();
+        }
+        return Sanitization.instance;
+    }
+    /**
+     * Set sensitive fields for log sanitization
+     * @param fields Array of field names to consider sensitive
+     */
+    setSensitiveFields(fields) {
+        this.sensitiveFields = [...new Set([...this.sensitiveFields, ...fields])]; // Ensure uniqueness
+        logger.debug('Updated sensitive fields list', { count: this.sensitiveFields.length });
+    }
+    /**
+     * Get the current list of sensitive fields
+     * @returns Array of sensitive field names
+     */
+    getSensitiveFields() {
+        return [...this.sensitiveFields];
+    }
+    /**
+     * Sanitize HTML content using sanitize-html library
+     * @param input HTML string to sanitize
+     * @param config Optional custom sanitization config
+     * @returns Sanitized HTML
+     */
+    sanitizeHtml(input, config) {
+        if (!input)
+            return '';
+        // Create sanitize-html options from our config
+        const options = {
+            allowedTags: config?.allowedTags || this.defaultHtmlSanitizeConfig.allowedTags,
+            allowedAttributes: config?.allowedAttributes || this.defaultHtmlSanitizeConfig.allowedAttributes,
+            transformTags: config?.transformTags
+        };
+        // Handle comments - if preserveComments is true, add '!--' to allowedTags
+        if (config?.preserveComments || this.defaultHtmlSanitizeConfig.preserveComments) {
+            options.allowedTags = [...(options.allowedTags || []), '!--'];
+        }
+        return sanitizeHtml(input, options);
+    }
+    /**
+     * Sanitize string input based on context.
+     *
+     * **Important:** Using `context: 'javascript'` is explicitly disallowed and will throw an `McpError`.
+     * This is a security measure to prevent accidental execution or ineffective sanitization of JavaScript code.
+     *
+     * @param input String to sanitize
+     * @param options Sanitization options
+     * @returns Sanitized string
+     * @throws {McpError} If `context: 'javascript'` is used.
+     */
+    sanitizeString(input, options = {}) {
+        if (!input)
+            return '';
+        // Handle based on context
+        switch (options.context) {
+            case 'html':
+                // Use sanitize-html with custom options
+                return this.sanitizeHtml(input, {
+                    allowedTags: options.allowedTags,
+                    allowedAttributes: options.allowedAttributes ?
+                        this.convertAttributesFormat(options.allowedAttributes) :
+                        undefined
+                });
+            case 'attribute':
+                // Strip HTML tags for attribute context
+                return sanitizeHtml(input, { allowedTags: [], allowedAttributes: {} });
+            case 'url':
+                // Validate and sanitize URL
+                if (!validator.isURL(input, {
+                    protocols: ['http', 'https'],
+                    require_protocol: true
+                })) {
+                    // Return empty string for invalid URLs in this context
+                    logger.warning('Invalid URL detected during string sanitization', { input });
+                    return '';
+                }
+                return validator.trim(input);
+            case 'javascript':
+                // Reject any attempt to sanitize JavaScript
+                logger.error('Attempted JavaScript sanitization via sanitizeString', { input: input.substring(0, 50) });
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, 'JavaScript sanitization not supported through string sanitizer');
+            case 'text':
+            default:
+                // Strip HTML tags for basic text context
+                return sanitizeHtml(input, { allowedTags: [], allowedAttributes: {} });
+        }
+    }
+    /**
+     * Sanitize URL with robust validation and sanitization
+     * @param input URL to sanitize
+     * @param allowedProtocols Allowed URL protocols
+     * @returns Sanitized URL
+     * @throws {McpError} If URL is invalid
+     */
+    sanitizeUrl(input, allowedProtocols = ['http', 'https']) {
+        try {
+            // First validate the URL format
+            if (!validator.isURL(input, {
+                protocols: allowedProtocols,
+                require_protocol: true
+            })) {
+                throw new Error('Invalid URL format or protocol');
+            }
+            // Double-check no javascript: protocol sneaked in
+            const lowerInput = input.toLowerCase().trim();
+            if (lowerInput.startsWith('javascript:')) {
+                throw new Error('JavaScript protocol not allowed');
+            }
+            // Return the trimmed, validated URL
+            return validator.trim(input);
+        }
+        catch (error) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, error instanceof Error ? error.message : 'Invalid URL format', { input });
+        }
+    }
+    /**
+     * Sanitize file paths to prevent path traversal attacks
+     * @param input Path to sanitize
+     * @param options Options for path sanitization
+     * @returns Sanitized and normalized path
+     * @throws {McpError} If path is invalid or unsafe
+     */
+    sanitizePath(input, options = {}) {
+        try {
+            if (!input || typeof input !== 'string') {
+                throw new Error('Invalid path input: must be a non-empty string');
+            }
+            // Apply path normalization using built-in path module
+            let normalized = path.normalize(input);
+            // Prevent null byte injection
+            if (normalized.includes('\0')) {
+                throw new Error('Path contains null byte');
+            }
+            // Convert backslashes to forward slashes if toPosix is true
+            if (options.toPosix) {
+                normalized = normalized.replace(/\\/g, '/');
+            }
+            // Handle absolute paths based on allowAbsolute option
+            if (!options.allowAbsolute && path.isAbsolute(normalized)) {
+                // Remove leading slash or drive letter to make it relative
+                normalized = normalized.replace(/^(?:[A-Za-z]:)?[/\\]/, '');
+            }
+            // If rootDir is specified, ensure the path doesn't escape it
+            if (options.rootDir) {
+                const rootDir = path.resolve(options.rootDir);
+                // Resolve the normalized path against the root dir
+                const fullPath = path.resolve(rootDir, normalized);
+                // More robust check for path traversal: ensure fullPath starts with rootDir + separator
+                // or is exactly rootDir
+                if (!fullPath.startsWith(rootDir + path.sep) && fullPath !== rootDir) {
+                    throw new Error('Path traversal detected');
+                }
+                // Return the path relative to the root
+                return path.relative(rootDir, fullPath);
+            }
+            // Final validation - check for relative path traversal attempts if not rooted
+            if (normalized.includes('..')) {
+                // Resolve the path to see if it escapes the current working directory conceptually
+                const resolvedPath = path.resolve(normalized);
+                const currentWorkingDir = path.resolve('.'); // Or use a safer base if needed
+                if (!resolvedPath.startsWith(currentWorkingDir)) {
+                    throw new Error('Relative path traversal detected');
+                }
+            }
+            return normalized;
+        }
+        catch (error) {
+            logger.warning('Path sanitization error', {
+                input,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, error instanceof Error ? error.message : 'Invalid or unsafe path', { input });
+        }
+    }
+    /**
+     * Sanitize a JSON string
+     * @param input JSON string to sanitize
+     * @param maxSize Maximum allowed size in bytes
+     * @returns Parsed and sanitized object
+     * @throws {McpError} If JSON is invalid or too large
+     */
+    sanitizeJson(input, maxSize) {
+        try {
+            if (typeof input !== 'string') {
+                throw new Error('Invalid input: expected a JSON string');
+            }
+            // Check size limit if specified
+            if (maxSize !== undefined && Buffer.byteLength(input, 'utf8') > maxSize) {
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `JSON exceeds maximum allowed size of ${maxSize} bytes`, { size: Buffer.byteLength(input, 'utf8'), maxSize });
+            }
+            // Validate JSON format using JSON.parse for stricter validation than validator.isJSON
+            const parsed = JSON.parse(input);
+            // Optional: Add recursive sanitization of parsed object values if needed
+            // this.sanitizeObjectRecursively(parsed); 
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof McpError) {
+                throw error;
+            }
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, error instanceof Error ? error.message : 'Invalid JSON format', { input: input.length > 100 ? `${input.substring(0, 100)}...` : input });
+        }
+    }
+    /**
+     * Ensure input is within a numeric range
+     * @param input Number or string to validate
+     * @param min Minimum allowed value (inclusive)
+     * @param max Maximum allowed value (inclusive)
+     * @returns Sanitized number within range
+     * @throws {McpError} If input is not a valid number
+     */
+    sanitizeNumber(input, min, max) {
+        let value;
+        // Handle string input
+        if (typeof input === 'string') {
+            // Use validator for initial check, but rely on parseFloat for conversion
+            if (!validator.isNumeric(input.trim())) {
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, 'Invalid number format', { input });
+            }
+            value = parseFloat(input.trim());
+        }
+        else if (typeof input === 'number') {
+            value = input;
+        }
+        else {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, 'Invalid input type: expected number or string', { input: String(input) });
+        }
+        // Check if parsing resulted in NaN
+        if (isNaN(value) || !isFinite(value)) {
+            throw new McpError(BaseErrorCode.VALIDATION_ERROR, 'Invalid number value (NaN or Infinity)', { input });
+        }
+        // Clamp the value to the specified range
+        if (min !== undefined && value < min) {
+            value = min;
+            logger.debug('Number clamped to minimum value', { input, min, value });
+        }
+        if (max !== undefined && value > max) {
+            value = max;
+            logger.debug('Number clamped to maximum value', { input, max, value });
+        }
+        return value;
+    }
+    /**
+     * Sanitize input for logging to protect sensitive information
+     * @param input Input to sanitize
+     * @returns Sanitized input safe for logging
+     */
+    sanitizeForLogging(input) {
+        try {
+            // Handle non-objects and null directly
+            if (!input || typeof input !== 'object') {
+                return input;
+            }
+            // Use structuredClone for deep copy if available (Node.js >= 17)
+            // Fallback to JSON stringify/parse for older versions
+            const clonedInput = typeof structuredClone === 'function'
+                ? structuredClone(input)
+                : JSON.parse(JSON.stringify(input));
+            // Recursively sanitize the cloned object
+            this.redactSensitiveFields(clonedInput);
+            return clonedInput;
+        }
+        catch (error) {
+            logger.error('Error during log sanitization', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // Return a placeholder if sanitization fails
+            return '[Log Sanitization Failed]';
+        }
+    }
+    /**
+     * Private helper to convert attribute format from record to sanitize-html format
+     */
+    convertAttributesFormat(attrs) {
+        // sanitize-html directly supports Record<string, string[]> for allowedAttributes per tag
+        return attrs;
+    }
+    /**
+     * Recursively redact sensitive fields in an object or array
+     */
+    redactSensitiveFields(obj) {
+        if (!obj || typeof obj !== 'object') {
+            return;
+        }
+        // Handle arrays: iterate and recurse
+        if (Array.isArray(obj)) {
+            obj.forEach((item, index) => {
+                // If the item is an object/array, recurse. Otherwise, leave primitive values.
+                if (item && typeof item === 'object') {
+                    this.redactSensitiveFields(item);
+                }
+            });
+            return;
+        }
+        // Handle regular objects: iterate through keys
+        for (const key in obj) {
+            // Use hasOwnProperty to avoid iterating over prototype properties
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                const value = obj[key];
+                // Check if this key matches any sensitive field pattern (case-insensitive)
+                const isSensitive = this.sensitiveFields.some(field => key.toLowerCase().includes(field.toLowerCase()));
+                if (isSensitive) {
+                    // Mask sensitive value
+                    obj[key] = '[REDACTED]';
+                }
+                else if (value && typeof value === 'object') {
+                    // Recursively process nested objects/arrays
+                    this.redactSensitiveFields(value);
+                }
+                // Primitive values are left as is if not sensitive
+            }
+        }
+    }
+}
+// Create and export singleton instance
+export const sanitization = Sanitization.getInstance();
+// Removed the `sanitizeInput` object export for simplicity.
+// Users should import `sanitization` and call methods directly.
+// e.g., import { sanitization } from './sanitization.js';
+// sanitization.sanitizeHtml(input);
+// sanitization.sanitizePath(input);
+/**
+ * Sanitize input for logging to protect sensitive information.
+ * Kept as a separate export for convenience.
+ * @param input Input to sanitize
+ * @returns Sanitized input safe for logging
+ */
+export const sanitizeInputForLogging = (input) => sanitization.sanitizeForLogging(input);
+// Removed default export

package/dist/utils/tokenCounter.js

@@ -0,0 +1,124 @@
+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';
+// 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
+/**
+ * Calculates the number of tokens for a given text using the 'gpt-4o' tokenizer.
+ * Uses ErrorHandler for consistent error management.
+ *
+ * @param text - The input text to tokenize.
+ * @param context - Optional request context for logging and error handling.
+ * @returns The number of tokens.
+ * @throws {McpError} Throws an McpError if tokenization fails.
+ */
+export async function countTokens(text, context) {
+    // Wrap the synchronous operation in tryCatch which handles both sync/async
+    return ErrorHandler.tryCatch(() => {
+        let encoding = null;
+        try {
+            // Always use the defined TOKENIZATION_MODEL
+            encoding = encoding_for_model(TOKENIZATION_MODEL);
+            const tokens = encoding.encode(text);
+            return tokens.length;
+        }
+        finally {
+            encoding?.free(); // Ensure the encoder is freed if it was successfully created
+        }
+    }, {
+        operation: 'countTokens',
+        context: context,
+        input: { textSample: text.substring(0, 50) + '...' }, // Log sanitized input
+        errorCode: BaseErrorCode.INTERNAL_ERROR, // Use INTERNAL_ERROR for external lib issues
+        rethrow: true // Rethrow as McpError
+        // Removed onErrorReturn as we now rethrow
+    });
+}
+/**
+ * Calculates the number of tokens for chat messages using the ChatCompletionMessageParam structure
+ * and the 'gpt-4o' tokenizer, considering special tokens and message overhead.
+ * This implementation is based on OpenAI's guidelines for gpt-4/gpt-3.5-turbo models.
+ * Uses ErrorHandler for consistent error management.
+ *
+ * See: https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
+ *
+ * @param messages - An array of chat messages in the `ChatCompletionMessageParam` format.
+ * @param context - Optional request context for logging and error handling.
+ * @returns The estimated number of tokens.
+ * @throws {McpError} Throws an McpError if tokenization fails.
+ */
+export async function countChatTokens(messages, // Use the complex type
+context) {
+    // Wrap the synchronous operation in tryCatch
+    return ErrorHandler.tryCatch(() => {
+        let encoding = null;
+        let num_tokens = 0;
+        try {
+            // Always use the defined TOKENIZATION_MODEL
+            encoding = encoding_for_model(TOKENIZATION_MODEL);
+            // Define tokens per message/name based on gpt-4o (same as gpt-4/gpt-3.5-turbo)
+            const tokens_per_message = 3;
+            const tokens_per_name = 1;
+            for (const message of messages) {
+                num_tokens += tokens_per_message;
+                // Encode role
+                num_tokens += encoding.encode(message.role).length;
+                // Encode content - handle potential null or array content (vision)
+                if (typeof message.content === 'string') {
+                    num_tokens += encoding.encode(message.content).length;
+                }
+                else if (Array.isArray(message.content)) {
+                    // Handle multi-part content (e.g., text + image) - simplified: encode text parts only
+                    for (const part of message.content) {
+                        if (part.type === 'text') {
+                            num_tokens += encoding.encode(part.text).length;
+                        }
+                        else {
+                            // Add placeholder token count for non-text parts (e.g., images) if needed
+                            // This requires specific model knowledge (e.g., OpenAI vision model token costs)
+                            logger.warning(`Non-text content part found (type: ${part.type}), token count contribution ignored.`, context);
+                            // num_tokens += IMAGE_TOKEN_COST; // Placeholder
+                        }
+                    }
+                } // else: content is null, add 0 tokens
+                // Encode name if present (often associated with 'tool' or 'function' roles in newer models)
+                if ('name' in message && message.name) {
+                    num_tokens += tokens_per_name;
+                    num_tokens += encoding.encode(message.name).length;
+                }
+                // --- Handle tool calls (specific to newer models) ---
+                // Assistant message requesting tool calls
+                if (message.role === 'assistant' && 'tool_calls' in message && message.tool_calls) {
+                    for (const tool_call of message.tool_calls) {
+                        // Add tokens for the function name and arguments
+                        if (tool_call.function.name) {
+                            num_tokens += encoding.encode(tool_call.function.name).length;
+                        }
+                        if (tool_call.function.arguments) {
+                            // Arguments are often JSON strings
+                            num_tokens += encoding.encode(tool_call.function.arguments).length;
+                        }
+                    }
+                }
+                // Tool message providing results
+                if (message.role === 'tool' && 'tool_call_id' in message && message.tool_call_id) {
+                    num_tokens += encoding.encode(message.tool_call_id).length;
+                    // Content of the tool message (the result) is already handled by the string content check above
+                }
+            }
+            num_tokens += 3; // every reply is primed with <|start|>assistant<|message|>
+            return num_tokens;
+        }
+        finally {
+            encoding?.free();
+        }
+    }, {
+        operation: 'countChatTokens',
+        context: context,
+        input: { messageCount: messages.length }, // Log sanitized input
+        errorCode: BaseErrorCode.INTERNAL_ERROR, // Use INTERNAL_ERROR
+        rethrow: true // Rethrow as McpError
+        // Removed onErrorReturn
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cyanheads/git-mcp-server",
-  "version": "1.2.4",
-  "description": "A Model Context Protocol server for Git integration",
+  "version": "2.0.2",
+  "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",
   "author": "Casey Hand @cyanheads",
@@ -9,31 +9,76 @@
     "type": "git",
     "url": "https://github.com/cyanheads/git-mcp-server"
   },
+  "homepage": "https://github.com/cyanheads/git-mcp-server#readme",
+  "bugs": {
+    "url": "https://github.com/cyanheads/git-mcp-server/issues"
+  },
+  "engines": {
+    "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_TRANSPORT_TYPE=stdio node dist/index.js",
+    "start:http": "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.8.0",
-    "dotenv": "^16.4.7",
-    "zod": "^3.24.2",
-    "@types/node": "^22.13.17",
+    "@modelcontextprotocol/sdk": "^1.10.2",
+    "@types/node": "^22.15.3",
+    "@types/sanitize-html": "^2.15.0",
+    "@types/validator": "13.15.0",
+    "dotenv": "^16.5.0",
+    "express": "^5.1.0",
+    "ignore": "^7.0.4",
+    "openai": "^4.96.2",
+    "partial-json": "^0.1.7",
+    "sanitize-html": "^2.16.0",
+    "tiktoken": "^1.0.21",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.2",
-    "simple-git": "^3.27.0"
+    "typescript": "^5.8.3",
+    "validator": "13.15.0",
+    "winston": "^3.17.0",
+    "winston-daily-rotate-file": "^5.0.0",
+    "yargs": "^17.7.2",
+    "zod": "^3.24.3"
+  },
+  "keywords": [
+    "typescript",
+    "MCP",
+    "model-context-protocol",
+    "LLM",
+    "AI-integration",
+    "server",
+    "git",
+    "version-control",
+    "repository",
+    "commit",
+    "branch",
+    "diff",
+    "log",
+    "status",
+    "push",
+    "pull",
+    "clone",
+    "automation",
+    "devops",
+    "ai-agent",
+    "llm-tools"
+  ],
+  "devDependencies": {
+    "@types/express": "^5.0.1"
   }
 }

package/build/index.js

@@ -1,54 +0,0 @@
-#!/usr/bin/env node
-/**
- * Git MCP Server Entry Point
- * =========================
- *
- * This is the main entry point for the Git MCP server.
- * It creates a server instance and connects it to a stdio transport.
- */
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { GitMcpServer } from './server.js';
-import dotenv from 'dotenv';
-// Load environment variables from .env file if it exists
-dotenv.config();
-/**
- * Main function to start the server
- */
-async function main() {
-    console.error('Starting Git MCP Server...');
-    try {
-        // Create server instance
-        const server = new GitMcpServer();
-        // Use stdio transport for communication
-        const transport = new StdioServerTransport();
-        // Connect the server to the transport
-        await server.connect(transport);
-        console.error('Git MCP Server running on stdio transport');
-        // Handle interruption signals
-        process.on('SIGINT', async () => {
-            console.error('Received SIGINT, shutting down Git MCP Server');
-            process.exit(0);
-        });
-        process.on('SIGTERM', async () => {
-            console.error('Received SIGTERM, shutting down Git MCP Server');
-            process.exit(0);
-        });
-    }
-    catch (error) {
-        console.error('Failed to start Git MCP Server:');
-        console.error(error instanceof Error ? error.message : String(error));
-        if (error instanceof Error && error.stack) {
-            console.error(error.stack);
-        }
-        process.exit(1);
-    }
-}
-// Start the server
-main().catch((error) => {
-    console.error('Unhandled error in main process:');
-    console.error(error instanceof Error ? error.message : String(error));
-    if (error instanceof Error && error.stack) {
-        console.error(error.stack);
-    }
-    process.exit(1);
-});