@structured-world/gitlab-mcp 6.62.1 → 7.0.1

package/dist/src/server.js

@@ -54,24 +54,38 @@ const index_2 = require("./middleware/index");
 const index_js_1 = require("./dashboard/index.js");
 const request_logger_1 = require("./utils/request-logger");
 const index_3 = require("./logging/index");
+function resolveCloseReason(socketError, res) {
+    if (socketError)
+        return `peer_reset:${socketError}`;
+    if (res.writableFinished)
+        return 'normal_close';
+    if (res.locals?.writeTimedOut)
+        return 'write_timeout';
+    if (res.locals?.heartbeatFailed)
+        return 'heartbeat_failed';
+    if (res.destroyed)
+        return 'destroyed';
+    return 'client_disconnect';
+}
+const KEEP_ALIVE_TIMEOUT_MS = Math.min(config_1.HTTP_KEEPALIVE_TIMEOUT_MS, config_1.MAX_SAFE_TIMEOUT_MS - 5000);
 async function sendToolsListChangedNotification() {
     try {
         const sessionManager = (0, session_manager_1.getSessionManager)();
         await sessionManager.broadcastToolsListChanged();
     }
     catch (error) {
-        (0, logger_1.logError)("Failed to broadcast tools/list_changed notification", { err: error });
+        (0, logger_1.logError)('Failed to broadcast tools/list_changed notification', { err: error });
     }
 }
 function registerOAuthEndpoints(app) {
-    app.get("/.well-known/oauth-authorization-server", index_1.metadataHandler);
-    app.get("/.well-known/oauth-protected-resource", index_1.protectedResourceHandler);
-    app.get("/authorize", index_1.authorizeHandler);
-    app.get("/oauth/poll", index_1.pollHandler);
-    app.get("/oauth/callback", index_1.callbackHandler);
-    app.post("/token", express_1.default.urlencoded({ extended: true }), index_1.tokenHandler);
-    app.post("/register", express_1.default.json(), index_1.registerHandler);
-    (0, logger_1.logInfo)("OAuth endpoints registered");
+    app.get('/.well-known/oauth-authorization-server', index_1.metadataHandler);
+    app.get('/.well-known/oauth-protected-resource', index_1.protectedResourceHandler);
+    app.get('/authorize', index_1.authorizeHandler);
+    app.get('/oauth/poll', index_1.pollHandler);
+    app.get('/oauth/callback', index_1.callbackHandler);
+    app.post('/token', express_1.default.urlencoded({ extended: true }), index_1.tokenHandler);
+    app.post('/register', express_1.default.json(), index_1.registerHandler);
+    (0, logger_1.logInfo)('OAuth endpoints registered');
 }
 function isTLSEnabled() {
     return !!(config_1.SSL_CERT_PATH && config_1.SSL_KEY_PATH);
@@ -87,16 +101,16 @@ function loadTLSOptions() {
         };
         if (config_1.SSL_CA_PATH) {
             options.ca = fs.readFileSync(config_1.SSL_CA_PATH);
-            (0, logger_1.logInfo)("CA certificate loaded", { path: config_1.SSL_CA_PATH });
+            (0, logger_1.logInfo)('CA certificate loaded', { path: config_1.SSL_CA_PATH });
         }
         if (config_1.SSL_PASSPHRASE) {
             options.passphrase = config_1.SSL_PASSPHRASE;
         }
-        (0, logger_1.logInfo)("TLS certificates loaded", { path: config_1.SSL_CERT_PATH });
+        (0, logger_1.logInfo)('TLS certificates loaded', { path: config_1.SSL_CERT_PATH });
         return options;
     }
     catch (error) {
-        (0, logger_1.logError)("Failed to load TLS certificates", { err: error });
+        (0, logger_1.logError)('Failed to load TLS certificates', { err: error });
         throw new Error(`Failed to load TLS certificates: ${String(error)}`, { cause: error });
     }
 }
