fix: multiple fixes for remote mcp error and timeout

Author: bywang56

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/mcp/mcpEventHandler.ts

@@ -786,6 +786,7 @@ export class McpEventHandler {
         }
 
         this.#currentEditingServerName = undefined
+        this.#serverNameBeforeUpdate = undefined
 
         // need to check server state now, as there is possibility of error during server initialization
         const serverStatusError = this.#getServerStatusError(serverName)
@@ -1238,7 +1239,7 @@ export class McpEventHandler {
             const serverConfig = McpManager.instance.getAllServerConfigs().get(serverName)
             if (serverConfig) {
                 // Emit server initialize event after permission change
-                const transportType = serverConfig.command ? 'stdio' : 'http'
+                const transportType = serverConfig.command?.trim() ? 'stdio' : 'http'
                 this.#telemetryController?.emitMCPServerInitializeEvent({
                     source: 'updatePermission',
                     command: transportType === 'stdio' ? serverConfig.command : undefined,
@@ -1319,7 +1320,7 @@ export class McpEventHandler {
                 enabled: enabled,
                 numTools: mcpManager.getAllToolsWithPermissions(serverName).length,
                 scope: config.__configPath__ === globalAgentPath ? 'global' : 'workspace',
-                transportType: 'stdio',
+                transportType: transportType,
                 languageServerVersion: this.#features.runtime.serverInfo.version,
             })
         }

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/mcp/mcpManager.ts

