@cyanheads/git-mcp-server 1.2.4 → 2.0.2

package/dist/config/index.js

@@ -0,0 +1,69 @@
+import dotenv from "dotenv";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { logger } from "../utils/logger.js"; // Import McpLogLevel and logger
+dotenv.config(); // Load environment variables from .env file
+// Determine the directory name of the current module
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Construct the path to package.json relative to the current file
+const pkgPath = join(__dirname, '../../package.json');
+// Default package information in case package.json is unreadable
+let pkg = { name: 'mcp-ts-template', version: '0.0.0' };
+try {
+    // Read and parse package.json to get server name and version
+    pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+}
+catch (error) {
+    // Silently use default pkg info if reading fails. Error will be logged later if needed.
+}
+/**
+ * Main application configuration object.
+ * Aggregates settings from environment variables and package.json.
+ */
+export const config = {
+    /** The name of the MCP server, derived from package.json. */
+    mcpServerName: pkg.name,
+    /** The version of the MCP server, derived from package.json. */
+    mcpServerVersion: pkg.version,
+    /** Logging level for the application (e.g., "debug", "info", "warning", "error"). Defaults to "info". */
+    logLevel: process.env.MCP_LOG_LEVEL || "info", // Use MCP_LOG_LEVEL consistently
+    /** The runtime environment (e.g., "development", "production"). Defaults to "development". */
+    environment: process.env.NODE_ENV || "development",
+    /** Security-related configurations. */
+    security: {
+        // Placeholder for security settings
+        // Example: authRequired: process.env.AUTH_REQUIRED === 'true'
+        /** Indicates if authentication is required for server operations. */
+        authRequired: false,
+    }
+    // Note: mcpClient configuration is now loaded separately from mcp-config.json
+};
+/**
+ * The configured logging level for the application.
+ * Exported separately for convenience (e.g., logger initialization).
+ * @type {string}
+ */
+export const logLevel = config.logLevel;
+/**
+ * The configured runtime environment for the application.
+ * Exported separately for convenience.
+ * @type {string}
+ */
+export const environment = config.environment;
+// Define valid MCP log levels based on the logger's type definition
+const validMcpLogLevels = ['debug', 'info', 'notice', 'warning', 'error', 'crit', 'alert', 'emerg'];
+// Validate the configured log level
+let validatedMcpLogLevel = 'info'; // Default to 'info'
+if (validMcpLogLevels.includes(logLevel)) {
+    validatedMcpLogLevel = logLevel;
+}
+else {
+    // Silently default to 'info' if the configured level is invalid.
+    // The logger initialization message will show the actual level being used.
+}
+// Initialize the logger with the validated MCP level AFTER config is defined.
+logger.initialize(validatedMcpLogLevel);
+// Log initialization message using the logger itself (will go to file and potentially MCP)
+logger.info(`Logger initialized. MCP logging level: ${validatedMcpLogLevel}`);
+logger.debug("Configuration loaded successfully", { config }); // Log loaded config at debug level