@@ -105,27 +119,27 @@ function configureTrustProxy(app) {
         return;
     }
     let trustValue = config_1.TRUST_PROXY;
-    if (config_1.TRUST_PROXY === "true" || config_1.TRUST_PROXY === "1") {
+    if (config_1.TRUST_PROXY === 'true' || config_1.TRUST_PROXY === '1') {
         trustValue = true;
     }
-    else if (config_1.TRUST_PROXY === "false" || config_1.TRUST_PROXY === "0") {
+    else if (config_1.TRUST_PROXY === 'false' || config_1.TRUST_PROXY === '0') {
         trustValue = false;
     }
     else if (!isNaN(Number(config_1.TRUST_PROXY))) {
         trustValue = Number(config_1.TRUST_PROXY);
     }
-    app.set("trust proxy", trustValue);
-    (0, logger_1.logInfo)("Trust proxy configured", { trustValue: String(trustValue) });
+    app.set('trust proxy', trustValue);
+    (0, logger_1.logInfo)('Trust proxy configured', { trustValue: String(trustValue) });
 }
 function configureServerTimeouts(server) {
-    server.keepAliveTimeout = config_1.HTTP_KEEPALIVE_TIMEOUT_MS;
-    server.headersTimeout = config_1.HTTP_KEEPALIVE_TIMEOUT_MS + 5000;
+    server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
+    server.headersTimeout = KEEP_ALIVE_TIMEOUT_MS + 5000;
     server.timeout = 0;
-    server.on("connection", (socket) => {
+    server.on('connection', (socket) => {
         socket.setKeepAlive(true, 30000);
         socket.setNoDelay(true);
     });
-    (0, logger_1.logInfo)("HTTP server timeouts configured for SSE streaming", {
+    (0, logger_1.logInfo)('HTTP server timeouts configured for SSE streaming', {
         keepAliveTimeout: server.keepAliveTimeout,
         headersTimeout: server.headersTimeout,
         timeout: server.timeout,
@@ -145,7 +159,7 @@ function startHttpServer(app, callback) {
     }
 }
 function getProtocol() {
-    return isTLSEnabled() ? "https" : "http";
+    return isTLSEnabled() ? 'https' : 'http';
 }
 const HEARTBEAT_DRAIN_TIMEOUT_MS = 10000;
 function startSseHeartbeat(res, sessionId) {
@@ -157,7 +171,7 @@ function startSseHeartbeat(res, sessionId) {
             pendingDrainTimeout = undefined;
         }
         waitingForDrain = false;
-        (0, logger_1.logDebug)("SSE heartbeat drain recovered", { sessionId });
+        (0, logger_1.logDebug)('SSE heartbeat drain recovered', { sessionId });
     };
     const interval = setInterval(() => {
         if (waitingForDrain)
@@ -169,20 +183,20 @@ function startSseHeartbeat(res, sessionId) {
                     clearTimeout(pendingDrainTimeout);
                     pendingDrainTimeout = undefined;
                 }
-                res.removeListener("drain", drainListener);
+                res.removeListener('drain', drainListener);
                 return;
             }
-            const ok = res.write(": ping\n\n");
+            const ok = res.write(': ping\n\n');
             if (!ok) {
                 waitingForDrain = true;
                 pendingDrainTimeout = setTimeout(() => {
                     pendingDrainTimeout = undefined;
                     waitingForDrain = false;
-                    res.removeListener("drain", drainListener);
-                    (0, logger_1.logWarn)("SSE heartbeat drain timeout — destroying dead connection", {
+                    res.removeListener('drain', drainListener);
+                    (0, logger_1.logWarn)('SSE heartbeat drain timeout — destroying dead connection', {
                         sessionId,
                         drainTimeoutMs: HEARTBEAT_DRAIN_TIMEOUT_MS,
-                        reason: "heartbeat_drain_timeout",
+                        reason: 'heartbeat_drain_timeout',
                     });
                     clearInterval(interval);
                     res.locals = res.locals ?? {};
@@ -191,62 +205,62 @@ function startSseHeartbeat(res, sessionId) {
                         res.destroy();
                     }
                 }, HEARTBEAT_DRAIN_TIMEOUT_MS);
-                res.once("drain", drainListener);
+                res.once('drain', drainListener);
             }
         }
         catch (err) {
             const errMsg = err instanceof Error ? err.message : String(err);
-            (0, logger_1.logWarn)("SSE heartbeat write error — connection likely dead", {
+            (0, logger_1.logWarn)('SSE heartbeat write error — connection likely dead', {
                 sessionId,
                 error: errMsg,
-                reason: "heartbeat_write_error",
+                reason: 'heartbeat_write_error',
             });
             clearInterval(interval);
             if (pendingDrainTimeout) {
                 clearTimeout(pendingDrainTimeout);
                 pendingDrainTimeout = undefined;
             }
-            res.removeListener("drain", drainListener);
+            res.removeListener('drain', drainListener);
         }
     }, config_1.SSE_HEARTBEAT_MS);
-    (0, logger_1.logDebug)("SSE heartbeat started", { sessionId, intervalMs: config_1.SSE_HEARTBEAT_MS });
+    (0, logger_1.logDebug)('SSE heartbeat started', { sessionId, intervalMs: config_1.SSE_HEARTBEAT_MS });
     return () => {
         clearInterval(interval);
         if (pendingDrainTimeout) {
             clearTimeout(pendingDrainTimeout);
             pendingDrainTimeout = undefined;
         }
-        res.removeListener("drain", drainListener);
-        (0, logger_1.logDebug)("SSE heartbeat stopped", { sessionId });
+        res.removeListener('drain', drainListener);
+        (0, logger_1.logDebug)('SSE heartbeat stopped', { sessionId });
     };
 }
 function determineTransportMode() {
     const args = process.argv.slice(2);
-    (0, logger_1.logInfo)("Transport mode detection", { args, PORT: config_1.PORT });
-    if (args.includes("stdio")) {
-        (0, logger_1.logInfo)("Selected stdio mode (explicit argument)");
-        return "stdio";
+    (0, logger_1.logInfo)('Transport mode detection', { args, PORT: config_1.PORT });
+    if (args.includes('stdio')) {
+        (0, logger_1.logInfo)('Selected stdio mode (explicit argument)');
+        return 'stdio';
     }
     if (process.env.PORT) {
-        (0, logger_1.logInfo)("Selected dual transport mode (SSE + StreamableHTTP) - PORT environment variable detected");
-        return "dual";
+        (0, logger_1.logInfo)('Selected dual transport mode (SSE + StreamableHTTP) - PORT environment variable detected');
+        return 'dual';
     }
-    (0, logger_1.logInfo)("Selected stdio mode (no PORT environment variable)");
-    return "stdio";
+    (0, logger_1.logInfo)('Selected stdio mode (no PORT environment variable)');
+    return 'stdio';
 }
 async function startServer() {
     const oauthConfig = (0, index_1.loadOAuthConfig)();
     if (oauthConfig) {
-        (0, logger_1.logInfo)("Starting in OAuth mode (per-user authentication)");
-        (0, logger_1.logInfo)("OAuth client ID configured", { clientId: oauthConfig.gitlabClientId });
+        (0, logger_1.logInfo)('Starting in OAuth mode (per-user authentication)');
+        (0, logger_1.logInfo)('OAuth client ID configured', { clientId: oauthConfig.gitlabClientId });
     }
     else if (process.env.GITLAB_TOKEN) {
-        (0, logger_1.logInfo)("Starting in static token mode (shared GITLAB_TOKEN)");
+        (0, logger_1.logInfo)('Starting in static token mode (shared GITLAB_TOKEN)');
     }
     else {
-        (0, logger_1.logInfo)("Starting without authentication - tools/list will work, but tool calls require GITLAB_TOKEN");
+        (0, logger_1.logInfo)('Starting without authentication - tools/list will work, but tool calls require GITLAB_TOKEN');
     }
-    (0, logger_1.logInfo)("Authentication mode", { mode: (0, index_1.getAuthModeDescription)() });
+    (0, logger_1.logInfo)('Authentication mode', { mode: (0, index_1.getAuthModeDescription)() });
     if (oauthConfig) {
         await index_1.sessionStore.initialize();
     }
@@ -254,28 +268,29 @@ async function startServer() {
     sessionManager.start();
     const requestTracker = (0, index_3.getRequestTracker)();
     const connectionTracker = (0, index_3.getConnectionTracker)();
-    const useCondensedLogging = config_1.LOG_FORMAT === "condensed";
+    const useCondensedLogging = config_1.LOG_FORMAT === 'condensed';
     requestTracker.setEnabled(useCondensedLogging);
     connectionTracker.setEnabled(useCondensedLogging);
-    (0, logger_1.logInfo)("Access log format", { logFormat: config_1.LOG_FORMAT });
+    (0, logger_1.logInfo)('Access log format', { logFormat: config_1.LOG_FORMAT });
     if (config_1.LOG_FILTER.length > 0) {
-        (0, logger_1.logInfo)("Access log filter rules active", { count: config_1.LOG_FILTER.length });
+        (0, logger_1.logInfo)('Access log filter rules active', { count: config_1.LOG_FILTER.length });
     }
     const transportMode = determineTransportMode();
     switch (transportMode) {
-        case "stdio": {
+        case 'stdio': {
             const transport = new stdio_js_1.StdioServerTransport();
-            await sessionManager.createSession("stdio", transport);
-            (0, logger_1.logInfo)("GitLab MCP Server running on stdio");
+            await sessionManager.createSession(session_manager_1.STDIO_SESSION_ID, transport);
+            (0, logger_1.logInfo)('GitLab MCP Server running on stdio');
             break;
         }
-        case "dual": {
-            (0, logger_1.logInfo)("Setting up dual transport mode (SSE + StreamableHTTP)...");
+        case 'dual': {
+            (0, logger_1.logInfo)('Setting up dual transport mode (SSE + StreamableHTTP)...');
             const app = (0, express_1.default)();
+            app.use((0, index_2.responseWriteTimeoutMiddleware)());
             app.use(express_1.default.json());
             configureTrustProxy(app);
-            app.get("/health", (_req, res) => {
-                res.status(200).json({ status: "ok" });
+            app.get('/health', (_req, res) => {
+                res.status(200).json({ status: 'ok' });
             });
             app.use((req, res, next) => {
                 if (!useCondensedLogging) {
@@ -288,18 +303,22 @@ async function startServer() {
                 }
                 const requestId = crypto.randomUUID();
                 const clientIp = (0, request_logger_1.getIpAddress)(req);
-                const sessionId = req.headers["mcp-session-id"];
+                const sessionId = req.headers['mcp-session-id'];
                 res.locals.accessLogRequestId = requestId;
                 requestTracker.openStack(requestId, clientIp, req.method, req.path, sessionId);
-                res.on("finish", () => {
+                res.on('finish', () => {
                     requestTracker.closeStack(requestId, res.statusCode);
                 });
-                res.on("close", () => {
+                res.on('close', () => {
                     if (res.writableFinished) {
                         return;
                     }
                     if (!res.headersSent) {
-                        requestTracker.closeStackWithError(requestId, "connection_closed");
+                        requestTracker.closeStackWithError(requestId, 'connection_closed');
+                        return;
+                    }
+                    if (res.locals?.writeTimedOut) {
+                        requestTracker.closeStackWithError(requestId, 'write_timeout');
                         return;
                     }
                     requestTracker.closeStack(requestId, res.statusCode);
@@ -311,16 +330,16 @@ async function startServer() {
                 registerOAuthEndpoints(app);
             }
             if (config_1.DASHBOARD_ENABLED) {
-                app.get("/", index_js_1.dashboardHandler);
-                (0, logger_1.logInfo)("Dashboard enabled at GET /");
+                app.get('/', index_js_1.dashboardHandler);
+                (0, logger_1.logInfo)('Dashboard enabled at GET /');
             }
-            app.use(["/", "/mcp"], (req, res, next) => {
-                const accept = req.headers.accept ?? "";
-                if (req.method === "POST" && !accept.includes("text/event-stream")) {
+            app.use(['/', '/mcp'], (req, res, next) => {
+                const accept = req.headers.accept ?? '';
+                if (req.method === 'POST' && !accept.includes('text/event-stream')) {
                     req.headers.accept = accept
                         ? `${accept}, text/event-stream`
-                        : "application/json, text/event-stream";
-                    (0, logger_1.logDebug)("Modified Accept header for MCP compatibility", {
+                        : 'application/json, text/event-stream';
+                    (0, logger_1.logDebug)('Modified Accept header for MCP compatibility', {
                         originalAccept: accept,
                         newAccept: req.headers.accept,
                     });
@@ -328,13 +347,13 @@ async function startServer() {
                 next();
             });
             if ((0, index_1.isOAuthEnabled)()) {
-                app.use(["/", "/mcp"], index_2.oauthAuthMiddleware);
+                app.use(['/', '/mcp'], index_2.oauthAuthMiddleware);
             }
             const sseTransports = {};
             const streamableTransports = {};
-            app.get("/sse", async (req, res) => {
-                (0, logger_1.logDebug)("SSE endpoint hit!");
-                const transport = new sse_js_1.SSEServerTransport("/messages", res);
+            app.get('/sse', async (req, res) => {
+                (0, logger_1.logDebug)('SSE endpoint hit!');
+                const transport = new sse_js_1.SSEServerTransport('/messages', res);
                 const sessionId = transport.sessionId;
                 const clientIp = (0, request_logger_1.getIpAddress)(req);
                 const accessLogRequestId = res.locals?.accessLogRequestId;
@@ -344,12 +363,12 @@ async function startServer() {
                 try {
                     await sessionManager.createSession(sessionId, transport);
                     sseTransports[sessionId] = transport;
-                    (0, logger_1.logDebug)("SSE transport created with session", { sessionId });
+                    (0, logger_1.logDebug)('SSE transport created with session', { sessionId });
                     connectionTracker.openConnection(sessionId, clientIp);
                     connectionTracker.incrementRequests(sessionId);
                 }
                 catch (error) {
-                    (0, logger_1.logError)("Failed to create SSE session", { err: error, sessionId });
+                    (0, logger_1.logError)('Failed to create SSE session', { err: error, sessionId });
                     if (!res.headersSent) {
                         res.status(500).end();
                     }
@@ -359,40 +378,32 @@ async function startServer() {
                 let socketError;
                 const socket = res.socket;
                 if (socket) {
-                    socket.on("error", (err) => {
+                    socket.on('error', (err) => {
                         socketError = err.code ?? err.message;
-                        (0, logger_1.logWarn)("SSE socket error", {
+                        (0, logger_1.logWarn)('SSE socket error', {
                             sessionId,
                             error: err.message,
                             code: err.code,
-                            reason: "socket_error",
+                            reason: 'socket_error',
                         });
                     });
                 }
-                res.on("close", () => {
+                res.on('close', () => {
                     stopHeartbeat();
                     delete sseTransports[sessionId];
-                    const reason = socketError
-                        ? `peer_reset:${socketError}`
-                        : res.writableFinished
-                            ? "normal_close"
-                            : res.locals?.heartbeatFailed
-                                ? "heartbeat_failed"
-                                : res.destroyed
-                                    ? "destroyed"
-                                    : "client_disconnect";
-                    (0, logger_1.logInfo)("SSE session disconnected", { sessionId, reason });
+                    const reason = resolveCloseReason(socketError, res);
+                    (0, logger_1.logInfo)('SSE session disconnected', { sessionId, reason });
                     connectionTracker.closeConnection(sessionId, reason);
                     sessionManager.removeSession(sessionId).catch((error) => {
-                        (0, logger_1.logDebug)("Error removing SSE session on disconnect", { err: error, sessionId });
+                        (0, logger_1.logDebug)('Error removing SSE session on disconnect', { err: error, sessionId });
                     });
                 });
             });
-            app.post("/messages", async (req, res) => {
-                (0, logger_1.logDebug)("SSE messages endpoint hit!");
+            app.post('/messages', async (req, res) => {
+                (0, logger_1.logDebug)('SSE messages endpoint hit!');
                 const sessionId = req.query.sessionId;
                 if (!sessionId || !sseTransports[sessionId]) {
-                    res.status(404).json({ error: "Session not found" });
+                    res.status(404).json({ error: 'Session not found' });
                     return;
                 }
                 connectionTracker.incrementRequests(sessionId);
@@ -414,14 +425,14 @@ async function startServer() {
                     }
                 }
                 catch (error) {
-                    (0, logger_1.logError)("Error handling SSE message", { err: error });
+                    (0, logger_1.logError)('Error handling SSE message', { err: error });
                     if (!res.headersSent) {
-                        res.status(500).json({ error: "Internal server error" });
+                        res.status(500).json({ error: 'Internal server error' });
                     }
                 }
             });
-            app.all(["/", "/mcp"], async (req, res) => {
-                const sessionId = req.headers["mcp-session-id"];
+            app.all(['/', '/mcp'], async (req, res) => {
+                const sessionId = req.headers['mcp-session-id'];
                 const accessLogRequestId = res.locals.accessLogRequestId;
                 const clientIp = (0, request_logger_1.getIpAddress)(req);
                 const oauthSessionId = res.locals.oauthSessionId;
@@ -432,8 +443,8 @@ async function startServer() {
                 const instanceLabel = res.locals.instanceLabel;
                 if (!useCondensedLogging) {
                     const requestContext = (0, request_logger_1.getRequestContext)(req, res);
-                    (0, logger_1.logInfo)("MCP endpoint request received", {
-                        event: "mcp_request",
+                    (0, logger_1.logInfo)('MCP endpoint request received', {
+                        event: 'mcp_request',
                         ...requestContext,
                         hasToken: !!gitlabToken,
                     });
@@ -476,8 +487,8 @@ async function startServer() {
                     else {
                         if (sessionId) {
                             res.status(404).json({
-                                error: "Session not found",
-                                message: "Your session has expired. Please reconnect.",
+                                error: 'Session not found',
+                                message: 'Your session has expired. Please reconnect.',
                             });
                             return;
                         }
@@ -487,7 +498,7 @@ async function startServer() {
                             sessionIdGenerator: () => newSessionId,
                             onsessioninitialized: (initializedSessionId) => {
                                 streamableTransports[initializedSessionId] = transport;
-                                (0, logger_1.logInfo)("MCP session initialized", {
+                                (0, logger_1.logInfo)('MCP session initialized', {
                                     sessionId: initializedSessionId,
                                     method: req.method,
                                 });
@@ -501,46 +512,38 @@ async function startServer() {
                             onsessionclosed: (closedSessionId) => {
                                 delete streamableTransports[closedSessionId];
                                 index_1.sessionStore.removeMcpSessionAssociation(closedSessionId);
-                                connectionTracker.closeConnection(closedSessionId, "session_closed");
+                                connectionTracker.closeConnection(closedSessionId, 'session_closed');
                                 sessionManager.removeSession(closedSessionId).catch((err) => {
-                                    (0, logger_1.logDebug)("Error removing closed session", { err, sessionId: closedSessionId });
+                                    (0, logger_1.logDebug)('Error removing closed session', { err, sessionId: closedSessionId });
                                 });
-                                (0, logger_1.logInfo)("StreamableHTTP session closed", {
+                                (0, logger_1.logInfo)('StreamableHTTP session closed', {
                                     sessionId: closedSessionId,
-                                    reason: "session_closed",
+                                    reason: 'session_closed',
                                 });
                             },
                         });
                         await sessionManager.createSession(newSessionId, transport);
                         await handleWithContext(transport);
                     }
-                    if (req.method === "GET" && !res.writableEnded) {
+                    if (req.method === 'GET' && !res.writableEnded) {
                         const stopHeartbeat = startSseHeartbeat(res, effectiveSessionId);
                         let socketError;
                         const socket = res.socket;
                         if (socket) {
-                            socket.on("error", (err) => {
+                            socket.on('error', (err) => {
                                 socketError = err.code ?? err.message;
-                                (0, logger_1.logWarn)("StreamableHTTP GET socket error", {
+                                (0, logger_1.logWarn)('StreamableHTTP GET socket error', {
                                     sessionId: effectiveSessionId,
                                     error: err.message,
                                     code: err.code,
-                                    reason: "socket_error",
+                                    reason: 'socket_error',
                                 });
                             });
                         }
-                        res.on("close", () => {
+                        res.on('close', () => {
                             stopHeartbeat();
-                            const reason = socketError
-                                ? `peer_reset:${socketError}`
-                                : res.writableFinished
-                                    ? "normal_close"
-                                    : res.locals?.heartbeatFailed
-                                        ? "heartbeat_failed"
-                                        : res.destroyed
-                                            ? "destroyed"
-                                            : "client_disconnect";
-                            (0, logger_1.logInfo)("StreamableHTTP GET stream disconnected", {
+                            const reason = resolveCloseReason(socketError, res);
+                            (0, logger_1.logInfo)('StreamableHTTP GET stream disconnected', {
                                 sessionId: effectiveSessionId,
                                 reason,
                             });
@@ -548,76 +551,89 @@ async function startServer() {
                     }
                 }
                 catch (error) {
-                    (0, logger_1.logError)("Error in StreamableHTTP transport", { err: error });
+                    (0, logger_1.logError)('Error in StreamableHTTP transport', { err: error });
                     if (!res.headersSent) {
-                        res.status(500).json({ error: "Internal server error" });
+                        res.status(500).json({ error: 'Internal server error' });
                     }
                 }
             });
             startHttpServer(app, () => {
                 const url = `${getProtocol()}://${config_1.HOST}:${config_1.PORT}`;
-                (0, logger_1.logInfo)("GitLab MCP Server running", { url });
+                (0, logger_1.logInfo)('GitLab MCP Server running', { url });
                 if (isTLSEnabled()) {
-                    (0, logger_1.logInfo)("TLS/HTTPS enabled");
+                    (0, logger_1.logInfo)('TLS/HTTPS enabled');
                 }
-                (0, logger_1.logInfo)("Dual Transport Mode Active");
-                (0, logger_1.logInfo)("SSE endpoint", { endpoint: `${url}/sse`, note: "backwards compatibility" });
-                (0, logger_1.logInfo)("StreamableHTTP endpoint", {
+                (0, logger_1.logInfo)('Dual Transport Mode Active');
+                (0, logger_1.logInfo)('SSE endpoint', { endpoint: `${url}/sse`, note: 'backwards compatibility' });
+                (0, logger_1.logInfo)('StreamableHTTP endpoint', {
                     endpoint: `${url}/mcp`,
-                    note: "modern, supports SSE + JSON-RPC",
+                    note: 'modern, supports SSE + JSON-RPC',
                 });
                 if ((0, index_1.isOAuthEnabled)()) {
-                    (0, logger_1.logInfo)("OAuth Mode Active");
-                    (0, logger_1.logInfo)("OAuth metadata", { endpoint: `${url}/.well-known/oauth-authorization-server` });
-                    (0, logger_1.logInfo)("Authorization endpoint", { endpoint: `${url}/authorize` });
-                    (0, logger_1.logInfo)("Token exchange endpoint", { endpoint: `${url}/token` });
+                    (0, logger_1.logInfo)('OAuth Mode Active');
+                    (0, logger_1.logInfo)('OAuth metadata', { endpoint: `${url}/.well-known/oauth-authorization-server` });
+                    (0, logger_1.logInfo)('Authorization endpoint', { endpoint: `${url}/authorize` });
+                    (0, logger_1.logInfo)('Token exchange endpoint', { endpoint: `${url}/token` });
                 }
-                (0, logger_1.logInfo)("SSE keepalive configured for proxy chain compatibility", {
+                (0, logger_1.logInfo)('SSE keepalive configured for proxy chain compatibility', {
                     heartbeatMs: config_1.SSE_HEARTBEAT_MS,
-                    keepAliveTimeoutMs: config_1.HTTP_KEEPALIVE_TIMEOUT_MS,
+                    keepAliveTimeoutMs: KEEP_ALIVE_TIMEOUT_MS,
                 });
-                (0, logger_1.logInfo)("Clients can use either transport as needed");
+                if (config_1.RESPONSE_WRITE_TIMEOUT_MS > 0) {
+                    (0, logger_1.logInfo)('Response write timeout enabled (zombie connection detection)', {
+                        responseWriteTimeoutMs: config_1.RESPONSE_WRITE_TIMEOUT_MS,
+                    });
+                }
+                (0, logger_1.logInfo)('Clients can use either transport as needed');
             });
             break;
         }
     }
 }
 async function gracefulShutdown(signal) {
-    (0, logger_1.logInfo)("Shutting down GitLab MCP Server...", { signal });
+    (0, logger_1.logInfo)('Shutting down GitLab MCP Server...', { signal });
     try {
         const connTracker = (0, index_3.getConnectionTracker)();
-        connTracker.closeAllConnections("server_shutdown");
-        (0, logger_1.logInfo)("All connections closed for shutdown");
+        connTracker.closeAllConnections('server_shutdown');
+        (0, logger_1.logInfo)('All connections closed for shutdown');
+    }
+    catch (error) {
+        (0, logger_1.logError)('Error closing connections', { err: error });
+    }
+    try {
+        const { HealthMonitor } = await Promise.resolve().then(() => __importStar(require('./services/HealthMonitor')));
+        HealthMonitor.getInstance().shutdown();
+        (0, logger_1.logInfo)('Health monitor shut down successfully');
     }
     catch (error) {
-        (0, logger_1.logError)("Error closing connections", { err: error });
+        (0, logger_1.logError)('Error shutting down health monitor', { err: error });
     }
     try {
         const sm = (0, session_manager_1.getSessionManager)();
         await sm.shutdown();
-        (0, logger_1.logInfo)("Session manager shut down successfully");
+        (0, logger_1.logInfo)('Session manager shut down successfully');
     }
     catch (error) {
-        (0, logger_1.logError)("Error shutting down session manager", { err: error });
+        (0, logger_1.logError)('Error shutting down session manager', { err: error });
     }
     try {
         await index_1.sessionStore.close();
-        (0, logger_1.logInfo)("Session store closed successfully");
+        (0, logger_1.logInfo)('Session store closed successfully');
     }
     catch (error) {
-        (0, logger_1.logError)("Error closing session store", { err: error });
+        (0, logger_1.logError)('Error closing session store', { err: error });
     }
     process.exit(0);
 }
-process.on("SIGINT", () => {
-    gracefulShutdown("SIGINT").catch(err => {
-        (0, logger_1.logError)("Error during graceful shutdown", { err });
+process.on('SIGINT', () => {
+    gracefulShutdown('SIGINT').catch((err) => {
+        (0, logger_1.logError)('Error during graceful shutdown', { err });
         process.exit(1);
     });
 });
-process.on("SIGTERM", () => {
-    gracefulShutdown("SIGTERM").catch(err => {
-        (0, logger_1.logError)("Error during graceful shutdown", { err });
+process.on('SIGTERM', () => {
+    gracefulShutdown('SIGTERM').catch((err) => {
+        (0, logger_1.logError)('Error during graceful shutdown', { err });
         process.exit(1);
     });
 });