mcp-lazy 0.1.4

package/dist/index.js

@@ -0,0 +1,1037 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/config.ts
+var config_exports = {};
+__export(config_exports, {
+  computeServerFingerprint: () => computeServerFingerprint,
+  convertUrlToMcpRemote: () => convertUrlToMcpRemote,
+  extractServersFromConfig: () => extractServersFromConfig,
+  extractServersFromOpencodeConfig: () => extractServersFromOpencodeConfig,
+  extractServersFromToml: () => extractServersFromToml,
+  loadServersBackup: () => loadServersBackup,
+  loadToolCache: () => loadToolCache,
+  saveServersBackup: () => saveServersBackup,
+  saveToolCache: () => saveToolCache
+});
+import { z } from "zod";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, dirname } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+function getBackupPath() {
+  return resolve(homedir(), ".mcp-lazy", "servers.json");
+}
+function saveServersBackup(servers) {
+  const existing = loadServersBackup();
+  const merged = { ...existing, ...servers };
+  delete merged["mcp-lazy"];
+  const dir = dirname(getBackupPath());
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getBackupPath(), JSON.stringify({ servers: merged }, null, 2) + "\n");
+}
+function loadServersBackup() {
+  if (!existsSync(getBackupPath())) {
+    return {};
+  }
+  try {
+    const raw = JSON.parse(readFileSync(getBackupPath(), "utf-8"));
+    return raw.servers ?? {};
+  } catch {
+    return {};
+  }
+}
+function convertUrlToMcpRemote(url, headers) {
+  const args = ["-y", "mcp-remote", url];
+  if (headers) {
+    for (const [key, value] of Object.entries(headers)) {
+      args.push("--header", `${key}:${value}`);
+    }
+  }
+  return { command: "npx", args };
+}
+function extractServersFromToml(content) {
+  const servers = {};
+  const sectionRegex = /^\[mcp_servers\.([^\]]+)\]/gm;
+  let match;
+  while ((match = sectionRegex.exec(content)) !== null) {
+    const name = match[1];
+    if (name === "mcp-lazy") continue;
+    const sectionStart = match.index + match[0].length;
+    const nextSection = /^\[[^\]]+\]/m.exec(content.slice(sectionStart));
+    const sectionContent = nextSection ? content.slice(sectionStart, sectionStart + nextSection.index) : content.slice(sectionStart);
+    const cmdMatch = /^\s*command\s*=\s*"([^"]+)"/m.exec(sectionContent);
+    const command = cmdMatch ? cmdMatch[1] : void 0;
+    const urlMatch = /^\s*url\s*=\s*"([^"]*)"/m.exec(sectionContent);
+    const serverUrlMatch = /^\s*serverUrl\s*=\s*"([^"]*)"/m.exec(sectionContent);
+    const url = urlMatch ? urlMatch[1] : serverUrlMatch ? serverUrlMatch[1] : void 0;
+    const argsMatch = /^\s*args\s*=\s*\[([^\]]*)\]/m.exec(sectionContent);
+    const args = [];
+    if (argsMatch) {
+      const inner = argsMatch[1];
+      const itemRegex = /"([^"]*)"/g;
+      let item;
+      while ((item = itemRegex.exec(inner)) !== null) {
+        args.push(item[1]);
+      }
+    }
+    const env = {};
+    const envSectionRegex = new RegExp(`^\\[mcp_servers\\.${name}\\.env\\]`, "m");
+    if (envSectionRegex.test(content)) {
+      const envStart = content.indexOf(`[mcp_servers.${name}.env]`) + `[mcp_servers.${name}.env]`.length;
+      const envEnd = /^\[[^\]]+\]/m.exec(content.slice(envStart));
+      const envContent = envEnd ? content.slice(envStart, envStart + envEnd.index) : content.slice(envStart);
+      const envPairRegex = /^\s*(\w+)\s*=\s*"([^"]*)"/gm;
+      let envMatch;
+      while ((envMatch = envPairRegex.exec(envContent)) !== null) {
+        env[envMatch[1]] = envMatch[2];
+      }
+    }
+    const headers = {};
+    const headersSectionRegex = new RegExp(`^\\[mcp_servers\\.${name}\\.http_headers\\]`, "m");
+    if (headersSectionRegex.test(content)) {
+      const headersStart = content.indexOf(`[mcp_servers.${name}.http_headers]`) + `[mcp_servers.${name}.http_headers]`.length;
+      const headersEnd = /^\[[^\]]+\]/m.exec(content.slice(headersStart));
+      const headersContent = headersEnd ? content.slice(headersStart, headersStart + headersEnd.index) : content.slice(headersStart);
+      const headerPairRegex = /^\s*(\S+)\s*=\s*"([^"]*)"/gm;
+      let headerMatch;
+      while ((headerMatch = headerPairRegex.exec(headersContent)) !== null) {
+        headers[headerMatch[1]] = headerMatch[2];
+      }
+    }
+    const bearerMatch = /^\s*bearer_token_env_var\s*=\s*"([^"]*)"/m.exec(sectionContent);
+    if (bearerMatch) {
+      const envVarName = bearerMatch[1];
+      const token = process.env[envVarName];
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+    }
+    if (command) {
+      servers[name] = { command, args, ...url && { url }, ...Object.keys(env).length > 0 && { env }, ...Object.keys(headers).length > 0 && { headers } };
+    } else if (url) {
+      servers[name] = { args, url, ...Object.keys(env).length > 0 && { env }, ...Object.keys(headers).length > 0 && { headers } };
+    }
+  }
+  return servers;
+}
+function extractServersFromConfig(configPath) {
+  if (!existsSync(configPath)) return {};
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    const parsed = McpJsonSchema.safeParse(raw);
+    if (!parsed.success) return {};
+    const servers = { ...parsed.data.mcpServers };
+    delete servers["mcp-lazy"];
+    for (const config of Object.values(servers)) {
+      if (config.serverUrl && !config.url) {
+        config.url = config.serverUrl;
+      }
+      delete config.serverUrl;
+    }
+    return servers;
+  } catch {
+    return {};
+  }
+}
+function getToolCachePath() {
+  return resolve(homedir(), ".mcp-lazy", "tool-cache.json");
+}
+function computeServerFingerprint(servers) {
+  const parts = Object.keys(servers).sort().map((name) => {
+    const s = servers[name];
+    return `${name}:${s.command ?? ""}:${(s.args ?? []).join(",")}`;
+  });
+  return createHash("sha256").update(parts.join("|")).digest("hex");
+}
+function loadToolCache() {
+  const cachePath = getToolCachePath();
+  if (!existsSync(cachePath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (typeof raw.fingerprint === "string" && Array.isArray(raw.tools)) {
+      return raw;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveToolCache(fingerprint, tools) {
+  const cachePath = getToolCachePath();
+  const dir = dirname(cachePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(cachePath, JSON.stringify({ fingerprint, tools }, null, 2) + "\n");
+}
+function extractServersFromOpencodeConfig(configPath) {
+  if (!existsSync(configPath)) return {};
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+    const mcpSection = raw.mcp;
+    if (!mcpSection || typeof mcpSection !== "object") return {};
+    const servers = {};
+    for (const [name, config] of Object.entries(mcpSection)) {
+      if (name === "mcp-lazy") continue;
+      const cfg = config;
+      if (cfg.type === "local" && Array.isArray(cfg.command) && cfg.command.length > 0) {
+        servers[name] = {
+          command: cfg.command[0],
+          args: cfg.command.slice(1),
+          ...cfg.environment && { env: cfg.environment }
+        };
+      } else if (cfg.type === "remote" && cfg.url) {
+        servers[name] = {
+          url: cfg.url,
+          args: [],
+          ...cfg.headers && { headers: cfg.headers }
+        };
+      }
+    }
+    return servers;
+  } catch {
+    return {};
+  }
+}
+var ServerConfigSchema, McpJsonSchema;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    "use strict";
+    ServerConfigSchema = z.object({
+      command: z.string().optional(),
+      args: z.array(z.string()).default([]),
+      url: z.string().optional(),
+      serverUrl: z.string().optional(),
+      headers: z.record(z.string()).optional(),
+      env: z.record(z.string()).optional(),
+      description: z.string().optional()
+    });
+    McpJsonSchema = z.object({
+      mcpServers: z.record(ServerConfigSchema)
+    });
+  }
+});
+
+// src/version.ts
+var VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    VERSION = "0.1.0";
+  }
+});
+
+// src/proxy/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ToolRegistry: () => ToolRegistry,
+  extractKeywords: () => extractKeywords
+});
+function extractKeywords(name, description) {
+  const text = `${name} ${description}`;
+  const words = text.replace(/[_-]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  return [...new Set(words)];
+}
+var ToolRegistry;
+var init_registry = __esm({
+  "src/proxy/registry.ts"() {
+    "use strict";
+    ToolRegistry = class {
+      tools = [];
+      addTool(entry) {
+        this.tools.push(entry);
+      }
+      addTools(entries) {
+        this.tools.push(...entries);
+      }
+      getToolCount() {
+        return this.tools.length;
+      }
+      getAllTools() {
+        return [...this.tools];
+      }
+      getServerNames() {
+        return [...new Set(this.tools.map((t) => t.server))];
+      }
+      getToolsByServer(serverName) {
+        return this.tools.filter((t) => t.server === serverName);
+      }
+      findTool(toolName, serverName) {
+        return this.tools.find(
+          (t) => t.name === toolName && t.server === serverName
+        );
+      }
+      search(query, limit = 5) {
+        const queryLower = query.toLowerCase();
+        const queryTokens = queryLower.split(/\s+/).filter(Boolean);
+        const scored = [];
+        for (const entry of this.tools) {
+          let score = 0;
+          const nameLower = entry.name.toLowerCase();
+          const descLower = entry.description.toLowerCase();
+          const serverDescLower = entry.serverDescription.toLowerCase();
+          if (nameLower === queryLower) {
+            score += 1;
+          } else if (nameLower.includes(queryLower) || queryTokens.some((t) => nameLower.includes(t))) {
+            score += 0.8;
+          }
+          for (const token of queryTokens) {
+            if (descLower.includes(token)) {
+              score += 0.6;
+            }
+          }
+          for (const token of queryTokens) {
+            if (serverDescLower.includes(token)) {
+              score += 0.4;
+              break;
+            }
+          }
+          for (const token of queryTokens) {
+            if (entry.keywords.some((k) => k.toLowerCase().includes(token))) {
+              score += 0.3;
+            }
+          }
+          if (score > 0) {
+            scored.push({ entry, score });
+          }
+        }
+        return scored.sort((a, b) => b.score - a.score).slice(0, limit).map(({ entry, score }) => ({
+          tool_name: entry.name,
+          server_name: entry.server,
+          description: entry.description,
+          relevance_score: Math.round(score * 100) / 100
+        }));
+      }
+      clear() {
+        this.tools = [];
+      }
+    };
+  }
+});
+
+// src/proxy/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  ServerLoader: () => ServerLoader
+});
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+var ServerLoader;
+var init_loader = __esm({
+  "src/proxy/loader.ts"() {
+    "use strict";
+    init_version();
+    ServerLoader = class {
+      servers = /* @__PURE__ */ new Map();
+      serverConfigs;
+      loading = /* @__PURE__ */ new Map();
+      constructor(serverConfigs) {
+        this.serverConfigs = serverConfigs;
+      }
+      async getClient(serverName) {
+        const existing = this.servers.get(serverName);
+        if (existing) {
+          return existing.client;
+        }
+        const pendingLoad = this.loading.get(serverName);
+        if (pendingLoad) {
+          return pendingLoad;
+        }
+        const loadPromise = this.loadServer(serverName);
+        this.loading.set(serverName, loadPromise);
+        try {
+          const client = await loadPromise;
+          return client;
+        } finally {
+          this.loading.delete(serverName);
+        }
+      }
+      async loadServer(serverName) {
+        const config = this.serverConfigs[serverName];
+        if (!config) {
+          throw new Error(`Unknown server: ${serverName}`);
+        }
+        try {
+          return await this.attemptConnect(serverName, config);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          if (message.includes("timed out")) {
+            try {
+              return await this.attemptConnect(serverName, config);
+            } catch (retryError) {
+              throw retryError;
+            }
+          }
+          throw error;
+        }
+      }
+      async attemptConnect(serverName, config) {
+        const timeoutMs = 3e4;
+        if (!config.command) {
+          throw new Error(`Server ${serverName} has no command configured`);
+        }
+        const client = new Client({
+          name: `mcp-lazy-proxy/${serverName}`,
+          version: VERSION
+        });
+        const env = { ...process.env, ...config.env };
+        const transport = new StdioClientTransport({
+          command: config.command,
+          args: config.args,
+          env
+        });
+        const connectPromise = client.connect(transport);
+        const timeoutPromise = new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Server ${serverName} timed out after ${timeoutMs}ms`)), timeoutMs)
+        );
+        await Promise.race([connectPromise, timeoutPromise]);
+        this.servers.set(serverName, {
+          client,
+          transport,
+          loadedAt: /* @__PURE__ */ new Date()
+        });
+        return client;
+      }
+      getLoadedServers() {
+        return [...this.servers.keys()];
+      }
+      isLoaded(serverName) {
+        return this.servers.has(serverName);
+      }
+      async closeServer(serverName) {
+        const server = this.servers.get(serverName);
+        if (server) {
+          await server.client.close();
+          this.servers.delete(serverName);
+        }
+      }
+      async closeAll() {
+        const closePromises = [...this.servers.keys()].map(
+          (name) => this.closeServer(name)
+        );
+        await Promise.allSettled(closePromises);
+      }
+      hasConfig(serverName) {
+        return serverName in this.serverConfigs;
+      }
+    };
+  }
+});
+
+// src/proxy/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createProxyServer: () => createProxyServer,
+  startProxyServer: () => startProxyServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+async function createProxyServer(registry, loader) {
+  const server = new McpServer({
+    name: "mcp-lazy",
+    version: VERSION
+  });
+  server.tool(
+    "mcp_search_tools",
+    `Search available MCP tools by keyword.
+Use this BEFORE calling any MCP tool.
+Returns matching tool names, server names, and descriptions.
+Example: mcp_search_tools("query database") \u2192 postgres-mcp.query_database`,
+    {
+      query: z2.string().describe("What you want to do in natural language"),
+      limit: z2.number().optional().default(5).describe("Max results to return (default: 5)")
+    },
+    async ({ query, limit }) => {
+      const results = registry.search(query, limit);
+      if (results.length === 0) {
+        const allServers = registry.getServerNames();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                results: [],
+                suggestion: `No tools found for "${query}". Available servers: ${allServers.join(", ")}. Try different keywords.`
+              })
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ results })
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "mcp_execute_tool",
+    `Execute a specific MCP tool.
+Use tool_name and server_name from mcp_search_tools results.`,
+    {
+      tool_name: z2.string().describe("Tool name from mcp_search_tools"),
+      server_name: z2.string().describe("Server name from mcp_search_tools"),
+      arguments: z2.record(z2.unknown()).optional().describe("Tool arguments")
+    },
+    async ({ tool_name, server_name, arguments: args }) => {
+      const tool = registry.findTool(tool_name, server_name);
+      if (!tool) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Tool "${tool_name}" not found in server "${server_name}". Use mcp_search_tools first.`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      if (!loader.hasConfig(server_name)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Server "${server_name}" is not configured.`
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const client = await loader.getClient(server_name);
+        const result = await client.callTool({
+          name: tool_name,
+          arguments: args ?? {}
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const alternatives = registry.search(tool_name, 3);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Failed to execute ${tool_name} on ${server_name}: ${message}`,
+                alternatives: alternatives.length > 0 ? alternatives : void 0
+              })
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  return server;
+}
+async function startProxyServer(registry, loader) {
+  const server = await createProxyServer(registry, loader);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", async () => {
+    await loader.closeAll();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    await loader.closeAll();
+    process.exit(0);
+  });
+}
+var init_server = __esm({
+  "src/proxy/server.ts"() {
+    "use strict";
+    init_version();
+  }
+});
+
+// src/utils/mcp-client.ts
+var mcp_client_exports = {};
+__export(mcp_client_exports, {
+  callServerTool: () => callServerTool,
+  connectToServer: () => connectToServer,
+  disconnectServer: () => disconnectServer,
+  listServerTools: () => listServerTools
+});
+import { Client as Client2 } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport as StdioClientTransport2 } from "@modelcontextprotocol/sdk/client/stdio.js";
+async function connectToServer(command, args, env) {
+  const client = new Client2({
+    name: "mcp-lazy-proxy",
+    version: VERSION
+  });
+  const mergedEnv = { ...process.env, ...env };
+  const transport = new StdioClientTransport2({
+    command,
+    args,
+    env: mergedEnv
+  });
+  await client.connect(transport);
+  return { client, transport };
+}
+async function listServerTools(client) {
+  const allTools = [];
+  let cursor;
+  do {
+    const result = await client.listTools({ cursor });
+    for (const tool of result.tools) {
+      allTools.push({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      });
+    }
+    cursor = result.nextCursor;
+  } while (cursor);
+  return allTools;
+}
+async function callServerTool(client, toolName, args) {
+  const result = await client.callTool({
+    name: toolName,
+    arguments: args
+  });
+  return result;
+}
+async function disconnectServer(connection) {
+  await connection.client.close();
+}
+var init_mcp_client = __esm({
+  "src/utils/mcp-client.ts"() {
+    "use strict";
+    init_version();
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/agents/index.ts
+init_config();
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+function resolvePath(p) {
+  const home = homedir2();
+  const cwd = process.cwd();
+  return p.startsWith("~") ? resolve2(home, p.slice(2)) : resolve2(cwd, p);
+}
+var AGENTS = [
+  {
+    name: "cursor",
+    displayName: "Cursor",
+    configPaths: ["~/.cursor/mcp.json"]
+  },
+  {
+    name: "opencode",
+    displayName: "Opencode",
+    configPaths: ["~/.config/opencode/config.json"],
+    format: "opencode"
+  },
+  {
+    name: "antigravity",
+    displayName: "Antigravity",
+    configPaths: ["~/.gemini/antigravity/mcp_config.json"]
+  },
+  {
+    name: "codex",
+    displayName: "Codex",
+    configPaths: ["~/.codex/config.toml"],
+    format: "toml"
+  }
+];
+function getAgentByName(name) {
+  return AGENTS.find((a) => a.name === name);
+}
+function findAgentConfig(agent) {
+  for (const p of agent.configPaths) {
+    const resolved = resolvePath(p);
+    if (existsSync2(resolved)) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function generateProxyEntry() {
+  return {
+    command: "npx",
+    args: ["-y", "mcp-lazy", "serve"]
+  };
+}
+function registerProxy(agent) {
+  const existing = findAgentConfig(agent);
+  const fallback = agent.configPaths[0];
+  let targetPath = existing ?? resolvePath(fallback);
+  let created = false;
+  let serverCount = 0;
+  if (agent.format === "opencode") {
+    if (existsSync2(targetPath)) {
+      try {
+        const fullConfig = JSON.parse(readFileSync2(targetPath, "utf-8"));
+        const mcpSection = fullConfig.mcp || {};
+        const serversToBackup = {};
+        for (const [name, cfg] of Object.entries(mcpSection)) {
+          if (name === "mcp-lazy") continue;
+          const c = cfg;
+          if (c.type === "remote" && c.url) {
+            serversToBackup[name] = convertUrlToMcpRemote(c.url, c.headers);
+          } else if (c.type === "local" && Array.isArray(c.command) && c.command.length > 0) {
+            serversToBackup[name] = {
+              command: c.command[0],
+              args: c.command.slice(1),
+              ...c.environment && { env: c.environment }
+            };
+          }
+        }
+        serverCount = Object.keys(serversToBackup).length;
+        if (serverCount > 0) {
+          saveServersBackup(serversToBackup);
+        }
+        fullConfig.mcp = {
+          "mcp-lazy": {
+            type: "local",
+            command: ["npx", "-y", "mcp-lazy", "serve"]
+          }
+        };
+        writeFileSync2(targetPath, JSON.stringify(fullConfig, null, 2) + "\n");
+      } catch {
+        const config = { mcp: { "mcp-lazy": { type: "local", command: ["npx", "-y", "mcp-lazy", "serve"] } } };
+        writeFileSync2(targetPath, JSON.stringify(config, null, 2) + "\n");
+      }
+    } else {
+      created = true;
+      const dir = dirname2(targetPath);
+      if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+      const config = { mcp: { "mcp-lazy": { type: "local", command: ["npx", "-y", "mcp-lazy", "serve"] } } };
+      writeFileSync2(targetPath, JSON.stringify(config, null, 2) + "\n");
+    }
+    return { configPath: targetPath, created, serverCount };
+  }
+  if (agent.format === "toml") {
+    if (!existsSync2(targetPath)) {
+      created = true;
+      const dir = dirname2(targetPath);
+      if (!existsSync2(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+    }
+    const existingContent = existsSync2(targetPath) ? readFileSync2(targetPath, "utf-8") : "";
+    const allServers = extractServersFromToml(existingContent);
+    const serversToBackup = {};
+    for (const [name, cfg] of Object.entries(allServers)) {
+      if (cfg.command) {
+        serversToBackup[name] = cfg;
+      } else if (cfg.url) {
+        serversToBackup[name] = convertUrlToMcpRemote(cfg.url, cfg.headers);
+      }
+    }
+    serverCount = Object.keys(serversToBackup).length;
+    if (serverCount > 0) {
+      saveServersBackup(serversToBackup);
+    }
+    let cleaned = existingContent.replace(
+      /\n?\[mcp_servers\.[^\]]+\](?:\n(?!\[)[^\n]*)*/g,
+      ""
+    ).trimEnd();
+    const tomlBlock = `
+
+[mcp_servers.mcp-lazy]
+command = "npx"
+args = ["-y", "mcp-lazy", "serve"]
+`;
+    writeFileSync2(targetPath, cleaned + tomlBlock);
+    return { configPath: targetPath, created, serverCount };
+  }
+  if (existsSync2(targetPath)) {
+    let rawConfig = {};
+    try {
+      rawConfig = JSON.parse(readFileSync2(targetPath, "utf-8"));
+    } catch {
+    }
+    const rawServers = rawConfig.mcpServers ?? {};
+    const serversToBackup = {};
+    const normalizedServers = extractServersFromConfig(targetPath);
+    for (const [name, serverCfg] of Object.entries(rawServers)) {
+      if (name === "mcp-lazy") continue;
+      const cfg = serverCfg;
+      if (cfg.url || cfg.serverUrl) {
+        const url = cfg.url || cfg.serverUrl;
+        const headers = cfg.headers;
+        serversToBackup[name] = convertUrlToMcpRemote(url, headers);
+      } else if (cfg.command && normalizedServers[name]) {
+        serversToBackup[name] = normalizedServers[name];
+      }
+    }
+    serverCount = Object.keys(serversToBackup).length;
+    if (serverCount > 0) {
+      saveServersBackup(serversToBackup);
+    }
+    const config = {
+      mcpServers: {
+        "mcp-lazy": generateProxyEntry()
+      }
+    };
+    writeFileSync2(targetPath, JSON.stringify(config, null, 2) + "\n");
+  } else {
+    created = true;
+    const dir = dirname2(targetPath);
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    const config = {
+      mcpServers: {
+        "mcp-lazy": generateProxyEntry()
+      }
+    };
+    writeFileSync2(targetPath, JSON.stringify(config, null, 2) + "\n");
+  }
+  return { configPath: targetPath, created, serverCount };
+}
+function isProxyRegistered(agent) {
+  const configPath = findAgentConfig(agent);
+  if (!configPath) return false;
+  if (agent.format === "opencode") {
+    try {
+      const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+      return !!(config.mcp && config.mcp["mcp-lazy"]);
+    } catch {
+      return false;
+    }
+  }
+  if (agent.format === "toml") {
+    try {
+      const content = readFileSync2(configPath, "utf-8");
+      return content.includes("[mcp_servers.mcp-lazy]");
+    } catch {
+      return false;
+    }
+  }
+  try {
+    const config = JSON.parse(readFileSync2(configPath, "utf-8"));
+    return !!(config.mcpServers && config.mcpServers["mcp-lazy"]);
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/add.ts
+var BANNER = `
+\x1B[36m\x1B[1m \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557       \u2588\u2588\u2557      \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557   \u2588\u2588\u2557
+ \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557      \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2557 \u2588\u2588\u2554\u255D
+ \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551  \u2588\u2588\u2588\u2554\u255D  \u255A\u2588\u2588\u2588\u2588\u2554\u255D
+ \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551 \u2588\u2588\u2588\u2554\u255D    \u255A\u2588\u2588\u2554\u255D
+ \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551           \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2551
+ \u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D           \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u255D\x1B[0m
+`;
+async function runAdd(options) {
+  console.log(BANNER);
+  let targets = [];
+  if (options.all) {
+    targets = [...AGENTS];
+  } else {
+    const flagMap = {
+      cursor: options.cursor,
+      opencode: options.opencode,
+      antigravity: options.antigravity,
+      codex: options.codex
+    };
+    for (const [name, enabled] of Object.entries(flagMap)) {
+      if (enabled) {
+        const agent = getAgentByName(name);
+        if (agent) {
+          targets.push(agent);
+        }
+      }
+    }
+  }
+  if (targets.length === 0) {
+    console.log("  No agent specified. Use one of:");
+    console.log("    mcp-lazy add --cursor");
+    console.log("    mcp-lazy add --opencode");
+    console.log("    mcp-lazy add --antigravity");
+    console.log("    mcp-lazy add --codex");
+    console.log("    mcp-lazy add --all\n");
+    process.exit(1);
+  }
+  console.log("  Registering mcp-lazy proxy...\n");
+  for (const agent of targets) {
+    try {
+      const { configPath, created, serverCount } = registerProxy(agent);
+      const action = created ? "created" : "updated";
+      const servers = serverCount > 0 ? ` (${serverCount} servers captured)` : "";
+      console.log(`  \u2713 ${agent.displayName}: ${action} ${configPath}${servers}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.log(`  \u2717 ${agent.displayName}: failed - ${message}`);
+    }
+  }
+  console.log("\n  Done! Restart your agents to activate mcp-lazy.\n");
+}
+
+// src/cli/doctor.ts
+init_config();
+var TOKENS_PER_TOOL = 650;
+var PROXY_BASE_TOKENS = 350;
+async function runDoctor() {
+  let hasIssues = false;
+  console.log("\nmcp-lazy status check\n");
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split(".")[0], 10);
+  if (major >= 18) {
+    console.log(`  \u2713 Node.js ${nodeVersion}`);
+  } else {
+    console.log(`  \u2717 Node.js ${nodeVersion} (requires >= 18)`);
+    hasIssues = true;
+  }
+  const servers = loadServersBackup();
+  const serverCount = Object.keys(servers).length;
+  if (serverCount > 0) {
+    const serverNames = Object.keys(servers);
+    console.log(`  \u2713 ${serverCount} MCP server(s) registered`);
+    for (const name of serverNames) {
+      console.log(`    - ${name}`);
+    }
+  } else {
+    console.log(`  \u2717 No MCP servers registered -> run 'mcp-lazy add --<agent>'`);
+    hasIssues = true;
+  }
+  console.log("");
+  let registeredCount = 0;
+  for (const agent of AGENTS) {
+    const registered = isProxyRegistered(agent);
+    if (registered) {
+      console.log(`  \u2713 ${agent.displayName} registered`);
+      registeredCount++;
+    } else {
+      console.log(`  - ${agent.displayName} not registered -> mcp-lazy add --${agent.name}`);
+    }
+  }
+  if (registeredCount === 0) {
+    console.log("\n  No agents registered. Run 'mcp-lazy add --<agent>' to register.");
+    hasIssues = true;
+  }
+  if (serverCount > 0) {
+    const estimatedTools = serverCount * 15;
+    const estimatedTokens = estimatedTools * TOKENS_PER_TOOL;
+    const savings = estimatedTokens > 0 ? Math.round((estimatedTokens - PROXY_BASE_TOKENS) / estimatedTokens * 100) : 0;
+    console.log(`
+  Token savings estimate:`);
+    console.log(`    ${serverCount} server(s) registered`);
+    console.log(`    Without mcp-lazy: ~${estimatedTokens.toLocaleString()} tokens`);
+    console.log(`    With mcp-lazy:     ${PROXY_BASE_TOKENS.toLocaleString()} tokens`);
+    console.log(`    Estimated savings: ${savings}%`);
+  }
+  console.log("");
+  if (!hasIssues) {
+    console.log("  All checks passed.\n");
+  } else {
+    console.log("  Some issues found. See above for details.\n");
+  }
+}
+
+// src/index.ts
+init_version();
+var program = new Command();
+program.name("mcp-lazy").description("MCP lazy loading proxy - reduce context window token usage by 90%+").version(VERSION);
+program.command("add").description("Register mcp-lazy proxy with an agent").option("--cursor", "Register with Cursor").option("--opencode", "Register with Opencode").option("--antigravity", "Register with Antigravity").option("--codex", "Register with Codex").option("--all", "Register with all agents").action(async (options) => {
+  await runAdd(options);
+});
+program.command("doctor").description("Check installation status and token savings").action(async () => {
+  await runDoctor();
+});
+program.command("serve").description("Start the mcp-lazy proxy server (stdio mode)").action(async () => {
+  await runServe();
+});
+async function runServe() {
+  const { loadServersBackup: loadServersBackup2, computeServerFingerprint: computeServerFingerprint2, loadToolCache: loadToolCache2, saveToolCache: saveToolCache2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { ToolRegistry: ToolRegistry2, extractKeywords: extractKeywords2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  const { ServerLoader: ServerLoader2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+  const { startProxyServer: startProxyServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  const { connectToServer: connectToServer2, listServerTools: listServerTools2, disconnectServer: disconnectServer2 } = await Promise.resolve().then(() => (init_mcp_client(), mcp_client_exports));
+  const servers = loadServersBackup2();
+  const serverNames = Object.keys(servers);
+  if (serverNames.length === 0) {
+    console.error("No MCP servers found. Check your MCP configurations.");
+    process.exit(1);
+  }
+  const registry = new ToolRegistry2();
+  const startMs = Date.now();
+  const fingerprint = computeServerFingerprint2(servers);
+  const cached = loadToolCache2();
+  if (cached && cached.fingerprint === fingerprint) {
+    for (const entry of cached.tools) {
+      registry.addTool(entry);
+    }
+    const elapsed = Date.now() - startMs;
+    console.error(`mcp-lazy: loaded ${registry.getToolCount()} tools from cache in ${elapsed}ms`);
+  } else {
+    const results = await Promise.allSettled(
+      serverNames.map(async (name) => {
+        const serverConfig = servers[name];
+        if (!serverConfig.command) {
+          console.error(`Warning: ${name} has no command configured, skipping`);
+          return [];
+        }
+        const conn = await connectToServer2(serverConfig.command, serverConfig.args, serverConfig.env);
+        const tools = await listServerTools2(conn.client);
+        await disconnectServer2(conn);
+        return tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description ?? "",
+          server: name,
+          serverDescription: serverConfig.description ?? "",
+          inputSchema: tool.inputSchema,
+          keywords: extractKeywords2(tool.name, tool.description ?? "")
+        }));
+      })
+    );
+    let successCount = 0;
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === "fulfilled") {
+        for (const entry of result.value) {
+          registry.addTool(entry);
+        }
+        if (result.value.length > 0) successCount++;
+      } else {
+        const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        console.error(`Warning: could not connect to ${serverNames[i]}: ${message}`);
+      }
+    }
+    const elapsed = Date.now() - startMs;
+    console.error(`mcp-lazy: discovered ${registry.getToolCount()} tools from ${successCount} servers in ${elapsed}ms`);
+    saveToolCache2(fingerprint, registry.getAllTools());
+  }
+  if (registry.getToolCount() === 0) {
+    console.error("No tools discovered from any server. Check your MCP configurations.");
+    process.exit(1);
+  }
+  const loader = new ServerLoader2(servers);
+  await startProxyServer2(registry, loader);
+}
+program.parse();
+//# sourceMappingURL=index.js.map