@yawlabs/mcp-connect 0.1.3 → 0.2.1

package/dist/index.js

@@ -10,12 +10,12 @@ function log(level, msg, data) {
 }
 
 // src/config.ts
-async function fetchConfig(apiUrl2, token2) {
-  const url = apiUrl2.replace(/\/$/, "") + "/api/connect/config";
+async function fetchConfig(apiUrl3, token3) {
+  const url = apiUrl3.replace(/\/$/, "") + "/api/connect/config";
   const res = await request(url, {
     method: "GET",
     headers: {
-      Authorization: "Bearer " + token2,
+      Authorization: "Bearer " + token3,
       Accept: "application/json"
     },
     headersTimeout: 1e4,
@@ -48,9 +48,81 @@ var ConfigError = class extends Error {
 };
 
 // src/server.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { resolve } from "path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { request as request3 } from "undici";
+
+// src/analytics.ts
+import { request as request2 } from "undici";
+var FLUSH_INTERVAL = 3e4;
+var FLUSH_SIZE = 50;
+var MAX_BUFFER = 5e3;
+var buffer = [];
+var flushTimer = null;
+var apiUrl = "";
+var token = "";
+function recordConnectEvent(event) {
+  if (buffer.length >= MAX_BUFFER) return;
+  buffer.push({ ...event, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  if (buffer.length >= FLUSH_SIZE) {
+    flush();
+  }
+}
+async function flush() {
+  if (buffer.length === 0 || !apiUrl || !token) return;
+  const events = buffer.splice(0, FLUSH_SIZE);
+  try {
+    const res = await request2(apiUrl.replace(/\/$/, "") + "/api/connect/analytics", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer " + token,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ events }),
+      headersTimeout: 1e4,
+      bodyTimeout: 1e4
+    });
+    if (res.statusCode >= 400) {
+      const room = MAX_BUFFER - buffer.length;
+      if (room > 0) buffer.unshift(...events.slice(0, room));
+      log("warn", "Analytics flush failed", { status: res.statusCode });
+    }
+    await res.body.text().catch(() => {
+    });
+  } catch (err) {
+    const room = MAX_BUFFER - buffer.length;
+    if (room > 0) buffer.unshift(...events.slice(0, room));
+    log("warn", "Analytics flush error", { error: err.message });
+  }
+}
+function initAnalytics(url, tok) {
+  apiUrl = url;
+  token = tok;
+  flushTimer = setInterval(() => flush().catch(() => {
+  }), FLUSH_INTERVAL);
+  if (flushTimer.unref) flushTimer.unref();
+}
+async function shutdownAnalytics() {
+  if (flushTimer) {
+    clearInterval(flushTimer);
+    flushTimer = null;
+  }
+  for (let i = 0; i < 3 && buffer.length > 0; i++) {
+    await flush();
+  }
+  buffer.length = 0;
+}
 
 // src/meta-tools.ts
 var META_TOOLS = {
@@ -59,7 +131,12 @@ var META_TOOLS = {
     description: "List all available MCP servers. Call this FIRST before activating anything. Only activate servers you need for the CURRENT task \u2014 each one adds tools to your context. Shows server names, namespaces, tool counts, and activation status.",
     inputSchema: {
       type: "object",
-      properties: {}
+      properties: {
+        context: {
+          type: "string",
+          description: "Optional: describe the current task or conversation context. Servers will be sorted by relevance to help you pick the right one."
+        }
+      }
     },
     annotations: {
       title: "Discover MCP Servers",
@@ -110,12 +187,50 @@ var META_TOOLS = {
       idempotentHint: true,
       openWorldHint: false
     }
+  },
+  import_config: {
+    name: "mcp_connect_import",
+    description: "Import MCP servers from an existing config file (Claude Desktop, Cursor, VS Code, etc.). Reads the file, parses the mcpServers section, and creates connect server entries in the cloud. Supported files: claude_desktop_config.json, mcp.json, settings.json.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filepath: {
+          type: "string",
+          description: 'Path to the MCP config file (e.g., "~/.claude/claude_desktop_config.json", ".cursor/mcp.json")'
+        }
+      },
+      required: ["filepath"]
+    },
+    annotations: {
+      title: "Import MCP Config",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: true
+    }
+  },
+  health: {
+    name: "mcp_connect_health",
+    description: "Show health stats for all active MCP server connections: total calls, error count, average latency, and last error.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    annotations: {
+      title: "Connection Health",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    }
   }
 };
 var META_TOOL_NAMES = /* @__PURE__ */ new Set([
   META_TOOLS.discover.name,
   META_TOOLS.activate.name,
-  META_TOOLS.deactivate.name
+  META_TOOLS.deactivate.name,
+  META_TOOLS.import_config.name,
+  META_TOOLS.health.name
 ]);
 
 // src/proxy.ts
@@ -153,6 +268,89 @@ function buildToolRoutes(activeConnections) {
   }
   return routes;
 }
+function buildResourceList(activeConnections) {
+  const resources = [];
+  for (const conn of activeConnections.values()) {
+    for (const r of conn.resources) {
+      resources.push({
+        uri: r.namespacedUri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType
+      });
+    }
+  }
+  return resources;
+}
+function buildResourceRoutes(activeConnections) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const conn of activeConnections.values()) {
+    for (const r of conn.resources) {
+      routes.set(r.namespacedUri, { namespace: conn.config.namespace, originalUri: r.uri });
+    }
+  }
+  return routes;
+}
+function buildPromptList(activeConnections) {
+  const prompts = [];
+  for (const conn of activeConnections.values()) {
+    for (const p of conn.prompts) {
+      prompts.push({
+        name: p.namespacedName,
+        description: p.description,
+        arguments: p.arguments
+      });
+    }
+  }
+  return prompts;
+}
+function buildPromptRoutes(activeConnections) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const conn of activeConnections.values()) {
+    for (const p of conn.prompts) {
+      routes.set(p.namespacedName, { namespace: conn.config.namespace, originalName: p.name });
+    }
+  }
+  return routes;
+}
+async function routeResourceRead(uri, resourceRoutes, activeConnections) {
+  const route = resourceRoutes.get(uri);
+  if (!route) {
+    return { contents: [{ uri, text: "Unknown resource: " + uri }] };
+  }
+  const connection = activeConnections.get(route.namespace);
+  if (!connection || connection.status !== "connected") {
+    return { contents: [{ uri, text: 'Server "' + route.namespace + '" is not connected.' }] };
+  }
+  try {
+    const result = await connection.client.readResource({ uri: route.originalUri });
+    return result;
+  } catch (err) {
+    log("error", "Resource read failed", { uri, namespace: route.namespace, error: err.message });
+    return { contents: [{ uri, text: "Error: " + err.message }] };
+  }
+}
+async function routePromptGet(name, args, promptRoutes, activeConnections) {
+  const route = promptRoutes.get(name);
+  if (!route) {
+    return { messages: [{ role: "user", content: { type: "text", text: "Unknown prompt: " + name } }] };
+  }
+  const connection = activeConnections.get(route.namespace);
+  if (!connection || connection.status !== "connected") {
+    return {
+      messages: [
+        { role: "user", content: { type: "text", text: 'Server "' + route.namespace + '" is not connected.' } }
+      ]
+    };
+  }
+  try {
+    const result = await connection.client.getPrompt({ name: route.originalName, arguments: args });
+    return result;
+  } catch (err) {
+    log("error", "Prompt get failed", { name, namespace: route.namespace, error: err.message });
+    return { messages: [{ role: "user", content: { type: "text", text: "Error: " + err.message } }] };
+  }
+}
 async function routeToolCall(toolName, args, toolRoutes, activeConnections) {
   const route = toolRoutes.get(toolName);
   if (!route) {
@@ -193,12 +391,31 @@ async function routeToolCall(toolName, args, toolRoutes, activeConnections) {
   }
 }
 
+// src/relevance.ts
+function scoreRelevance(context, server2, tools) {
+  const contextLower = context.toLowerCase();
+  const words = contextLower.split(/\s+/).filter((w) => w.length > 2).map((w) => w.replace(/[^a-z0-9]/g, "")).filter(Boolean);
+  if (words.length === 0) return 0;
+  let score = 0;
+  const nameLower = server2.name.toLowerCase();
+  const nsLower = server2.namespace.toLowerCase();
+  for (const word of words) {
+    if (nameLower.includes(word)) score += 3;
+    if (nsLower.includes(word)) score += 2;
+    for (const tool of tools) {
+      if (tool.name.toLowerCase().includes(word)) score += 2;
+      if (tool.description?.toLowerCase().includes(word)) score += 1;
+    }
+  }
+  return score;
+}
+
 // src/upstream.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 var CONNECT_TIMEOUT = 15e3;
-async function connectToUpstream(config) {
+async function connectToUpstream(config, onDisconnect) {
   const client = new Client({ name: "mcp-connect", version: "0.1.0" }, { capabilities: {} });
   let transport;
   if (config.type === "local") {
@@ -217,20 +434,45 @@ async function connectToUpstream(config) {
     }
     transport = new StreamableHTTPClientTransport(new URL(config.url));
   }
-  const connectPromise = client.connect(transport);
-  const timeoutPromise = new Promise(
-    (_, reject) => setTimeout(() => reject(new Error("Connection timeout after " + CONNECT_TIMEOUT + "ms")), CONNECT_TIMEOUT)
-  );
-  await Promise.race([connectPromise, timeoutPromise]);
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("Connection timeout after " + CONNECT_TIMEOUT + "ms")), CONNECT_TIMEOUT);
+  });
+  try {
+    await Promise.race([client.connect(transport), timeoutPromise]);
+    clearTimeout(timer);
+  } catch (err) {
+    clearTimeout(timer);
+    try {
+      await client.close();
+    } catch {
+    }
+    throw err;
+  }
   log("info", "Connected to upstream", { name: config.name, namespace: config.namespace, type: config.type });
