@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.8

package/dist/init.d.ts

@@ -3,8 +3,7 @@ import type { McpExtensionState } from "./state.ts";
 import { type McpAdapterOptions, type McpConfig } from "./types.ts";
 import { type McpOAuthRuntime } from "./mcp-oauth-runtime.ts";
 import { type McpRuntimeOwner } from "./runtime-owner.ts";
-/** Most servers one multi-server pass connects at once. */
-export declare const MAX_CONCURRENT_SERVER_CONNECTS = 10;
+export { MAX_CONCURRENT_SERVER_CONNECTS } from "./utils.ts";
 export declare function clearFailure(state: McpExtensionState, serverName: string): void;
 export declare function recordFailure(state: McpExtensionState, serverName: string, message: string): void;
 type McpInitializationOptions = McpAdapterOptions & {
@@ -24,4 +23,3 @@ export declare function updateStatusBar(state: McpExtensionState): void;
 export declare function getFailureAgeSeconds(state: McpExtensionState, serverName: string): number | null;
 export declare function getFailureMessage(state: McpExtensionState, serverName: string): string | null;
 export declare function lazyConnect(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<boolean>;
-export {};

package/dist/init.js

@@ -1,4 +1,4 @@
-import { isServerDisabled } from "./types.js";
+import { isServerDisabled, } from "./types.js";
 import { cloneMcpConfig, isPathInsideProject, loadMcpConfig } from "./config.js";
 import { ConsentManager } from "./consent-manager.js";
 import { McpLifecycleManager } from "./lifecycle.js";
@@ -6,17 +6,16 @@ import { computeServerHash, getMetadataCachePath, getMissingConfiguredDirectTool
 import { McpServerManager } from "./server-manager.js";
 import { buildToolMetadata, totalToolCount } from "./tool-metadata.js";
 import { UiResourceHandler } from "./ui-resource-handler.js";
-import { formatMcpStatus, openUrl, parallelLimit, sanitizeTerminalText } from "./utils.js";
+import { formatMcpStatus, MAX_CONCURRENT_SERVER_CONNECTS, openUrl, parallelLimit, sanitizeTerminalText, } from "./utils.js";
 import { logger } from "./logger.js";
 import { throwIfAborted } from "./abort.js";
 import { getAuthStorageOptions } from "./mcp-auth.js";
-import { createOAuthRuntime, hasPendingAuth, shutdownOAuth } from "./mcp-oauth-runtime.js";
+import { createOAuthRuntime, hasPendingAuth, shutdownOAuth, } from "./mcp-oauth-runtime.js";
 import { combineAbortSignals, createMcpRuntimeOwner, createOwnedUi, isAbortError, } from "./runtime-owner.js";
 import { publishMcpStatusSnapshot } from "./mcp-status.js";
 const FAILURE_BACKOFF_MS = 60 * 1000;
 const MAX_FAILURE_MESSAGE_CHARS = 8 * 1024;
-/** Most servers one multi-server pass connects at once. */
-export const MAX_CONCURRENT_SERVER_CONNECTS = 10;
+export { MAX_CONCURRENT_SERVER_CONNECTS } from "./utils.js";
 const failureExpiryTimers = new WeakMap();
 function getFailureExpiryTimers(state) {
     let timers = failureExpiryTimers.get(state);
@@ -31,8 +30,9 @@ export function clearFailure(state, serverName) {
     state.failureMessages?.delete(serverName);
     const timers = failureExpiryTimers.get(state);
     const timer = timers?.get(serverName);
-    if (timer)
+    if (timer) {
         clearTimeout(timer);
+    }
     timers?.delete(serverName);
 }
 export function recordFailure(state, serverName, message) {
@@ -72,8 +72,7 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
             ? cloneMcpConfig(options.resolvedConfig)
             : loadMcpConfig(options.configPath ?? pi.getFlag("mcp-config"), cwd);
     const authStorageOptions = getAuthStorageOptions(config.settings?.oauthDir, cwd);
-    const metadataCacheEnabled = (ctx.isProjectTrusted?.() ?? true)
-        || !isPathInsideProject(getMetadataCachePath(), cwd);
+    const metadataCacheEnabled = (ctx.isProjectTrusted?.() ?? true) || !isPathInsideProject(getMetadataCachePath(), cwd);
     const ownsOAuthRuntime = options.oauthRuntime === undefined;
     const oauthRuntime = options.oauthRuntime ?? createOAuthRuntime(owner.signal);
     const manager = new McpServerManager(cwd);
@@ -88,10 +87,8 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
             autoApprove: samplingAutoApprove,
             ...(ui !== undefined ? { ui } : {}),
             modelRegistry,
-            getCurrentModel: () => owner.isActive() ? ctx.model : undefined,
-            getSignal: () => owner.isActive()
-                ? combineAbortSignals(owner.signal, ctx.signal)
-                : owner.signal,
+            getCurrentModel: () => (owner.isActive() ? ctx.model : undefined),
+            getSignal: () => owner.isActive() ? combineAbortSignals(owner.signal, ctx.signal) : owner.signal,
         });
     }
     const elicitationEnabled = config.settings?.elicitation !== false && hasUI;
@@ -142,18 +139,21 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
         },
         ...(ui !== undefined ? { ui } : {}),
         sendMessage: (message, options) => {
-            if (!owner.isActive())
+            if (!owner.isActive()) {
                 return;
+            }
             pi.sendMessage(message, options);
         },
         ...(options.statusEvents !== undefined ? { statusEvents: options.statusEvents } : {}),
         ...(options.onToolCall ? { onToolCall: options.onToolCall } : {}),
     };