package/dist/index.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'; // Import McpServer type
+import { config, environment } from "./config/index.js";
+import { initializeAndStartServer } from "./mcp-server/server.js"; // Updated import
+import { logger } from "./utils/logger.js";
+// Import the service instance instead of the standalone function
+import { requestContextService } from "./utils/requestContext.js";
+/**
+ * The main MCP server instance.
+ * @type {McpServer | undefined}
+ */
+let server;
+/**
+ * Gracefully shuts down the main MCP server.
+ * Handles process termination signals (SIGTERM, SIGINT) and critical errors.
+ *
+ * @param signal - The signal or event name that triggered the shutdown (e.g., "SIGTERM", "uncaughtException").
+ */
+const shutdown = async (signal) => {
+    // Define context for the shutdown operation
+    const shutdownContext = {
+        operation: 'Shutdown',
+        signal,
+    };
+    logger.info(`Received ${signal}. Starting graceful shutdown...`, shutdownContext);
+    try {
+        // Close the main MCP server
+        if (server) {
+            logger.info("Closing main MCP server...", shutdownContext);
+            await server.close();
+            logger.info("Main MCP server closed successfully", shutdownContext);
+        }
+        else {
+            logger.warning("Server instance not found during shutdown.", shutdownContext);
+        }
+        logger.info("Graceful shutdown completed successfully", shutdownContext);
+        process.exit(0);
+    }
+    catch (error) {
+        // Handle any errors during shutdown
+        logger.error("Critical error during shutdown", {
+            ...shutdownContext,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined
+        });
+        process.exit(1); // Exit with error code if shutdown fails
+    }
+};
+/**
+ * Initializes and starts the main MCP server.
+ * Sets up request context, initializes the server instance, starts the transport,
+ * and registers signal handlers for graceful shutdown and error handling.
+ */
+const start = async () => {
+    // Create application-level request context using the service instance
+    const transportType = (process.env.MCP_TRANSPORT_TYPE || 'stdio').toLowerCase();
+    const startupContext = requestContextService.createRequestContext({
+        operation: `ServerStartup_${transportType}`, // Include transport in operation name
+        appName: config.mcpServerName,
+        appVersion: config.mcpServerVersion,
+        environment: environment
+    });
+    logger.info(`Starting ${config.mcpServerName} v${config.mcpServerVersion} (Transport: ${transportType})...`, startupContext);
+    try {
+        // Initialize the server instance and start the selected transport
+        logger.debug("Initializing and starting MCP server transport", startupContext);
+        // Start the server transport. For stdio, this returns the server instance.
+        // For http, it sets up the listener and returns void (or potentially the http.Server).
+        // We only need to store the instance for stdio shutdown.
+        const potentialServerInstance = await initializeAndStartServer();
+        if (transportType === 'stdio' && potentialServerInstance instanceof McpServer) {
+            server = potentialServerInstance; // Store only for stdio
+        }
+        else {
+            // For HTTP, server instances are managed per-session in server.ts
+            // The main http server listener keeps the process alive.
+            // Shutdown for HTTP needs to handle closing the main http server.
+            // We might need to return the httpServer from initializeAndStartServer if
+            // we want to close it explicitly here during shutdown.
+            // For now, we don't store anything globally for HTTP transport.
+        }
+        // If initializeAndStartServer failed, it would have thrown an error,
+        // and execution would jump to the outer catch block.
+        logger.info(`${config.mcpServerName} is running with ${transportType} transport`, {
+            ...startupContext,
+            startTime: new Date().toISOString(),
+        });
+        // --- Signal and Error Handling Setup ---
+        // Handle process signals for graceful shutdown
+        process.on("SIGTERM", () => shutdown("SIGTERM"));
+        process.on("SIGINT", () => shutdown("SIGINT"));
+        // Handle uncaught exceptions
+        process.on("uncaughtException", async (error) => {
+            const errorContext = {
+                ...startupContext, // Include base context for correlation
+                event: 'uncaughtException',
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined
+            };
+            logger.error("Uncaught exception detected. Initiating shutdown...", errorContext);
+            // Attempt graceful shutdown; shutdown() handles its own errors.
+            await shutdown("uncaughtException");
+            // If shutdown fails internally, it will call process.exit(1).
+            // If shutdown succeeds, it calls process.exit(0).
+            // If shutdown itself throws unexpectedly *before* exiting, this process might terminate abruptly,
+            // but the core shutdown logic is handled within shutdown().
+        });
+        // Handle unhandled promise rejections
+        process.on("unhandledRejection", async (reason) => {
+            const rejectionContext = {
+                ...startupContext, // Include base context for correlation
+                event: 'unhandledRejection',
+                reason: reason instanceof Error ? reason.message : String(reason),
+                stack: reason instanceof Error ? reason.stack : undefined
+            };
+            logger.error("Unhandled promise rejection detected. Initiating shutdown...", rejectionContext);
+            // Attempt graceful shutdown; shutdown() handles its own errors.
+            await shutdown("unhandledRejection");
+            // Similar logic as uncaughtException: shutdown handles its exit codes.
+        });
+    }
+    catch (error) {
+        // Handle critical startup errors (already logged by ErrorHandler or caught above)
+        // Log the final failure context, including error details, before exiting
+        logger.error("Critical error during startup, exiting.", {
+            ...startupContext,
+            finalErrorContext: 'Startup Failure',
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        process.exit(1);
+    }
+};
+// Start the application
+start();