@@ -292,7 +292,7 @@ export class McpManager {
             this.features.logging.debug(`MCP: initializing server [${serverName}]`)
 
             const client = new Client({
-                name: `mcp-client-${serverName}`,
+                name: `q-chat-plugin`, // Do not use server name in the client name to avoid polluting builder-mcp metrics
                 version: '1.0.0',
             })
 
@@ -662,7 +662,7 @@ export class McpManager {
                 disabled: cfg.disabled ?? false,
             }
             // Only add timeout to agent config if it's not 0
-            if (cfg.timeout !== 0) {
+            if (cfg.timeout !== undefined) {
                 serverConfig.timeout = cfg.timeout
             }
             if (cfg.args && cfg.args.length > 0) {
@@ -1281,11 +1281,21 @@ export class McpManager {
     private handleError(server: string | undefined, err: unknown) {
         const msg = err instanceof Error ? err.message : String(err)
 
-        this.features.logging.error(`MCP ERROR${server ? ` [${server}]` : ''}: ${msg}`)
+        const isBenignSseDisconnect =
+            /SSE error:\s*TypeError:\s*terminated:\s*Body Timeout Error/i.test(msg) ||
+            /TypeError:\s*terminated:\s*Body Timeout Error/i.test(msg) ||
+            /TypeError:\s*terminated:\s*other side closed/i.test(msg) ||
+            /ECONNRESET|ENETRESET|EPIPE/i.test(msg)
 
-        if (server) {
-            this.setState(server, McpServerStatus.FAILED, 0, msg)
-            this.emitToolsChanged(server)
+        if (isBenignSseDisconnect) {
+            this.features.logging.debug(`MCP SSE idle timeout${server ? ` [${server}]` : ''}: ${msg}`)
+        } else {
+            // default path for real errors
+            this.features.logging.error(`MCP ERROR${server ? ` [${server}]` : ''}: ${msg}`)
+            if (server) {
+                this.setState(server, McpServerStatus.FAILED, 0, msg)
+                this.emitToolsChanged(server)
+            }
         }
     }
 

server/aws-lsp-codewhisperer/src/language-server/agenticChat/tools/mcp/mcpOauthClient.ts

@@ -3,7 +3,7 @@
  * All Rights Reserved. SPDX-License-Identifier: Apache-2.0
  */
 
-import fetch, { type RequestInit } from 'node-fetch'
+import type { RequestInit } from 'node-fetch'
 import * as crypto from 'crypto'
 import * as path from 'path'
 import { spawn } from 'child_process'
@@ -56,11 +56,16 @@ export class OAuthClient {
             const port = Number(new URL(savedReg.redirect_uri).port)
             server = http.createServer()
             try {
-                await new Promise<void>(res => server.listen(port, '127.0.0.1', res))
+                await this.listen(server, port)
                 redirectUri = savedReg.redirect_uri
                 this.logger.info(`OAuth: reusing redirect URI ${redirectUri}`)
             } catch (e: any) {
                 if (e.code === 'EADDRINUSE') {
+                    try {
+                        server.close()
+                    } catch {
+                        /* ignore */
+                    }
                     this.logger.warn(`Port ${port} in use; falling back to new random port`)
                     ;({ server, redirectUri } = await this.buildCallbackServer())
                     this.logger.info(`OAuth: new redirect URI ${redirectUri}`)
@@ -131,17 +136,16 @@ export class OAuthClient {
     // Spin up a one‑time HTTP listener on localhost:randomPort */
     private static async buildCallbackServer(): Promise<{ server: http.Server; redirectUri: string }> {
         const server = http.createServer()
-        const port = await new Promise<number>(res =>
-            server.listen(0, '127.0.0.1', () => res((server.address() as any).port))
-        )
+        await this.listen(server, 0)
+        const port = (server.address() as any).port as number
         return { server, redirectUri: `http://localhost:${port}` }
     }
 
     /** Discover OAuth endpoints by HEAD/WWW‑Authenticate, well‑known, or fallback */
     private static async discoverAS(rs: URL): Promise<Meta> {
         // a) HEAD → WWW‑Authenticate → resource_metadata
         try {
-            const h = await fetch(rs.toString(), { method: 'HEAD' })
+            const h = await this.fetchCompat(rs.toString(), { method: 'HEAD' })
             const header = h.headers.get('www-authenticate') || ''
             const m = /resource_metadata=(?:"([^"]+)"|([^,\s]+))/i.exec(header)
             if (m) {
@@ -259,7 +263,7 @@ export class OAuthClient {
             client_id: reg.client_id,
             resource: rs.toString(),
         })
-        const res = await fetch(meta.token_endpoint, {
+        const res = await this.fetchCompat(meta.token_endpoint, {
             method: 'POST',
             headers: { 'content-type': 'application/x-www-form-urlencoded' },
             body: form,
@@ -332,7 +336,7 @@ export class OAuthClient {
             redirect_uri: redirectUri,
             resource: rs.toString(),
         })
-        const res2 = await fetch(meta.token_endpoint, {
+        const res2 = await this.fetchCompat(meta.token_endpoint, {
             method: 'POST',
             headers: { 'content-type': 'application/x-www-form-urlencoded' },
             body: form2,
@@ -347,7 +351,7 @@ export class OAuthClient {
 
     /** Fetch + error‑check + parse JSON */
     private static async json<T>(url: string, init?: RequestInit): Promise<T> {
-        const r = await fetch(url, init)
+        const r = await this.fetchCompat(url, init)
         if (!r.ok) {
             const txt = await r.text().catch(() => '')
             throw new Error(`HTTP ${r.status}@${url} — ${txt}`)
@@ -393,4 +397,39 @@ export class OAuthClient {
         'sso',
         'cache'
     )
+
+    /**
+     * Await server.listen() but reject if it emits 'error' (eg EADDRINUSE),
+     * so callers can handle it immediately instead of hanging.
+     */
+    private static listen(server: http.Server, port: number, host: string = '127.0.0.1'): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const onListening = () => {
+                server.off('error', onError)
+                resolve()
+            }
+            const onError = (err: NodeJS.ErrnoException) => {
+                server.off('listening', onListening)
+                reject(err)
+            }
+            server.once('listening', onListening)
+            server.once('error', onError)
+            server.listen(port, host)
+        })
+    }
+
+    /**
+     * Fetch compatibility: use global fetch on Node >= 18, otherwise dynamically import('node-fetch').
+     * Using Function('return import(...)') avoids downleveling to require() in CJS builds.
+     */
+    private static async fetchCompat(url: string, init?: RequestInit): Promise<any> {
+        const g = globalThis as any
+        if (typeof g.fetch === 'function') {
+            return g.fetch(url as any, init as any)
+        }
+        // Dynamic import of ESM node-fetch (only when global fetch is unavailable)
+        const mod = await (Function('return import("node-fetch")')() as Promise<any>)
+        const f = mod.default ?? mod
+        return f(url as any, init as any)
+    }
 }

server/aws-lsp-codewhisperer/src/shared/localProjectContextController.ts

@@ -85,7 +85,7 @@ export class LocalProjectContextController {
         try {
             await waitUntil(async () => this.instance, {
                 interval: 1000,
-                timeout: 60,
+                timeout: 60_000,
                 truthy: true,
             })
 
@@ -359,7 +359,7 @@ export class LocalProjectContextController {
                     }
                     return false
                 },
-                { interval: 1000, timeout: 60, truthy: true }
+                { interval: 1000, timeout: 60_000, truthy: true }
             )
             return true
         } catch (error) {