-    if (ownsOAuthRuntime)
+    if (ownsOAuthRuntime) {
         owner.addCleanup(() => shutdownOAuth(oauthRuntime));
+    }
     manager.setMetadataListChangedListener?.((serverName, reason) => {
-        if (!owner.isActive())
+        if (!owner.isActive()) {
             return;
+        }
         updateServerMetadata(state, serverName);
         updateMetadataCache(state, serverName, { preserveEmptyResources: false });
         notifyToolMetadataUpdated(state, serverName, reason);
@@ -214,33 +214,42 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
         try {
             const connection = await manager.connect(name, definition, runtimeSignal);
             if (connection.status === "needs-auth") {
-                return { name, definition, connection: null, error: `OAuth authentication required. Run /mcp-auth ${name}.` };
+                return {
+                    name,
+                    definition,
+                    connection: null,
+                    error: `OAuth authentication required. Run /mcp-auth ${name}.`,
+                };
             }
             return { name, definition, connection, error: null };
         }
         catch (error) {
             if (isAbortError(error, runtimeSignal)) {
-                if (owner.signal.aborted)
+                if (owner.signal.aborted) {
                     throw error;
+                }
                 return { name, definition, connection: null, error: null };
             }
             const message = error instanceof Error ? error.message : String(error);
             return { name, definition, connection: null, error: message };
         }
     });
