@within-7/minto 0.3.10 → 0.4.0

package/dist/services/mcpClient.js

@@ -1,4 +1,5 @@
 import { zipObject } from "lodash-es";
+import { debug as debugLogger } from "../utils/debugLogger.js";
 import {
   getCurrentProjectConfig,
   saveCurrentProjectConfig,
@@ -20,13 +21,31 @@ import {
   ListPromptsResultSchema,
   ListToolsResultSchema,
   ListResourcesResultSchema,
-  ReadResourceResultSchema
+  ReadResourceResultSchema,
+  ToolListChangedNotificationSchema
 } from "@modelcontextprotocol/sdk/types.js";
 import { memoize, pickBy } from "lodash-es";
 import { MCPTool } from "../tools/MCPTool/MCPTool.js";
 import { logMCPError } from "../utils/log.js";
+import { ensureProxyBypass } from "../utils/envConfig.js";
 import { PRODUCT_COMMAND } from "../constants/product.js";
 import { CircuitBreakerRegistry, CircuitOpenError } from "../utils/CircuitBreaker.js";
+import { emitReminderEvent } from "./systemReminder.js";
+const SENSITIVE_ENV_PREFIXES = [
+  "ANTHROPIC_",
+  "OPENAI_",
+  "AWS_SECRET",
+  "GITHUB_TOKEN",
+  "GH_TOKEN",
+  "MINTO_API"
+];
+function filterSensitiveEnv(env) {
+  return Object.fromEntries(
+    Object.entries(env).filter(
+      ([k]) => !SENSITIVE_ENV_PREFIXES.some((p) => k.startsWith(p) || k === p)
+    ).filter((e) => e[1] !== void 0)
+  );
+}
 const mcpCircuitBreakers = new CircuitBreakerRegistry({
   failureThreshold: 5,
   successThreshold: 2,
@@ -74,7 +93,11 @@ function addMcpServer(name, server, scope = "project") {
           if (existingConfig && typeof existingConfig === "object") {
             mcprcConfig = existingConfig;
           }
-        } catch {
+        } catch (e) {
+          debugLogger.warn(
+            "MCP_CONFIG",
+            `Failed to read/parse .mcprc: ${e instanceof Error ? e.message : String(e)}`
+          );
         }
       }
       mcprcConfig[name] = server;
@@ -168,16 +191,30 @@ function getMcpServer(name) {
   return void 0;
 }
 async function connectToServer(name, serverRef) {
-  const transport = serverRef.type === "sse" ? new SSEClientTransport(new URL(serverRef.url)) : new StdioClientTransport({
-    command: serverRef.command,
-    args: serverRef.args,
-    env: {
-      ...process.env,
-      ...serverRef.env
-    },
-    stderr: "pipe"
-    // prevents error output from the MCP server from printing to the UI
-  });
+  let transport;
+  if (serverRef.type === "http") {
+    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    transport = new StreamableHTTPClientTransport(
+      new URL(serverRef.url),
+      {
+        // Pass headers but never log sensitive values
+        requestInit: serverRef.headers ? { headers: serverRef.headers } : void 0
+      }
+    );
+  } else if (serverRef.type === "sse") {
+    transport = new SSEClientTransport(new URL(serverRef.url));
+  } else {
+    transport = new StdioClientTransport({
+      command: serverRef.command,
+      args: serverRef.args,
+      env: ensureProxyBypass({
+        ...filterSensitiveEnv(process.env),
+        ...serverRef.env
+      }),
+      stderr: "pipe"
+      // prevents error output from the MCP server from printing to the UI
+    });
+  }
   const client = new Client(
     {
       name: PRODUCT_COMMAND,
@@ -187,16 +224,16 @@ async function connectToServer(name, serverRef) {
       capabilities: {}
     }
   );
-  const CONNECTION_TIMEOUT_MS = 5e3;
+  const connectionTimeout = poolConfig.connectionTimeout;
   const connectPromise = client.connect(transport);
   const timeoutPromise = new Promise((_, reject) => {
     const timeoutId = setTimeout(() => {
       reject(
         new Error(
-          `Connection to MCP server "${name}" timed out after ${CONNECTION_TIMEOUT_MS}ms`
+          `Connection to MCP server "${name}" timed out after ${connectionTimeout}ms`
         )
       );
-    }, CONNECTION_TIMEOUT_MS);
+    }, connectionTimeout);
     connectPromise.then(
       () => clearTimeout(timeoutId),
       () => clearTimeout(timeoutId)
@@ -212,6 +249,11 @@ async function connectToServer(name, serverRef) {
       }
     });
   }
+  client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+    if (typeof getMCPTools.cache?.clear === "function") {
+      getMCPTools.cache.clear();
+    }
+  });
   return client;
 }
 function getMcprcServerStatus(serverName) {
@@ -227,10 +269,11 @@ function getMcprcServerStatus(serverName) {
 let connectedClients = [];
 const DEFAULT_POOL_CONFIG = {
   maxConnections: 10,
-  connectionTimeout: 5e3,
+  connectionTimeout: Number(process.env.MCP_TIMEOUT) || 1e4,
   healthCheckInterval: 3e4,
   retryFailed: true,
-  maxRetries: 3
+  maxRetries: 2,
+  maxOutputChars: Number(process.env.MAX_MCP_OUTPUT_CHARS) || 25e3
 };
 let poolConfig = { ...DEFAULT_POOL_CONFIG };
 let healthCheckTimer = null;
@@ -325,7 +368,11 @@ function startHealthCheck() {
   healthCheckTimer = setInterval(async () => {
     try {
       await runHealthCheck();
-    } catch {
+    } catch (e) {
+      debugLogger.warn(
+        "MCP_HEALTH",
+        `Health check failed: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
   }, poolConfig.healthCheckInterval);
 }
@@ -345,6 +392,27 @@ function getPoolStats() {
     unhealthyCount: health.filter((h) => h.status === "unhealthy").length
   };
 }
+async function connectWithRetry(name, serverRef) {
+  const { retryFailed, maxRetries } = poolConfig;
+  let lastError;
+  const attempts = retryFailed ? maxRetries : 0;
+  for (let attempt = 0; attempt <= attempts; attempt++) {
+    try {
+      return await connectToServer(name, serverRef);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < attempts && retryFailed) {
+        const delay = 1e3 * Math.pow(2, attempt);
+        logMCPError(
+          name,
+          `Connection attempt ${attempt + 1} failed, retrying in ${delay}ms...`
+        );
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastError;
+}
 const getClients = memoize(async () => {
   if (process.env.CI && process.env.NODE_ENV !== "test") {
     return [];
@@ -371,7 +439,10 @@ const getClients = memoize(async () => {
   const clients = await Promise.all(
     Object.entries(enabledServers).map(async ([name, serverRef]) => {
       try {
-        const client = await connectToServer(name, serverRef);
+        const client = await connectWithRetry(
+          name,
+          serverRef
+        );
         return { name, client, type: "connected" };
       } catch (error) {
         logMCPError(
@@ -416,6 +487,28 @@ async function requestAll(req, resultSchema, requiredCapability) {
     (result) => result !== null
   );
 }
+function isLazyMCPEnabled() {
+  return !!(process.env.MINTO_ENABLE_TOOL_SEARCH || process.env.ENABLE_TOOL_SEARCH);
+}
+const lazySchemaCache = /* @__PURE__ */ new Map();
+async function getLazyInputSchema(client, toolName, fullName) {
+  if (lazySchemaCache.has(fullName)) {
+    return lazySchemaCache.get(fullName);
+  }
+  try {
+    const result = await client.client.request(
+      { method: "tools/list" },
+      ListToolsResultSchema
+    );
+    for (const tool of result.tools) {
+      const key = "mcp__" + client.name + "__" + tool.name;
+      lazySchemaCache.set(key, tool.inputSchema);
+    }
+    return lazySchemaCache.get(fullName);
+  } catch {
+    return void 0;
+  }
+}
 const getMCPTools = memoize(async () => {
   const toolsList = await requestAll(
     {
@@ -424,6 +517,7 @@ const getMCPTools = memoize(async () => {
     ListToolsResultSchema,
     "tools"
   );
+  const lazyMode = isLazyMCPEnabled();
   return toolsList.flatMap(({ client, result: { tools } }) => {
     const validTools = tools.filter(
       (tool) => {
@@ -437,21 +531,32 @@ const getMCPTools = memoize(async () => {
         return true;
       }
     );
-    return validTools.map(
-      (tool) => ({
+    return validTools.map((tool) => {
+      const fullName = "mcp__" + client.name + "__" + tool.name;
+      if (lazyMode) {
+        lazySchemaCache.set(
+          fullName,
+          tool.inputSchema
+        );
+      }
+      return {
         ...MCPTool,
-        name: "mcp__" + client.name + "__" + tool.name,
+        name: fullName,
         async description() {
           return tool.description ?? "";
         },
         async prompt() {
           return tool.description ?? "";
         },
-        inputJSONSchema: tool.inputSchema,
+        // In lazy mode, schema starts as undefined and is loaded on-demand
+        inputJSONSchema: lazyMode ? void 0 : tool.inputSchema,
         async validateInput(input, context) {
           return { result: true };
         },
         async *call(args, context) {
+          if (lazyMode && !lazySchemaCache.has(fullName)) {
+            await getLazyInputSchema(client, tool.name, fullName);
+          }
           const data = await callMCPTool({ client, tool: tool.name, args });
           yield {
             type: "result",
@@ -462,8 +567,8 @@ const getMCPTools = memoize(async () => {
         userFacingName() {
           return `${client.name}:${tool.name} (MCP)`;
         }
-      })
-    );
+      };
+    });
   });
 });
 async function withTimeout(promise, timeoutMs, operationName) {
@@ -497,6 +602,13 @@ function isTimeoutError(error) {
 }
 const MCP_TOOL_TIMEOUT_MS = 12e4;
 const MCP_TOOL_MAX_RETRIES = 2;
+function truncateMcpOutput(text) {
+  const limit = poolConfig.maxOutputChars;
+  if (text.length <= limit) return text;
+  return text.slice(0, limit) + `
+
+[Output truncated: ${text.length} chars exceeded limit of ${limit}]`;
+}
 async function callMCPTool({
   client: { client, name },
   tool,
@@ -527,7 +639,8 @@ async function callMCPTool({
         throw Error(errorMessage);
       }
       if ("toolResult" in result) {
-        return String(result.toolResult);
+        const text = String(result.toolResult);
+        return truncateMcpOutput(text);
       }
       if ("content" in result && Array.isArray(result.content)) {
         return result.content.map((item) => {
@@ -618,6 +731,9 @@ async function runCommand({ name, client }, args) {
           message.content.type === "text" ? {
             type: "text",
             text: message.content.text
+          } : message.content.type === "resource" ? {
+            type: "text",
+            text: typeof message.content.resource?.text === "string" ? message.content.resource.text : `[MCP Resource: ${message.content.resource?.uri ?? "unknown"}]`
           } : {
             type: "image",
             source: {
@@ -637,6 +753,26 @@ async function runCommand({ name, client }, args) {
     throw error;
   }
 }
+function closeClientsInBackground(clients) {
+  const CLOSE_TIMEOUT_MS = 5e3;
+  const closePromises = clients.map(async (wrappedClient) => {
+    if (wrappedClient.type === "connected") {
+      try {
+        await wrappedClient.client.close();
+      } catch (e) {
+        debugLogger.warn(
+          "MCP_CLOSE",
+          `Failed to close MCP client: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+  });
+  Promise.race([
+    Promise.allSettled(closePromises),
+    new Promise((resolve) => setTimeout(resolve, CLOSE_TIMEOUT_MS))
+  ]).catch(() => {
+  });
+}
 async function refreshMCPConnections() {
   if (pendingRefresh) {
     return;
@@ -644,6 +780,8 @@ async function refreshMCPConnections() {
   pendingRefresh = true;
   const release = await acquireConnectionLock();
   try {
+    const oldClients = connectedClients;
+    connectedClients = [];
     if (typeof getClients.cache?.clear === "function") {
       getClients.cache.clear();
     }
@@ -659,16 +797,20 @@ async function refreshMCPConnections() {
       invalidateToolsCache();
     } catch {
     }
+    if (oldClients.length > 0) {
+      closeClientsInBackground(oldClients);
+    }
   } finally {
     pendingRefresh = false;
     release();
   }
 }
 async function shutdownMCPClients() {
-  if (connectedClients.length === 0) {
-    return;
-  }
-  const closePromises = connectedClients.map(async (wrappedClient) => {
+  if (connectedClients.length === 0) return;
+  const oldClients = connectedClients;
+  connectedClients = [];
+  const SHUTDOWN_TIMEOUT_MS = 3e3;
+  const closePromises = oldClients.map(async (wrappedClient) => {
     if (wrappedClient.type === "connected") {
       try {
         await wrappedClient.client.close();
@@ -676,7 +818,6 @@ async function shutdownMCPClients() {
       }
     }
   });
-  const SHUTDOWN_TIMEOUT_MS = 3e3;
   try {
     await Promise.race([
       Promise.allSettled(closePromises),
@@ -684,8 +825,15 @@ async function shutdownMCPClients() {
     ]);
   } catch {
   }
-  connectedClients = [];
-  await refreshMCPConnections();
+  if (typeof getClients.cache?.clear === "function") {
+    getClients.cache.clear();
+  }
+  if (typeof getMCPTools.cache?.clear === "function") {
+    getMCPTools.cache.clear();
+  }
+  if (typeof getMCPCommands.cache?.clear === "function") {
+    getMCPCommands.cache.clear();
+  }
 }
 async function listMCPResources(serverFilter) {
   const results = await requestAll(
@@ -731,6 +879,8 @@ async function readMCPResource(uri, serverName) {
           text: "text" in content ? String(content.text) : void 0,
           blob: "blob" in content ? String(content.blob) : void 0
         };
+      } else {
+        emitReminderEvent("mcp:resource_no_content", { resourceUri: uri });
       }
     } catch (error) {
       logMCPError(