lazy-mcp 2.2.7 → 2.3.1

package/dist/server-manager.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerManager = void 0;
+exports.ServerManager = exports.DEFAULT_REQUEST_TIMEOUT_MS = void 0;
 const child_process_1 = require("child_process");
 const crypto_1 = require("crypto");
 const types_1 = require("./types");
@@ -8,6 +8,7 @@ const config_1 = require("./config");
 const error_diagnostics_1 = require("./error-diagnostics");
 const oauth_manager_1 = require("./oauth-manager");
 const version_1 = require("./version");
+const logger_1 = require("./logger");
 const eventsource_parser_1 = require("eventsource-parser");
 /** Canonical header name for the MCP session token (lowercase — HTTP headers are case-insensitive). */
 const MCP_SESSION_HEADER = "mcp-session-id";
@@ -16,7 +17,8 @@ const DEFAULT_CACHE_CONFIG = {
     ttl: 0, // No expiration
     maxAccessCount: 0, // No access cap
 };
-const REQUEST_TIMEOUT_MS = 10000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 10000;
+exports.DEFAULT_REQUEST_TIMEOUT_MS = DEFAULT_REQUEST_TIMEOUT_MS;
 const DEFAULT_HEALTH_MONITOR_CONFIG = {
     enabled: true,
     interval: 30000, // 30 seconds
@@ -24,7 +26,7 @@ const DEFAULT_HEALTH_MONITOR_CONFIG = {
     idleTimeout: 300000, // 5 minutes — sleep after this much inactivity
 };
 class RemoteMCPServer {
-    constructor(serverUrl, serverName, headers = {}, oauthManager) {
+    constructor(serverUrl, serverName, headers = {}, oauthManager, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
         /** Session ID from `Mcp-Session-Id` header, populated after `initialize` handshake. */
         this.sessionId = null;
         /** True once the MCP handshake (initialize + notifications/initialized) has completed. */
@@ -33,6 +35,7 @@ class RemoteMCPServer {
         this.initializing = null;
         this.serverUrl = serverUrl;
         this.serverName = serverName;
+        this.timeoutMs = timeoutMs;
         this.headers = {
             "Content-Type": "application/json",
             ...headers,
@@ -40,26 +43,58 @@ class RemoteMCPServer {
         // Every remote server gets an OAuthManager — config overrides defaults if provided
         this.oauthManager = oauthManager ?? new oauth_manager_1.OAuthManager(serverName, serverUrl, {});
     }
+    async withRequestTimeout(label, fn) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            return await fn(controller.signal);
+        }
+        catch (err) {
+            if (err?.name === "AbortError") {
+                throw new types_1.MCPException(types_1.MCPErrorCode.SERVER_TIMEOUT, `Request timed out (${this.timeoutMs / 1000}s) for server '${this.serverName}'`, this.serverName);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
     /**
-     * Parse SSE stream and extract JSON-RPC response matching the request ID
+     * Parse SSE stream and extract JSON-RPC response matching the request ID.
+     * The signal is assumed to be controlled by withRequestTimeout() — when the
+     * timeout fires the outer promise is guaranteed to be rejected.
      */
-    async parseSSEStream(stream, requestId) {
+    async parseSSEStream(stream, requestId, signal) {
         return new Promise((resolve, reject) => {
             const reader = stream.getReader();
             const decoder = new TextDecoder();
             let buffer = "";
-            let resolved = false; // Track if promise is settled
+            let settled = false;
+            const cleanup = () => {
+                signal.removeEventListener("abort", onAbort);
+            };
+            const rejectAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reader.cancel().catch(() => { });
+                const err = new Error("The operation was aborted.");
+                err.name = "AbortError";
+                reject(err);
+            };
+            const onAbort = () => rejectAbort();
+            signal.addEventListener("abort", onAbort, { once: true });
             const parser = (0, eventsource_parser_1.createParser)({
                 onEvent: (event) => {
-                    if (!event.data || resolved)
+                    if (!event.data || settled)
                         return;
                     try {
                         const message = JSON.parse(event.data);
-                        // Check if this is our response
                         if (message.jsonrpc === "2.0" && message.id === requestId) {
-                            resolved = true;
-                            clearTimeout(timeoutId);
-                            reader.cancel(); // Stop reading the stream
+                            settled = true;
+                            cleanup();
+                            reader.cancel().catch(() => { });
                             if (message.error) {
                                 reject(new Error(`MCP Error: ${message.error.message}`));
                             }
@@ -73,10 +108,10 @@ class RemoteMCPServer {
                     }
                 },
                 onError: (error) => {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeoutId);
-                        reader.cancel();
+                    if (!settled) {
+                        settled = true;
+                        cleanup();
+                        reader.cancel().catch(() => { });
                         reject(new Error(`SSE parse error: ${error}`));
                     }
                 },
@@ -86,37 +121,30 @@ class RemoteMCPServer {
                     while (true) {
                         const { done, value } = await reader.read();
                         if (done) {
-                            if (!resolved) {
-                                resolved = true;
-                                clearTimeout(timeoutId);
+                            if (!settled) {
+                                settled = true;
+                                cleanup();
                                 reject(new Error(`SSE stream ended without receiving response for request ${requestId}`));
                             }
                             break;
                         }
-                        // Decode chunk and add to buffer
                         buffer += decoder.decode(value, { stream: true });
-                        // Feed to parser
                         parser.feed(buffer);
                         buffer = "";
                     }
                 }
                 catch (err) {
-                    if (!resolved) {
-                        resolved = true;
-                        clearTimeout(timeoutId);
+                    if (!settled) {
+                        settled = true;
+                        cleanup();
                         reject(err);
                     }
                 }
+                finally {
+                    cleanup();
+                }
             };
             processStream();
-            // Timeout after 30 seconds
-            const timeoutId = setTimeout(() => {
-                if (!resolved) {
-                    resolved = true;
-                    reader.cancel();
-                    reject(new Error(`SSE request timeout for request ${requestId}`));
-                }
-            }, 30000);
         });
     }
     async ensureInitialized() {
@@ -140,7 +168,7 @@ class RemoteMCPServer {
      * 2. Parse `mcp-session-id` from response headers (if present)
      * 3. POST `notifications/initialized` (with session header if we have one)
      *
-     * Both fetch calls are guarded by REQUEST_TIMEOUT_MS via AbortController.
+     * Both phases stay under deadline until fully complete (body read included).
      *
      * This follows the MCP spec for Streamable HTTP transport:
      * https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http
@@ -162,42 +190,27 @@ class RemoteMCPServer {
             ...oauthHeaders,
             Accept: "application/json, text/event-stream",
         };
-        // Guard both fetch calls with REQUEST_TIMEOUT_MS
-        const initAbort = new AbortController();
-        const initTimeout = setTimeout(() => initAbort.abort(), REQUEST_TIMEOUT_MS);
-        let response;
-        try {
-            response = await fetch(this.serverUrl, {
+        const { sessionId, initResult } = await this.withRequestTimeout("initialize", async (signal) => {
+            const response = await fetch(this.serverUrl, {
                 method: "POST",
                 headers: requestHeaders,
                 body: JSON.stringify(initRequest),
-                signal: initAbort.signal,
+                signal,
             });
-        }
-        catch (err) {
-            if (err?.name === "AbortError") {
-                throw new types_1.MCPException(types_1.MCPErrorCode.SERVER_TIMEOUT, `Initialize timed out (${REQUEST_TIMEOUT_MS / 1000}s) for server '${this.serverName}'`, this.serverName, undefined, `The remote server did not respond within ${REQUEST_TIMEOUT_MS / 1000}s. Check that the server is running and reachable.`);
+            if (!response.ok) {
+                await this.handleHttpError(response, oauthHeaders);
             }
-            throw err;
-        }
-        finally {
-            clearTimeout(initTimeout);
-        }
-        if (!response.ok) {
-            await this.handleHttpError(response, oauthHeaders);
-        }
-        // Extract session ID from response headers (may be absent for stateless servers).
-        // Use the canonical lowercase name; fetch Headers are case-insensitive on get().
-        const sessionId = response.headers.get(MCP_SESSION_HEADER);
+            return {
+                sessionId: response.headers.get(MCP_SESSION_HEADER),
+                initResult: await this.parseOkResponse(response, initRequest.id, signal),
+            };
+        });
         if (sessionId) {
             this.sessionId = sessionId;
         }
-        // Parse the initialize result (validates the server understood the handshake)
-        const initResult = await this.parseOkResponse(response, initRequest.id);
         if (!initResult?.protocolVersion) {
             throw new Error(`Server '${this.serverName}' returned invalid initialize response`);
         }
-        // Send notifications/initialized (with session header if we have one)
         const initializedNotification = {
             jsonrpc: "2.0",
             method: "notifications/initialized",
@@ -211,34 +224,27 @@ class RemoteMCPServer {
         if (this.sessionId) {
             notifHeaders[MCP_SESSION_HEADER] = this.sessionId;
         }
-        const notifAbort = new AbortController();
-        const notifTimeout = setTimeout(() => notifAbort.abort(), REQUEST_TIMEOUT_MS);
-        let notifResponse;
-        try {
-            notifResponse = await fetch(this.serverUrl, {
+        await this.withRequestTimeout("notifications/initialized", async (signal) => {
+            const notifResponse = await fetch(this.serverUrl, {
                 method: "POST",
                 headers: notifHeaders,
                 body: JSON.stringify(initializedNotification),
-                signal: notifAbort.signal,
+                signal,
             });
-        }
-        catch (err) {
-            if (err?.name === "AbortError") {
-                throw new types_1.MCPException(types_1.MCPErrorCode.SERVER_TIMEOUT, `notifications/initialized timed out (${REQUEST_TIMEOUT_MS / 1000}s) for server '${this.serverName}'`, this.serverName, undefined, `The remote server did not respond within ${REQUEST_TIMEOUT_MS / 1000}s during the MCP handshake.`);
+            if (!notifResponse.ok) {
+                const body = await notifResponse.text();
+                const logger = (0, logger_1.getLogger)();
+                const preparedBody = logger.prepareBody(body);
+                let details;
+                if (typeof preparedBody.body === 'string') {
+                    details = preparedBody.body.slice(0, 200);
+                }
+                else {
+                    details = (0, logger_1.safeJsonStringify)(preparedBody.body).slice(0, 200);
+                }
+                throw new types_1.MCPException(types_1.MCPErrorCode.SERVER_UNREACHABLE, `MCP handshake failed: server '${this.serverName}' rejected notifications/initialized with HTTP ${notifResponse.status}`, this.serverName, details, `Ensure the server implements the MCP Streamable HTTP transport correctly. It must accept POST notifications/initialized and return a 2xx status.`);
             }
-            throw err;
-        }
-        finally {
-            clearTimeout(notifTimeout);
-        }
-        // Per spec: server MUST return 202 Accepted for notifications (no request ID).
-        // Some servers may return 200 — accept any 2xx.
-        // A non-2xx response means the handshake is incomplete; fail loudly so the
-        // caller sees a clear error rather than a cryptic failure on the next request.
-        if (!notifResponse.ok) {
-            const body = await notifResponse.text().catch(() => "");
-            throw new types_1.MCPException(types_1.MCPErrorCode.SERVER_UNREACHABLE, `MCP handshake failed: server '${this.serverName}' rejected notifications/initialized with HTTP ${notifResponse.status}`, this.serverName, body.slice(0, 200) || undefined, `Ensure the server implements the MCP Streamable HTTP transport correctly. It must accept POST notifications/initialized and return a 2xx status.`);
-        }
+        });
         this.initialized = true;
     }
     /**
@@ -254,9 +260,28 @@ class RemoteMCPServer {
             throw new types_1.MCPException(types_1.MCPErrorCode.AUTH_REQUIRED, `Authentication required for '${this.serverName}'`, this.serverName, undefined, `Open this URL in your browser to authorize:\n\n${authUrl}\n\nlazy-mcp is listening on ${this.oauthManager.redirectUrl} and will capture the token automatically. Once authorized, retry your original command.`);
         }
         const errorText = await response.text();
-        console.error(`Remote server error: HTTP ${response.status} ${response.statusText} - ${errorText}`);
+        const logger = (0, logger_1.getLogger)();
+        const preparedBody = logger.prepareBody(errorText);
+        logger.error("Remote server error", {
+            event: "remote_server_error",
+            server: this.serverName,
+            httpStatus: response.status,
+            httpStatusText: response.statusText,
+            responseBody: preparedBody.body,
+            responseBodyBytes: preparedBody.bodyBytes,
+            responseBodyLoggedBytes: preparedBody.bodyLoggedBytes,
+            responseBodyTruncated: preparedBody.bodyTruncated,
+        });
         const { code, diagnostic } = error_diagnostics_1.ErrorDiagnostics.analyzeHttpError(response.status, this.serverName);
-        throw new types_1.MCPException(code, `HTTP ${response.status}: ${response.statusText}`, this.serverName, errorText.slice(0, 200), diagnostic);
+        let details;
+        if (typeof preparedBody.body === 'string') {
+            details = preparedBody.body.slice(0, 200);
+        }
+        else {
+            const serialized = (0, logger_1.safeJsonStringify)(preparedBody.body);
+            details = serialized.slice(0, 200);
+        }
+        throw new types_1.MCPException(code, `HTTP ${response.status}: ${response.statusText}`, this.serverName, details, diagnostic);
     }
     async makeRequest(method, params, _isRetry = false) {
         if (!this.serverUrl.startsWith("http")) {
@@ -265,7 +290,6 @@ class RemoteMCPServer {
             }
             throw new Error("Only HTTP and WebSocket URLs are supported");
         }
-        // Ensure MCP handshake has been performed (idempotent after first call)
         await this.ensureInitialized();
         const request = {
             jsonrpc: "2.0",
@@ -273,51 +297,48 @@ class RemoteMCPServer {
             method,
             ...(params && { params }),
         };
-        // Inject OAuth headers if we have a valid stored token
         const oauthHeaders = this.oauthManager.getStoredAuthHeaders() ?? {};
         const requestHeaders = {
             ...this.headers,
             ...oauthHeaders,
             Accept: "application/json, text/event-stream",
         };
-        // Include session ID in all requests after initialization
         if (this.sessionId) {
             requestHeaders[MCP_SESSION_HEADER] = this.sessionId;
         }
-        const response = await fetch(this.serverUrl, {
-            method: "POST",
-            headers: requestHeaders,
-            body: JSON.stringify(request),
-        });
-        if (!response.ok) {
-            // Session expired — reset and retry once with a fresh handshake.
-            // Retry regardless of whether we have a sessionId: some servers use a
-            // stateful handshake without returning an Mcp-Session-Id header, and can
-            // still expire the implicit server-side session.
-            // _isRetry guards against infinite loops.
-            if (response.status === 404 && !_isRetry) {
-                console.error(`Session expired for server '${this.serverName}', re-initializing...`);
-                this.initialized = false;
-                this.sessionId = null;
-                return this.makeRequest(method, params, true);
+        return this.withRequestTimeout(`request '${method}'`, async (signal) => {
+            const response = await fetch(this.serverUrl, {
+                method: "POST",
+                headers: requestHeaders,
+                body: JSON.stringify(request),
+                signal,
+            });
+            if (!response.ok) {
+                if (response.status === 404 && !_isRetry) {
+                    (0, logger_1.getLogger)().info(`Session expired for server '${this.serverName}', re-initializing...`, {
+                        event: "remote_session_expired",
+                        server: this.serverName,
+                        method,
+                    });
+                    this.initialized = false;
+                    this.sessionId = null;
+                    return this.makeRequest(method, params, true);
+                }
+                await this.handleHttpError(response, oauthHeaders);
             }
-            await this.handleHttpError(response, oauthHeaders);
-        }
-        return this.parseOkResponse(response, request.id);
+            return this.parseOkResponse(response, request.id, signal);
+        });
     }
     /** Parse a confirmed-ok (2xx) HTTP response into the MCP result value. */
-    async parseOkResponse(response, requestId) {
-        // Check content type of response
+    async parseOkResponse(response, requestId, signal) {
         const contentType = response.headers.get("content-type");
         if (contentType?.includes("text/event-stream")) {
-            // Server responded with SSE stream
             if (!response.body) {
                 throw new Error("SSE response has no body");
             }
-            return await this.parseSSEStream(response.body, requestId);
+            return this.parseSSEStream(response.body, requestId, signal);
         }
         else if (contentType?.includes("application/json")) {
-            // Server responded with JSON (traditional HTTP transport)
             const result = await response.json();
             if (result.error) {
                 throw new Error(`MCP Error: ${result.error.message}`);
@@ -325,8 +346,6 @@ class RemoteMCPServer {
             return result.result;
         }
         else if (response.status === 202) {
-            // 202 Accepted - server will send response via separate GET SSE stream
-            // This is less common; for now we don't support this pattern
             throw new Error("202 Accepted with separate SSE stream not yet supported. Server must respond inline with SSE or JSON.");
         }
         else {
@@ -350,7 +369,72 @@ class RemoteMCPServer {
     }
 }
 class LocalMCPServer {
-    constructor(command, serverName, args = [], env = {}) {
+    invalidateProcessState(child) {
+        if (this.process === child) {
+            this.initialized = false;
+            this.initializing = null;
+        }
+    }
+    resetProcessState(child) {
+        if (this.process === child) {
+            this.invalidateProcessState(child);
+            this.process = null;
+        }
+    }
+    makeWriteError(error) {
+        const details = error instanceof Error ? error.message : String(error);
+        const errorCode = error?.code;
+        const diagnostic = errorCode === "EPIPE" || errorCode === "ERR_STREAM_DESTROYED"
+            ? `Server '${this.serverName}' closed its stdio pipe. Ensure the configured command starts a long-running MCP stdio server (not a one-shot command).`
+            : `Failed writing to server '${this.serverName}'. Check command/configuration and server logs.`;
+        return new types_1.MCPException(types_1.MCPErrorCode.SERVER_CRASHED, `Failed to write request to server '${this.serverName}'`, this.serverName, details, diagnostic);
+    }
+    async writeToProcess(child, payload) {
+        const stdin = child.stdin;
+        if (!stdin || stdin.destroyed || !stdin.writable) {
+            this.invalidateProcessState(child);
+            throw new types_1.MCPException(types_1.MCPErrorCode.SERVER_CRASHED, `Process stdin not available for server '${this.serverName}'`, this.serverName, this.stderrData.slice(-200) || undefined, `Server '${this.serverName}' exited before handling the request. Check command/configuration and server logs.`);
+        }
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                stdin.off("error", onError);
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                this.invalidateProcessState(child);
+                reject(this.makeWriteError(error));
+            };
+            const onError = (error) => {
+                fail(error);
+            };
+            stdin.once("error", onError);
+            try {
+                stdin.write(payload, (error) => {
+                    if (error) {
+                        fail(error);
+                        return;
+                    }
+                    // Defer settle by one turn so late EPIPE emission is still captured
+                    // by the temporary error listener for this write.
+                    setImmediate(() => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        cleanup();
+                        resolve();
+                    });
+                });
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+    }
+    constructor(command, serverName, args = [], env = {}, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
         this.process = null;
         this.stderrData = "";
         this.initialized = false;
@@ -359,6 +443,7 @@ class LocalMCPServer {
         this.serverName = serverName;
         this.args = args;
         this.env = env;
+        this.timeoutMs = timeoutMs;
     }
     ensureProcess() {
         if (!this.process) {
@@ -367,17 +452,24 @@ class LocalMCPServer {
                 stdio: ["pipe", "pipe", "pipe"],
                 env: processEnv,
             });
+            const child = this.process;
             // Allow many concurrent in-flight requests without spurious warnings
             this.process.setMaxListeners(50);
+            child.stdin?.setMaxListeners(50);
+            child.stdout?.setMaxListeners(50);
             // Capture stderr for better error messages
             this.process.stderr?.on("data", (data) => {
                 this.stderrData += data.toString();
             });
+            // Prevent unhandled EPIPE/stream errors from crashing the proxy process.
+            child.stdin?.on("error", () => {
+                this.invalidateProcessState(child);
+            });
             // Persistent close listener: clear the process reference so the next
             // makeRequest() call will spawn a fresh process instead of writing to
             // a dead stdin and hanging until the 10 s timeout fires.
-            this.process.once("close", () => {
-                this.process = null;
+            child.once("close", () => {
+                this.resetProcessState(child);
             });
         }
     }
@@ -406,10 +498,11 @@ class LocalMCPServer {
         if (!initResult?.protocolVersion) {
             throw new Error(`Server '${this.serverName}' returned invalid initialize response`);
         }
-        if (!this.process?.stdin) {
+        const child = this.process;
+        if (!child) {
             throw new Error(`Process stdin not available for server '${this.serverName}'`);
         }
-        this.process.stdin.write(JSON.stringify({
+        await this.writeToProcess(child, JSON.stringify({
             jsonrpc: "2.0",
             method: "notifications/initialized",
             params: {},
@@ -419,9 +512,14 @@ class LocalMCPServer {
     async sendRawRequest(method, params) {
         return new Promise((resolve, reject) => {
             this.ensureProcess();
+            const child = this.process;
+            if (!child) {
+                reject(new types_1.MCPException(types_1.MCPErrorCode.SERVER_CRASHED, `Failed to start server '${this.serverName}'`, this.serverName));
+                return;
+            }
             const request = {
                 jsonrpc: "2.0",
-                id: Date.now(),
+                id: (0, crypto_1.randomUUID)(),
                 method,
                 ...(params && { params }),
             };
@@ -429,11 +527,12 @@ class LocalMCPServer {
             let responseReceived = false;
             const timeoutId = setTimeout(() => {
                 if (!responseReceived) {
-                    this.process?.stdout?.off("data", onData);
-                    const { code, diagnostic } = error_diagnostics_1.ErrorDiagnostics.analyzeTimeout(REQUEST_TIMEOUT_MS, this.stderrData, this.serverName);
-                    reject(new types_1.MCPException(code, `Server timeout (${REQUEST_TIMEOUT_MS / 1000}s)`, this.serverName, this.stderrData.slice(-200) || undefined, diagnostic));
+                    child.stdout?.off("data", onData);
+                    child.off("close", onClose);
+                    const { code, diagnostic } = error_diagnostics_1.ErrorDiagnostics.analyzeTimeout(this.timeoutMs, this.stderrData, this.serverName);
+                    reject(new types_1.MCPException(code, `Server timeout (${this.timeoutMs / 1000}s)`, this.serverName, this.stderrData.slice(-200) || undefined, diagnostic));
                 }
-            }, REQUEST_TIMEOUT_MS);
+            }, this.timeoutMs);
             const onData = (data) => {
                 responseData += data.toString();
                 const lines = responseData.split("\n");
@@ -445,8 +544,8 @@ class LocalMCPServer {
                             if (response.jsonrpc === "2.0" && response.id === request.id) {
                                 responseReceived = true;
                                 clearTimeout(timeoutId);
-                                this.process?.stdout?.off("data", onData);
-                                this.process?.off("close", onClose);
+                                child.stdout?.off("data", onData);
+                                child.off("close", onClose);
                                 if (response.error) {
                                     reject(new Error(`MCP Error: ${response.error.message}`));
                                 }
@@ -466,15 +565,24 @@ class LocalMCPServer {
             const onClose = (code) => {
                 if (!responseReceived) {
                     clearTimeout(timeoutId);
-                    this.process?.stdout?.off("data", onData);
+                    child.stdout?.off("data", onData);
+                    child.off("close", onClose);
                     const analysis = error_diagnostics_1.ErrorDiagnostics.analyzeStderr(this.stderrData, this.serverName);
                     reject(new types_1.MCPException(analysis?.code || types_1.MCPErrorCode.SERVER_CRASHED, `Process exited with code ${code}`, this.serverName, this.stderrData.slice(-200) || undefined, analysis?.diagnostic ||
                         `Server exited unexpectedly. Check stderr for details.`));
                 }
             };
-            this.process.stdout?.on("data", onData);
-            this.process.once("close", onClose);
-            this.process.stdin?.write(JSON.stringify(request) + "\n");
+            child.stdout?.on("data", onData);
+            child.once("close", onClose);
+            this.writeToProcess(child, JSON.stringify(request) + "\n").catch((error) => {
+                if (!responseReceived) {
+                    responseReceived = true;
+                    clearTimeout(timeoutId);
+                    child.stdout?.off("data", onData);
+                    child.off("close", onClose);
+                    reject(error);
+                }
+            });
         });
     }
     async makeRequest(method, params) {
@@ -508,7 +616,7 @@ class ServerManager {
         const ref = version === 'unknown' ? 'main' : `v${version}`;
         return `https://gitlab.com/gitlab-org/ai/lazy-mcp/-/blob/${ref}/AGENTS.md`;
     }
-    constructor(serverConfigs, cacheConfig = DEFAULT_CACHE_CONFIG, healthMonitorConfig, configFile) {
+    constructor(serverConfigs, cacheConfig = DEFAULT_CACHE_CONFIG, healthMonitorConfig, configFile, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
         this.servers = new Map();
         this.healthMonitorTimer = null;
         this.probing = false;
@@ -518,6 +626,7 @@ class ServerManager {
         /** Resolves when the first health probe round completes. null if monitor is disabled. */
         this.firstProbeComplete = null;
         this.cacheConfig = cacheConfig;
+        this.requestTimeoutMs = requestTimeoutMs;
         this.healthMonitorConfig = {
             ...DEFAULT_HEALTH_MONITOR_CONFIG,
             ...healthMonitorConfig,
@@ -525,8 +634,11 @@ class ServerManager {
         if (configFile)
             this.configFile = configFile;
         if (cacheConfig.strategy === "persistent") {
-            console.error('Warning: cache strategy "persistent" is not yet implemented and will behave as "session" (in-memory). ' +
-                'Remove cachePath from your config or use strategy: "session".');
+            (0, logger_1.getLogger)().info('Warning: cache strategy "persistent" is not yet implemented and will behave as "session" (in-memory). ' +
+                'Remove cachePath from your config or use strategy: "session".', {
+                event: "cache_strategy_warning",
+                strategy: cacheConfig.strategy,
+            });
         }
         for (const config of serverConfigs) {
             // Only add servers that are enabled (default to true if not specified)
@@ -812,15 +924,41 @@ class ServerManager {
         return Date.now() - health.lastChecked < cacheDuration;
     }
     async callTool(serverName, toolName, arguments_) {
+        const startedAt = Date.now();
+        const logger = (0, logger_1.getLogger)();
         const managed = this.servers.get(serverName);
         if (!managed) {
             throw new types_1.MCPException(types_1.MCPErrorCode.SERVER_NOT_FOUND, `Server '${serverName}' not found`, serverName, undefined, `Available servers: ${Array.from(this.servers.keys()).join(", ")}`);
         }
         const server = await this.getServer(serverName);
+        logger.info("Downstream tool execution started", {
+            event: "downstream_tool_execution",
+            phase: "start",
+            server: serverName,
+            command: toolName,
+        });
         try {
-            return await server.callTool(toolName, arguments_);
+            const result = await server.callTool(toolName, arguments_);
+            logger.info("Downstream tool execution completed", {
+                event: "downstream_tool_execution",
+                phase: "finish",
+                status: "ok",
+                server: serverName,
+                command: toolName,
+                durationMs: Date.now() - startedAt,
+            });
+            return result;
         }
         catch (error) {
+            logger.error("Downstream tool execution failed", {
+                event: "downstream_tool_execution",
+                phase: "finish",
+                status: "error",
+                server: serverName,
+                command: toolName,
+                durationMs: Date.now() - startedAt,
+                error,
+            });
             // If the call failed, the server process may have died. Reset the
             // managed.server reference so the next call spawns a fresh connection
             // rather than writing to a dead process and hanging until timeout.
@@ -845,7 +983,7 @@ class ServerManager {
             const oauthManager = config.oauth
                 ? new oauth_manager_1.OAuthManager(config.name, config.url, config.oauth)
                 : undefined;
-            return new RemoteMCPServer(config.url, config.name, config.headers || {}, oauthManager);
+            return new RemoteMCPServer(config.url, config.name, config.headers || {}, oauthManager, this.requestTimeoutMs);
         }
         else {
             if (!config.command) {
@@ -870,7 +1008,7 @@ class ServerManager {
                 args = config.args || [];
             }
             const env = config.env ? config_1.ConfigLoader.processEnv(config.env) : {};
-            return new LocalMCPServer(command, config.name, args, env);
+            return new LocalMCPServer(command, config.name, args, env, this.requestTimeoutMs);
         }
     }
     /**
@@ -885,7 +1023,10 @@ class ServerManager {
             this._startTimer();
             // Fire an immediate probe on wake (non-blocking).
             this.probeAllServers().catch((err) => {
-                console.error("Health monitor error:", err);
+                (0, logger_1.getLogger)().error("Health monitor error", {
+                    event: "health_monitor_error",
+                    error: err,
+                });
             });
         }
     }
@@ -933,7 +1074,10 @@ class ServerManager {
                 }
             }
             this.probeAllServers().catch((err) => {
-                console.error("Health monitor error:", err);
+                (0, logger_1.getLogger)().error("Health monitor error", {
+                    event: "health_monitor_error",
+                    error: err,
+                });
             });
         }, this.healthMonitorConfig.interval);
         // Don't let the timer keep the process alive