-    if (initialSignal?.aborted)
+    if (initialSignal?.aborted) {
         return state;
+    }
     owner.throwIfInactive();
     const startupCache = { entries: new Map() };
     try {
         for (const { name, definition, connection, error } of results) {
             owner.throwIfInactive();
             if (error || !connection) {
-                if (initialSignal?.aborted)
+                if (initialSignal?.aborted) {
                     continue;
+                }
                 saveMetadataCacheUpdates(state, startupCache);
-                if (error)
+                if (error) {
                     recordFailure(state, name, error);
+                }
                 const displayError = sanitizeTerminalText(error ?? "Unknown connection failure");
                 if (ui) {
                     ui.notify(`MCP: Failed to connect to ${name}: ${displayError}`, "error");
@@ -273,8 +282,8 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
     finally {
         saveMetadataCacheUpdates(state, startupCache);
     }
-    const connectedCount = results.filter(r => r.connection).length;
-    const failedCount = results.filter(r => r.error).length;
+    const connectedCount = results.filter((r) => r.connection).length;
+    const failedCount = results.filter((r) => r.error).length;
     if (ui && connectedCount > 0) {
         const totalTools = totalToolCount(state);
         const msg = failedCount > 0
@@ -285,14 +294,18 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
     const envDirect = process.env.MCP_DIRECT_TOOLS;
     if (envDirect !== "__none__") {
         const currentCache = loadMetadataCache(state.metadataCacheEnabled);
-        const envDirectToolOverride = envDirect?.split(",").map(selector => selector.trim()).filter(Boolean);
+        const envDirectToolOverride = envDirect
+            ?.split(",")
+            .map((selector) => selector.trim())
+            .filter(Boolean);
         const missingCacheServers = getMissingConfiguredDirectToolServers(config, currentCache, envDirectToolOverride);
         if (missingCacheServers.length > 0) {
-            const bootstrapResults = await parallelLimit(missingCacheServers.filter(name => !results.some(r => r.name === name && r.connection)), MAX_CONCURRENT_SERVER_CONNECTS, async (name) => {
+            const bootstrapResults = await parallelLimit(missingCacheServers.filter((name) => !results.some((r) => r.name === name && r.connection)), MAX_CONCURRENT_SERVER_CONNECTS, async (name) => {
                 try {
                     const definition = config.mcpServers[name];
-                    if (!definition)
+                    if (!definition) {
                         throw new Error(`MCP server "${name}" is not configured`);
+                    }
                     const connection = await manager.connect(name, definition, runtimeSignal);
                     if (connection.status === "needs-auth") {
                         return { name, ok: false };
@@ -306,8 +319,9 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
                 }
                 catch (error) {
                     if (isAbortError(error, runtimeSignal)) {
-                        if (owner.signal.aborted)
+                        if (owner.signal.aborted) {
                             throw error;
+                        }
                         return { name, ok: false };
                     }
                     const message = error instanceof Error ? error.message : String(error);
@@ -316,7 +330,7 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
                     return { name, ok: false };
                 }
             });
-            const bootstrapped = bootstrapResults.filter(r => r.ok).map(r => r.name);
+            const bootstrapped = bootstrapResults.filter((r) => r.ok).map((r) => r.name);
             owner.throwIfInactive();
             if (bootstrapped.length > 0 && ui) {
                 ui.notify(`MCP: tools discovered for ${bootstrapped.join(", ")}`, "info");
@@ -324,8 +338,9 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
         }
     }
     lifecycle.setReconnectCallback((serverName) => {
-        if (!owner.isActive())
+        if (!owner.isActive()) {
             return;
+        }
         updateServerMetadata(state, serverName);
         updateMetadataCache(state, serverName);
         notifyToolMetadataUpdated(state, serverName, "lifecycle-reconnect");
@@ -333,15 +348,17 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
         updateStatusBar(state);
     });
     lifecycle.setReconnectFailureCallback((serverName, error) => {
-        if (!owner.isActive())
+        if (!owner.isActive()) {
             return;
+        }
         const message = error instanceof Error ? error.message : String(error);
         recordFailure(state, serverName, message);
         updateStatusBar(state);
     });
     lifecycle.setIdleShutdownCallback((serverName) => {
-        if (!owner.isActive())
+        if (!owner.isActive()) {
             return;
+        }
         const idleMinutes = getEffectiveIdleTimeoutMinutes(state, serverName);
         logger.debug(`${serverName} shut down (idle ${idleMinutes}m)`);
         updateStatusBar(state);
@@ -356,19 +373,22 @@ export async function initializeMcp(pi, ctx, owner = createMcpRuntimeOwner(), op
 }
 export function markKeepAliveAfterConnect(state, serverName) {
     const definition = state.config.mcpServers[serverName];
-    if (!definition || isServerDisabled(definition))
+    if (!definition || isServerDisabled(definition)) {
         return;
+    }
     if ((definition.lifecycle ?? "lazy") === "lazy-keep-alive") {
         state.lifecycle.markKeepAlive(serverName, definition);
     }
 }
 export function updateServerMetadata(state, serverName) {
     const connection = state.manager.getConnection(serverName);
-    if (!connection || connection.status !== "connected")
+    if (!connection || connection.status !== "connected") {
         return;
+    }
     const definition = state.config.mcpServers[serverName];
-    if (!definition)
+    if (!definition) {
         return;
+    }
     if (isServerDisabled(definition)) {
         state.toolMetadata.delete(serverName);
         state.resourceCounts?.delete(serverName);
@@ -394,19 +414,24 @@ export function updateServerMetadata(state, serverName) {
 }
 function collectMetadataCacheUpdate(state, serverName, updates, options = {}) {
     const connection = state.manager.getConnection(serverName);
-    if (!connection || connection.status !== "connected")
+    if (!connection || connection.status !== "connected") {
         return;
+    }
     const definition = state.config.mcpServers[serverName];
-    if (!definition || isServerDisabled(definition))
+    if (!definition || isServerDisabled(definition)) {
         return;
+    }
     const configHash = computeServerHash(definition);
-    if (updates.existing === undefined)
+    if (updates.existing === undefined) {
         updates.existing = loadMetadataCache(state.metadataCacheEnabled);
+    }
     const existingEntry = updates.existing?.servers?.[serverName];
     const tools = serializeTools(connection.tools);
     let resources = definition.exposeResources === false ? [] : serializeResources(connection.resources);
     const prompts = connection.promptDiscoveryFailed
-        ? existingEntry?.configHash === configHash ? existingEntry.prompts : undefined
+        ? existingEntry?.configHash === configHash
+            ? existingEntry.prompts
+            : undefined
         : serializePrompts(connection.prompts ?? []);
     if (definition.exposeResources !== false &&
         resources.length === 0 &&
@@ -426,8 +451,9 @@ function collectMetadataCacheUpdate(state, serverName, updates, options = {}) {
     updates.entries.set(serverName, entry);
 }
 function saveMetadataCacheUpdates(state, updates) {
-    if (updates.entries.size === 0)
+    if (updates.entries.size === 0) {
         return;
+    }
     const servers = Object.fromEntries(updates.entries);
     updates.entries.clear();
     delete updates.existing;
@@ -469,8 +495,9 @@ export function flushMetadataCache(state) {
 export function updateStatusBar(state) {
     publishMcpStatusSnapshot(state);
     const ui = state.ui;
-    if (!ui)
+    if (!ui) {
         return;
+    }
     const entries = Object.entries(state.config.mcpServers);
     const disabledCount = entries.filter(([, definition]) => isServerDisabled(definition)).length;
     const enabledCount = entries.length - disabledCount;
@@ -480,7 +507,7 @@ export function updateStatusBar(state) {
     }
     const connectedCount = [...state.manager.getAllConnections()].filter(([name, connection]) => {
         const definition = state.config.mcpServers[name];
-        return connection.status === "connected" && definition !== undefined && !isServerDisabled(definition);
+        return (connection.status === "connected" && definition !== undefined && !isServerDisabled(definition));
     }).length;
     const footerStatus = state.config.settings?.mcpFooterStatus ?? "compact";
     if (footerStatus === "off") {
@@ -491,10 +518,12 @@ export function updateStatusBar(state) {
         ? `MCP ${connectedCount}/${enabledCount}`
         : `${enabledCount} ${enabledCount === 1 ? "server" : "servers"} enabled`;
     if (footerStatus === "full") {
-        if (connectedCount > 0)
+        if (connectedCount > 0) {
             status += ` (${connectedCount} connected)`;
-        if (disabledCount > 0)
+        }
+        if (disabledCount > 0) {
             status += ` (${disabledCount} disabled)`;
+        }
     }
     const formattedStatus = footerStatus === "compact" ? status : formatMcpStatus(state.config, status);
     if (formattedStatus === undefined) {
@@ -505,16 +534,19 @@ export function updateStatusBar(state) {
 }
 export function getFailureAgeSeconds(state, serverName) {
     const failedAt = state.failureTracker.get(serverName);
-    if (!failedAt)
+    if (!failedAt) {
         return null;
+    }
     const ageMs = Date.now() - failedAt;
-    if (ageMs > FAILURE_BACKOFF_MS)
+    if (ageMs > FAILURE_BACKOFF_MS) {
         return null;
+    }
     return Math.round(ageMs / 1000);
 }
 export function getFailureMessage(state, serverName) {
-    if (getFailureAgeSeconds(state, serverName) === null)
+    if (getFailureAgeSeconds(state, serverName) === null) {
         return null;
+    }
     return state.failureMessages?.get(serverName) ?? null;
 }
 export async function lazyConnect(state, serverName, signal) {
@@ -530,11 +562,13 @@ export async function lazyConnect(state, serverName, signal) {
         return true;
     }
     const failedAgo = getFailureAgeSeconds(state, serverName);
-    if (failedAgo !== null)
+    if (failedAgo !== null) {
         return false;
+    }
     const definition = state.config.mcpServers[serverName];
-    if (!definition || isServerDisabled(definition))
+    if (!definition || isServerDisabled(definition)) {
         return false;
+    }
     try {
         if (state.ui) {
             const status = formatMcpStatus(state.config, `connecting to ${serverName}...`);
@@ -566,12 +600,18 @@ export async function lazyConnect(state, serverName, signal) {
 function getEffectiveIdleTimeoutMinutes(state, serverName) {
     const definition = state.config.mcpServers[serverName];
     if (!definition) {
-        return typeof state.config.settings?.idleTimeout === "number" ? state.config.settings.idleTimeout : 10;
+        return typeof state.config.settings?.idleTimeout === "number"
+            ? state.config.settings.idleTimeout
+            : 10;
     }
-    if (typeof definition.idleTimeout === "number")
+    if (typeof definition.idleTimeout === "number") {
         return definition.idleTimeout;
+    }
     const mode = definition.lifecycle ?? "lazy";
-    if (mode === "eager" || mode === "lazy-keep-alive")
+    if (mode === "eager" || mode === "lazy-keep-alive") {
         return 0;
-    return typeof state.config.settings?.idleTimeout === "number" ? state.config.settings.idleTimeout : 10;
+    }
+    return typeof state.config.settings?.idleTimeout === "number"
+        ? state.config.settings.idleTimeout
+        : 10;
 }

package/dist/legacy-migration.d.ts

@@ -5,7 +5,7 @@ interface FileMigration {
     status: "absent" | "existing" | "would-copy" | "copied";
 }
 /** Run explicitly before starting v5. Never overwrite a destination or remove a source. */
-export declare function migrateLegacyState({ cwd, dryRun }?: {
+export declare function migrateLegacyState({ cwd, dryRun, }?: {
     cwd?: string;
     dryRun?: boolean;
 }): {

package/dist/legacy-migration.js

@@ -4,40 +4,45 @@ import { getAdapterPath, getAgentPath } from "./agent-dir.js";
 import { getProjectPiConfigPath, loadMcpConfig, resolveConfiguredOAuthDir } from "./config.js";
 import { migrateLegacyAuthEntry } from "./mcp-auth.js";
 /** Run explicitly before starting v5. Never overwrite a destination or remove a source. */
-export function migrateLegacyState({ cwd = process.cwd(), dryRun = false } = {}) {
-    const paths = ["mcp.json", "mcp-cache.json", "mcp-onboarding.json", "mcp-npx-cache.json"]
-        .map((name) => ({ source: getAgentPath(name), destination: getAdapterPath(name) }));
+export function migrateLegacyState({ cwd = process.cwd(), dryRun = false, } = {}) {
+    const paths = ["mcp.json", "mcp-cache.json", "mcp-onboarding.json", "mcp-npx-cache.json"].map((name) => ({ source: getAgentPath(name), destination: getAdapterPath(name) }));
     paths.push({ source: resolve(cwd, ".pi", "mcp.json"), destination: getProjectPiConfigPath(cwd) });
     const files = paths.map(({ source, destination }) => {
-        if (!existsSync(source))
+        if (!existsSync(source)) {
             return { source, destination, status: "absent" };
-        if (existsSync(destination))
+        }
+        if (existsSync(destination)) {
             return { source, destination, status: "existing" };
-        if (dryRun)
+        }
+        if (dryRun) {
             return { source, destination, status: "would-copy" };
+        }
         const contents = readFileSync(source);
         mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
         try {
             writeFileSync(destination, contents, { flag: "wx", mode: 0o600 });
         }
         catch (error) {
-            if (error.code === "EEXIST")
+            if (error.code === "EEXIST") {
                 return { source, destination, status: "existing" };
+            }
             throw error;
         }
-        if (!readFileSync(destination).equals(contents))
+        if (!readFileSync(destination).equals(contents)) {
             throw new Error(`Failed to verify migrated file: ${destination}`);
+        }
         return { source, destination, status: "copied" };
     });
     const credentials = [];
     if (!dryRun) {
         const config = loadMcpConfig(undefined, cwd);
-        const legacyDirectory = process.env.MCP_OAUTH_DIR?.trim()
-            || resolveConfiguredOAuthDir(config.settings?.oauthDir, cwd)
-            || getAgentPath("mcp-oauth");
+        const legacyDirectory = process.env.MCP_OAUTH_DIR?.trim() ||
+            resolveConfiguredOAuthDir(config.settings?.oauthDir, cwd) ||
+            getAgentPath("mcp-oauth");
         for (const [server, definition] of Object.entries(config.mcpServers)) {
-            if (typeof definition.url !== "string")
+            if (typeof definition.url !== "string") {
                 continue;
+            }
             credentials.push({ server, status: migrateLegacyAuthEntry(server, legacyDirectory) });
         }
     }

package/dist/lifecycle.d.ts

@@ -4,9 +4,9 @@ import { hasPendingAuth } from "./mcp-oauth-runtime.ts";
 export type ReconnectCallback = (serverName: string) => void;
 export type ReconnectFailureCallback = (serverName: string, error: unknown) => void;
 export declare class McpLifecycleManager {
-    private keepAliveServers;
-    private allServers;
-    private serverSettings;
+    private readonly keepAliveServers;
+    private readonly allServers;
+    private readonly serverSettings;
     private globalIdleTimeout;
     private healthCheckInterval;
     private onReconnect;

package/dist/lifecycle.js

@@ -29,16 +29,19 @@ export class McpLifecycleManager {
         this.onReconnectFailure = callback;
     }
     markKeepAlive(name, definition) {
-        if (isServerDisabled(definition))
+        if (isServerDisabled(definition)) {
             return;
+        }
         this.keepAliveServers.set(name, definition);
     }
     registerServer(name, definition, settings) {
-        if (isServerDisabled(definition))
+        if (isServerDisabled(definition)) {
             return;
+        }
         this.allServers.set(name, definition);
-        if (settings?.idleTimeout !== undefined)
+        if (settings?.idleTimeout !== undefined) {
             this.serverSettings.set(name, settings);
+        }
     }
     setGlobalIdleTimeout(minutes) {
         this.globalIdleTimeout = minutes * 60 * 1000;
@@ -49,8 +52,9 @@ export class McpLifecycleManager {
     startHealthChecks(signalOrInterval, maybeIntervalMs = 30000) {
         const signal = typeof signalOrInterval === "number" ? undefined : signalOrInterval;
         const intervalMs = typeof signalOrInterval === "number" ? signalOrInterval : maybeIntervalMs;
-        if (this.healthCheckInterval)
+        if (this.healthCheckInterval) {
             clearInterval(this.healthCheckInterval);
+        }
         this.removeHealthAbortListener?.();
         this.stopped = false;
         this.healthSignal = signal;
@@ -61,33 +65,38 @@ export class McpLifecycleManager {
         }
         const stop = () => {
             this.stopped = true;
-            if (this.healthCheckInterval)
+            if (this.healthCheckInterval) {
                 clearInterval(this.healthCheckInterval);
+            }
             this.healthCheckInterval = undefined;
         };
         signal?.addEventListener("abort", stop, { once: true });
         this.removeHealthAbortListener = () => signal?.removeEventListener("abort", stop);
         this.healthCheckInterval = setInterval(() => {
-            if (this.stopped || signal?.aborted || this.activeHealthCheck)
+            if (this.stopped || signal?.aborted || this.activeHealthCheck) {
                 return;
+            }
             const check = this.checkConnections(signal)
-                .catch(error => {
+                .catch((error) => {
                 console.error(`MCP: Health check failed: ${formatTerminalError(error)}`);
             })
                 .finally(() => {
-                if (this.activeHealthCheck === check)
+                if (this.activeHealthCheck === check) {
                     this.activeHealthCheck = undefined;
+                }
             });
             this.activeHealthCheck = check;
         }, intervalMs);
         this.healthCheckInterval.unref();
     }
     async checkConnections(signal) {
-        if (this.stopped || signal?.aborted)
+        if (this.stopped || signal?.aborted) {
             return;
+        }
         for (const [name, definition] of this.keepAliveServers) {
-            if (isServerDisabled(definition))
+            if (isServerDisabled(definition)) {
                 continue;
+            }
             const connection = this.manager.getConnection(name);
             if (!connection || connection.status !== "connected") {
                 if (this.hasPendingAuthForServer(name)) {
@@ -96,14 +105,16 @@ export class McpLifecycleManager {
                 }
                 try {
                     await this.manager.connect(name, definition, signal);
-                    if (this.stopped || signal?.aborted)
+                    if (this.stopped || signal?.aborted) {
                         return;
+                    }
                     logger.debug(`Reconnected to ${name}`);
                     this.onReconnect?.(name);
                 }
                 catch (error) {
-                    if (this.stopped || signal?.aborted)
+                    if (this.stopped || signal?.aborted) {
                         return;
+                    }
                     this.onReconnectFailure?.(name, error);
                     const message = error instanceof Error ? error.message : String(error);
                     console.error(`MCP: Failed to reconnect to ${name}: ${sanitizeTerminalText(message)}`);
@@ -111,33 +122,38 @@ export class McpLifecycleManager {
             }
         }
         for (const [name] of this.allServers) {
-            if (this.keepAliveServers.has(name))
+            if (this.keepAliveServers.has(name)) {
                 continue;
+            }
             const timeout = this.getIdleTimeout(name);
             if (timeout > 0 && this.manager.isIdle(name, timeout)) {
                 await this.manager.close(name);
-                if (this.stopped || signal?.aborted)
+                if (this.stopped || signal?.aborted) {
                     return;
+                }
                 this.onIdleShutdown?.(name);
             }
         }
     }
     getIdleTimeout(name) {
         const perServer = this.serverSettings.get(name)?.idleTimeout;
-        if (perServer !== undefined)
+        if (perServer !== undefined) {
             return perServer * 60 * 1000;
+        }
         return this.globalIdleTimeout;
     }
     async gracefulShutdown() {
-        if (this.shutdownPromise)
+        if (this.shutdownPromise) {
             return this.shutdownPromise;
+        }
         this.shutdownPromise = this.shutdownOnce();
         return this.shutdownPromise;
     }
     async shutdownOnce() {
         this.stopped = true;
-        if (this.healthCheckInterval)
+        if (this.healthCheckInterval) {
             clearInterval(this.healthCheckInterval);
+        }
         this.healthCheckInterval = undefined;
         this.removeHealthAbortListener?.();
         this.removeHealthAbortListener = undefined;

package/dist/logger.d.ts

@@ -25,8 +25,8 @@ declare class Logger {
     child(context: LogContext): ChildLogger;
 }
 declare class ChildLogger {
-    private parent;
-    private context;
+    private readonly parent;
+    private readonly context;
     constructor(parent: Logger, context: LogContext);
     debug(message: string, context?: LogContext): void;
     info(message: string, context?: LogContext): void;

package/dist/logger.js

@@ -23,8 +23,9 @@ class Logger {
         return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[this.minLevel];
     }
     emit(level, message, context, error) {
-        if (!this.shouldLog(level))
+        if (!this.shouldLog(level)) {
             return;
+        }
         const prefix = LEVEL_PREFIX[level];
         const contextStr = formatContext(context);
         const fullMessage = contextStr ? `${prefix} ${message} ${contextStr}` : `${prefix} ${message}`;
@@ -84,8 +85,9 @@ class ChildLogger {
     }
 }
 function formatContext(context) {
-    if (!context || Object.keys(context).length === 0)
+    if (!context || Object.keys(context).length === 0) {
         return "";
+    }
     const parts = [];
     for (const [key, value] of Object.entries(context)) {
         if (value !== undefined && value !== null) {