+  const connection = {};
+  client.onclose = () => {
+    if (connection.status === "connected") {
+      connection.status = "error";
+      connection.error = "Upstream disconnected unexpectedly";
+      log("warn", "Upstream disconnected unexpectedly", { namespace: config.namespace });
+      if (onDisconnect) onDisconnect(config.namespace);
+    }
+  };
   const tools = await fetchToolsFromUpstream(client, config.namespace);
-  return {
+  const resources = await fetchResourcesFromUpstream(client, config.namespace);
+  const prompts = await fetchPromptsFromUpstream(client, config.namespace);
+  Object.assign(connection, {
     config,
     client,
     transport,
     tools,
+    resources,
+    prompts,
+    health: { totalCalls: 0, errorCount: 0, totalLatencyMs: 0 },
     status: "connected"
-  };
+  });
+  return connection;
 }
 async function disconnectFromUpstream(connection) {
   try {
@@ -244,6 +486,33 @@ async function disconnectFromUpstream(connection) {
   connection.status = "disconnected";
   log("info", "Disconnected from upstream", { namespace: connection.config.namespace });
 }
+async function fetchResourcesFromUpstream(client, namespace) {
+  try {
+    const result = await client.listResources();
+    return (result.resources ?? []).map((r) => ({
+      uri: r.uri,
+      namespacedUri: "connect://" + namespace + "/" + r.uri,
+      name: r.name,
+      description: r.description,
+      mimeType: r.mimeType
+    }));
+  } catch {
+    return [];
+  }
+}
+async function fetchPromptsFromUpstream(client, namespace) {
+  try {
+    const result = await client.listPrompts();
+    return (result.prompts ?? []).map((p) => ({
+      name: p.name,
+      namespacedName: namespace + "_" + p.name,
+      description: p.description,
+      arguments: p.arguments
+    }));
+  } catch {
+    return [];
+  }
+}
 async function fetchToolsFromUpstream(client, namespace) {
   const result = await client.listTools();
   return (result.tools ?? []).map((tool) => ({
@@ -258,12 +527,18 @@ async function fetchToolsFromUpstream(client, namespace) {
 // src/server.ts
 var POLL_INTERVAL = 6e4;
 var ConnectServer = class _ConnectServer {
-  constructor(apiUrl2, token2) {
-    this.apiUrl = apiUrl2;
-    this.token = token2;
+  constructor(apiUrl3, token3) {
+    this.apiUrl = apiUrl3;
+    this.token = token3;
     this.server = new Server(
-      { name: "mcp-connect", version: "0.1.0" },
-      { capabilities: { tools: { listChanged: true } } }
+      { name: "mcp-connect", version: "0.2.0" },
+      {
+        capabilities: {
+          tools: { listChanged: true },
+          resources: { listChanged: true },
+          prompts: { listChanged: true }
+        }
+      }
     );
     this.setupHandlers();
   }
@@ -275,16 +550,50 @@ var ConnectServer = class _ConnectServer {
   configVersion = null;
   pollTimer = null;
   toolRoutes = /* @__PURE__ */ new Map();
+  resourceRoutes = /* @__PURE__ */ new Map();
+  promptRoutes = /* @__PURE__ */ new Map();
   idleCallCounts = /* @__PURE__ */ new Map();
   static IDLE_CALL_THRESHOLD = 10;
   setupHandlers() {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
       tools: buildToolList(this.connections)
     }));
-    this.server.setRequestHandler(CallToolRequestSchema, async (request2) => {
-      const { name, arguments: args } = request2.params;
+    this.server.setRequestHandler(CallToolRequestSchema, async (request4) => {
+      const { name, arguments: args } = request4.params;
       return this.handleToolCall(name, args ?? {});
     });
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: buildResourceList(this.connections)
+    }));
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request4) => {
+      return routeResourceRead(request4.params.uri, this.resourceRoutes, this.connections);
+    });
+    this.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+      prompts: buildPromptList(this.connections)
+    }));
+    this.server.setRequestHandler(GetPromptRequestSchema, async (request4) => {
+      return routePromptGet(
+        request4.params.name,
+        request4.params.arguments,
+        this.promptRoutes,
+        this.connections
+      );
+    });
+  }
+  handleUpstreamDisconnect(namespace) {
+    log("warn", "Upstream disconnect detected, will auto-reconnect on next use", { namespace });
+  }
+  rebuildRoutes() {
+    this.toolRoutes = buildToolRoutes(this.connections);
+    this.resourceRoutes = buildResourceRoutes(this.connections);
+    this.promptRoutes = buildPromptRoutes(this.connections);
+  }
+  async notifyAllListsChanged() {
+    await this.server.sendToolListChanged();
+    await this.server.sendResourceListChanged().catch(() => {
+    });
+    await this.server.sendPromptListChanged().catch(() => {
+    });
   }
   async start() {
     try {
@@ -296,6 +605,7 @@ var ConnectServer = class _ConnectServer {
       log("warn", "Initial config fetch failed, starting with empty config", { error: err.message });
       this.config = { servers: [], configVersion: "" };
     }
+    initAnalytics(this.apiUrl, this.token);
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
     this.startPolling();
@@ -306,22 +616,92 @@ var ConnectServer = class _ConnectServer {
   }
   async handleToolCall(name, args) {
     if (name === META_TOOLS.discover.name) {
-      return this.handleDiscover();
+      recordConnectEvent({ namespace: null, toolName: null, action: "discover", latencyMs: null, success: true });
+      return this.handleDiscover(args.context);
     }
     if (name === META_TOOLS.activate.name) {
-      return this.handleActivate(args.server);
+      const result2 = await this.handleActivate(args.server);
+      recordConnectEvent({
+        namespace: args.server || null,
+        toolName: null,
+        action: "activate",
+        latencyMs: null,
+        success: !result2.isError
+      });
+      return result2;
     }
     if (name === META_TOOLS.deactivate.name) {
-      return this.handleDeactivate(args.server);
+      const result2 = await this.handleDeactivate(args.server);
+      recordConnectEvent({
+        namespace: args.server || null,
+        toolName: null,
+        action: "deactivate",
+        latencyMs: null,
+        success: !result2.isError
+      });
+      return result2;
+    }
+    if (name === META_TOOLS.import_config.name) {
+      return this.handleImport(args.filepath);
+    }
+    if (name === META_TOOLS.health.name) {
+      return this.handleHealth();
     }
     const route = this.toolRoutes.get(name);
+    if (route) {
+      const conn = this.connections.get(route.namespace);
+      if (conn && conn.status === "error") {
+        const serverConfig = this.config?.servers.find((s) => s.namespace === route.namespace);
+        if (serverConfig) {
+          try {
+            await disconnectFromUpstream(conn);
+            const newConn = await connectToUpstream(serverConfig, (ns) => this.handleUpstreamDisconnect(ns));
+            this.connections.set(route.namespace, newConn);
+            this.rebuildRoutes();
+            await this.notifyAllListsChanged();
+            log("info", "Auto-reconnected to upstream", { namespace: route.namespace });
+          } catch (err) {
+            log("error", "Auto-reconnect failed", { namespace: route.namespace, error: err.message });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: 'Server "' + route.namespace + '" disconnected and auto-reconnect failed: ' + err.message + '. Try mcp_connect_activate("' + route.namespace + '") to manually reconnect.'
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+      }
+    }
+    const startMs = Date.now();
     const result = await routeToolCall(name, args, this.toolRoutes, this.connections);
+    const latencyMs = Date.now() - startMs;
     if (route) {
+      const conn = this.connections.get(route.namespace);
+      if (conn) {
+        conn.health.totalCalls++;
+        conn.health.totalLatencyMs += latencyMs;
+        if (result.isError) {
+          conn.health.errorCount++;
+          conn.health.lastErrorMessage = result.content[0]?.text;
+          conn.health.lastErrorAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      }
+      recordConnectEvent({
+        namespace: route.namespace,
+        toolName: route.originalName,
+        action: "tool_call",
+        latencyMs,
+        success: !result.isError,
+        error: result.isError ? result.content[0]?.text : void 0
+      });
       await this.trackUsageAndAutoDeactivate(route.namespace);
     }
     return result;
   }
-  handleDiscover() {
+  handleDiscover(context) {
     if (!this.config || this.config.servers.length === 0) {
       return {
         content: [
@@ -332,12 +712,26 @@ var ConnectServer = class _ConnectServer {
         ]
       };
     }
-    const lines = ["Available MCP servers:\n"];
-    for (const server2 of this.config.servers) {
-      if (!server2.isActive) continue;
+    const activeServers = this.config.servers.filter((s) => s.isActive);
+    let sorted;
+    const scores = /* @__PURE__ */ new Map();
+    if (context) {
+      for (const server2 of activeServers) {
+        const connection = this.connections.get(server2.namespace);
+        const tools = connection?.tools ?? [];
+        scores.set(server2.namespace, scoreRelevance(context, server2, tools));
+      }
+      sorted = [...activeServers].sort((a, b) => (scores.get(b.namespace) ?? 0) - (scores.get(a.namespace) ?? 0));
+    } else {
+      sorted = activeServers;
+    }
+    const lines = [context ? "Servers ranked by relevance:\n" : "Available MCP servers:\n"];
+    for (const server2 of sorted) {
       const connection = this.connections.get(server2.namespace);
-      const status = connection ? "ACTIVE (" + connection.tools.length + " tools)" : "available";
-      lines.push("  " + server2.namespace + " \u2014 " + server2.name + " [" + status + "] (" + server2.type + ")");
+      const status = connection ? connection.status === "error" ? "ERROR (disconnected, will auto-reconnect on use)" : "ACTIVE (" + connection.tools.length + " tools)" : "available";
+      const score = scores.get(server2.namespace);
+      const relevance = score && score > 0 ? " (relevance: " + score + ")" : "";
+      lines.push("  " + server2.namespace + " \u2014 " + server2.name + " [" + status + "] (" + server2.type + ")" + relevance);
     }
     const inactive = this.config.servers.filter((s) => !s.isActive);
     if (inactive.length > 0) {
@@ -386,11 +780,11 @@ var ConnectServer = class _ConnectServer {
       };
     }
     try {
-      const connection = await connectToUpstream(serverConfig);
+      const connection = await connectToUpstream(serverConfig, (ns) => this.handleUpstreamDisconnect(ns));
       this.connections.set(namespace, connection);
       this.idleCallCounts.set(namespace, 0);
-      this.toolRoutes = buildToolRoutes(this.connections);
-      await this.server.sendToolListChanged();
+      this.rebuildRoutes();
+      await this.notifyAllListsChanged();
       const toolNames = connection.tools.map((t) => t.namespacedName).join(", ");
       return {
         content: [
@@ -425,8 +819,8 @@ var ConnectServer = class _ConnectServer {
     await disconnectFromUpstream(connection);
     this.connections.delete(namespace);
     this.idleCallCounts.delete(namespace);
-    this.toolRoutes = buildToolRoutes(this.connections);
-    await this.server.sendToolListChanged();
+    this.rebuildRoutes();
+    await this.notifyAllListsChanged();
     return {
       content: [{ type: "text", text: 'Deactivated "' + namespace + '". Tools removed.' }]
     };
@@ -454,8 +848,8 @@ var ConnectServer = class _ConnectServer {
       }
     }
     if (toDeactivate.length > 0) {
-      this.toolRoutes = buildToolRoutes(this.connections);
-      await this.server.sendToolListChanged();
+      this.rebuildRoutes();
+      await this.notifyAllListsChanged();
     }
   }
   async fetchAndApplyConfig() {
@@ -476,6 +870,7 @@ var ConnectServer = class _ConnectServer {
         log("info", "Server removed or disabled in config, deactivating", { namespace });
         await disconnectFromUpstream(connection);
         this.connections.delete(namespace);
+        this.idleCallCounts.delete(namespace);
         changed = true;
         continue;
       }
@@ -484,12 +879,13 @@ var ConnectServer = class _ConnectServer {
         log("info", "Server config changed, deactivating stale connection", { namespace });
         await disconnectFromUpstream(connection);
         this.connections.delete(namespace);
+        this.idleCallCounts.delete(namespace);
         changed = true;
       }
     }
     if (changed) {
-      this.toolRoutes = buildToolRoutes(this.connections);
-      await this.server.sendToolListChanged();
+      this.rebuildRoutes();
+      await this.notifyAllListsChanged();
     }
   }
   startPolling() {
@@ -504,12 +900,112 @@ var ConnectServer = class _ConnectServer {
       this.pollTimer.unref();
     }
   }
+  async handleImport(filepath) {
+    if (!filepath) {
+      return { content: [{ type: "text", text: "filepath is required." }], isError: true };
+    }
+    const ALLOWED_FILENAMES = ["claude_desktop_config.json", "mcp.json", "settings.json", "mcp_config.json"];
+    const basename = filepath.split(/[/\\]/).pop() || "";
+    if (!ALLOWED_FILENAMES.includes(basename)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Only MCP config files are allowed: " + ALLOWED_FILENAMES.join(", ") + ". Got: " + basename
+          }
+        ],
+        isError: true
+      };
+    }
+    try {
+      const resolved = filepath.startsWith("~/") ? resolve(homedir(), filepath.slice(2)) : resolve(filepath);
+      const raw = await readFile(resolved, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!parsed.mcpServers || typeof parsed.mcpServers !== "object") {
+        return {
+          content: [{ type: "text", text: "No mcpServers object found in " + resolved }],
+          isError: true
+        };
+      }
+      const mcpServers = parsed.mcpServers;
+      if (typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+        return { content: [{ type: "text", text: "No mcpServers object found in " + resolved }], isError: true };
+      }
+      const servers = [];
+      for (const [key, value] of Object.entries(mcpServers)) {
+        if (!value || typeof value !== "object") continue;
+        if (key === "mcp-connect") continue;
+        const namespace = key.toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/^_+|_+$/g, "").slice(0, 30);
+        if (!namespace) continue;
+        const entry = {
+          name: key,
+          namespace,
+          type: value.url ? "remote" : "local"
+        };
+        if (value.command) entry.command = value.command;
+        if (value.args) entry.args = value.args;
+        if (value.url) entry.url = value.url;
+        servers.push(entry);
+      }
+      if (servers.length === 0) {
+        return { content: [{ type: "text", text: "No servers found in " + resolved }], isError: true };
+      }
+      const res = await request3(this.apiUrl.replace(/\/$/, "") + "/api/connect/import", {
+        method: "POST",
+        headers: {
+          Authorization: "Bearer " + this.token,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ servers }),
+        headersTimeout: 15e3,
+        bodyTimeout: 15e3
+      });
+      const body = await res.body.json();
+      if (res.statusCode >= 400) {
+        return {
+          content: [{ type: "text", text: "Import failed: " + (body.error || "HTTP " + res.statusCode) }],
+          isError: true
+        };
+      }
+      await this.fetchAndApplyConfig().catch(() => {
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Imported " + (body.imported || 0) + " servers" + (body.skipped ? ", " + body.skipped + " skipped (already exist)" : "") + " from " + resolved + ". Note: environment variables (API keys, tokens) were NOT imported for security \u2014 set them at mcp.hosting. Use mcp_connect_discover to see imported servers."
+          }
+        ]
+      };
+    } catch (err) {
+      return { content: [{ type: "text", text: "Import error: " + err.message }], isError: true };
+    }
+  }
+  handleHealth() {
+    if (this.connections.size === 0) {
+      return { content: [{ type: "text", text: "No active connections." }] };
+    }
+    const lines = ["Connection health:\n"];
+    for (const [namespace, conn] of this.connections) {
+      const h = conn.health;
+      const avgLatency = h.totalCalls > 0 ? Math.round(h.totalLatencyMs / h.totalCalls) : 0;
+      const errorRate = h.totalCalls > 0 ? Math.round(h.errorCount / h.totalCalls * 100) : 0;
+      lines.push("  " + namespace + " [" + conn.status + "]");
+      lines.push("    calls: " + h.totalCalls + ", errors: " + h.errorCount + " (" + errorRate + "%)");
+      lines.push("    avg latency: " + avgLatency + "ms");
+      if (h.lastErrorMessage) {
+        lines.push("    last error: " + h.lastErrorMessage + " at " + h.lastErrorAt);
+      }
+    }
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
   async shutdown() {
     log("info", "Shutting down mcp-connect");
     if (this.pollTimer) {
       clearInterval(this.pollTimer);
       this.pollTimer = null;
     }
+    await shutdownAnalytics();
     const disconnects = Array.from(this.connections.values()).map((conn) => disconnectFromUpstream(conn));
     await Promise.allSettled(disconnects);
     this.connections.clear();
@@ -519,15 +1015,15 @@ var ConnectServer = class _ConnectServer {
 };
 
 // src/index.ts
-var token = process.env.MCP_HOSTING_TOKEN;
-var apiUrl = process.env.MCP_HOSTING_URL ?? "https://mcp.hosting";
-if (!token) {
+var token2 = process.env.MCP_HOSTING_TOKEN;
+var apiUrl2 = process.env.MCP_HOSTING_URL ?? "https://mcp.hosting";
+if (!token2) {
   process.stderr.write(
     '\n  mcp-connect: MCP_HOSTING_TOKEN is required.\n\n  1. Create a token at https://mcp.hosting \u2192 Settings \u2192 API Tokens\n  2. Add it to your MCP client config:\n\n     {\n       "mcpServers": {\n         "mcp-connect": {\n           "command": "npx",\n           "args": ["@yawlabs/mcp-connect"],\n           "env": {\n             "MCP_HOSTING_TOKEN": "mcp_pat_your_token_here"\n           }\n         }\n       }\n     }\n\n'
   );
   process.exit(1);
 }
-var server = new ConnectServer(apiUrl, token);
+var server = new ConnectServer(apiUrl2, token2);
 var shutdown = async () => {
   await server.shutdown();
   process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/mcp-connect",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "MCP orchestrator — one install, all your MCP servers, managed from the cloud",
   "license": "MIT",
   "author": "Yaw Labs <contact@yaw.sh> (https://yaw.sh)",