@hasna/mcps 0.0.1 → 0.0.3

package/dist/index.js

@@ -25,8 +25,97 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/lib/config.ts
+import { join } from "path";
+import { homedir } from "os";
+var MCPS_DIR, DB_PATH, REGISTRY_API_URL = "https://registry.modelcontextprotocol.io/v0/servers", TOOL_PREFIX_SEPARATOR = "__";
+var init_config = __esm(() => {
+  MCPS_DIR = join(homedir(), ".mcps");
+  DB_PATH = join(MCPS_DIR, "registry.db");
+});
+
+// src/lib/db.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "fs";
+function getDb() {
+  if (db)
+    return db;
+  mkdirSync(MCPS_DIR, { recursive: true });
+  db = new Database(DB_PATH, { create: true });
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS servers (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT,
+      command TEXT NOT NULL,
+      args TEXT NOT NULL DEFAULT '[]',
+      env TEXT NOT NULL DEFAULT '{}',
+      transport TEXT NOT NULL DEFAULT 'stdio',
+      url TEXT,
+      source TEXT NOT NULL DEFAULT 'local',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tool_cache (
+      server_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      input_schema TEXT NOT NULL DEFAULT '{}',
+      cached_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (server_id, name),
+      FOREIGN KEY (server_id) REFERENCES servers(id) ON DELETE CASCADE
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tool_cache_server ON tool_cache(server_id)");
+  try {
+    db.exec("ALTER TABLE servers ADD COLUMN last_connected_at TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE servers ADD COLUMN last_error TEXT");
+  } catch {}
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sources (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      url TEXT NOT NULL,
+      description TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  const count = db.query("SELECT COUNT(*) as c FROM sources").get().c;
+  if (count === 0) {
+    db.exec(`
+      INSERT OR IGNORE INTO sources (id, name, type, url, description) VALUES
+        ('official-registry', 'Official MCP Registry', 'mcp-registry', 'https://registry.modelcontextprotocol.io/v0/servers', 'The official Model Context Protocol server registry'),
+        ('awesome-mcp-servers', 'Awesome MCP Servers', 'awesome-list', 'https://raw.githubusercontent.com/punkpeye/awesome-mcp-servers/main/README.md', 'Curated list of MCP servers by punkpeye'),
+        ('npm-mcp', 'npm MCP Packages', 'npm-search', 'https://registry.npmjs.org/-/v1/search', 'Search npm packages for MCP servers'),
+        ('github-mcp-topic', 'GitHub MCP Topic', 'github-topic', 'https://api.github.com/search/repositories', 'GitHub repositories tagged with mcp-server topic')
+    `);
+  }
+  return db;
+}
+function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+var db = null;
+var init_db = __esm(() => {
+  init_config();
+});
+
 // node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -6286,7 +6375,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time3(str) {
+    return function time(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -6955,92 +7044,381 @@ var require_cross_spawn = __commonJS((exports, module) => {
   module.exports._enoent = enoent;
 });
 
-// src/lib/db.ts
-import { Database } from "bun:sqlite";
-import { mkdirSync } from "fs";
-
-// src/lib/config.ts
-import { join } from "path";
-import { homedir } from "os";
-var MCPS_DIR = join(homedir(), ".mcps");
-var DB_PATH = join(MCPS_DIR, "registry.db");
-var REGISTRY_API_URL = "https://registry.modelcontextprotocol.io/v0/servers";
-var TOOL_PREFIX_SEPARATOR = "__";
-
-// src/lib/db.ts
-var db = null;
-function getDb() {
-  if (db)
-    return db;
-  mkdirSync(MCPS_DIR, { recursive: true });
-  db = new Database(DB_PATH, { create: true });
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA busy_timeout = 5000");
-  db.exec("PRAGMA foreign_keys = ON");
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS servers (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      description TEXT,
-      command TEXT NOT NULL,
-      args TEXT NOT NULL DEFAULT '[]',
-      env TEXT NOT NULL DEFAULT '{}',
-      transport TEXT NOT NULL DEFAULT 'stdio',
-      url TEXT,
-      source TEXT NOT NULL DEFAULT 'local',
-      enabled INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-    )
-  `);
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS tool_cache (
-      server_id TEXT NOT NULL,
-      name TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      input_schema TEXT NOT NULL DEFAULT '{}',
-      cached_at TEXT NOT NULL DEFAULT (datetime('now')),
-      PRIMARY KEY (server_id, name),
-      FOREIGN KEY (server_id) REFERENCES servers(id) ON DELETE CASCADE
-    )
-  `);
-  db.exec("CREATE INDEX IF NOT EXISTS idx_tool_cache_server ON tool_cache(server_id)");
-  return db;
+// src/lib/sources.ts
+var exports_sources = {};
+__export(exports_sources, {
+  searchSource: () => searchSource,
+  removeSource: () => removeSource,
+  listSources: () => listSources,
+  getSource: () => getSource,
+  findServers: () => findServers,
+  enableSource: () => enableSource,
+  disableSource: () => disableSource,
+  clearCache: () => clearCache,
+  addSource: () => addSource
+});
+import { mkdirSync as mkdirSync2, existsSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from "fs";
+import { join as join2 } from "path";
+function getCacheFile(sourceId) {
+  return join2(CACHE_DIR, `${sourceId}.json`);
+}
+function readCache(sourceId) {
+  try {
+    const file = getCacheFile(sourceId);
+    if (!existsSync(file))
+      return null;
+    const data = JSON.parse(readFileSync(file, "utf-8"));
+    return data;
+  } catch {
+    return null;
+  }
 }
-function closeDb() {
-  if (db) {
-    db.close();
-    db = null;
+function writeCache(sourceId, results) {
+  try {
+    mkdirSync2(CACHE_DIR, { recursive: true });
+    writeFileSync(getCacheFile(sourceId), JSON.stringify({ results, cachedAt: Date.now() }), "utf-8");
+  } catch {}
+}
+function clearCache(sourceId) {
+  try {
+    if (!existsSync(CACHE_DIR))
+      return;
+    const files = readdirSync(CACHE_DIR);
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      if (!sourceId || file.startsWith(`${sourceId}.`)) {
+        try {
+          unlinkSync(join2(CACHE_DIR, file));
+        } catch {}
+      }
+    }
+  } catch {}
+}
+function generateId2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function listSources() {
+  const db2 = getDb();
+  const rows = db2.query("SELECT * FROM sources ORDER BY created_at ASC").all();
+  return rows.map((r) => ({ ...r, enabled: r.enabled === 1 }));
+}
+function getSource(id) {
+  const db2 = getDb();
+  const row = db2.query("SELECT * FROM sources WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return { ...row, enabled: row.enabled === 1 };
+}
+function addSource(opts) {
+  const db2 = getDb();
+  const id = generateId2(opts.name);
+  db2.run("INSERT INTO sources (id, name, type, url, description) VALUES (?, ?, ?, ?, ?)", [id, opts.name, opts.type, opts.url, opts.description ?? null]);
+  return getSource(id);
+}
+function removeSource(id) {
+  const db2 = getDb();
+  db2.run("DELETE FROM sources WHERE id = ?", [id]);
+}
+function enableSource(id) {
+  const db2 = getDb();
+  db2.run("UPDATE sources SET enabled = 1 WHERE id = ?", [id]);
+}
+function disableSource(id) {
+  const db2 = getDb();
+  db2.run("UPDATE sources SET enabled = 0 WHERE id = ?", [id]);
+}
+async function searchMcpRegistry(source, query) {
+  try {
+    const res = await fetch(source.url);
+    if (!res.ok)
+      return [];
+    const data = await res.json();
+    const q = query.toLowerCase();
+    return (data.servers || []).map((e) => e.server).filter((s) => q === "" || s.name.toLowerCase().includes(q) || (s.description || "").toLowerCase().includes(q)).map((s) => ({
+      name: s.name,
+      description: s.description || "",
+      source: "registry",
+      sourceId: source.id,
+      url: s.repository?.url,
+      githubRepo: s.repository?.url,
+      installCmd: s.packages?.[0] ? s.packages[0].registryType === "npm" ? `npx -y ${s.packages[0].identifier}` : s.packages[0].identifier : undefined,
+      npmPackage: s.packages?.find((p) => p.registryType === "npm")?.identifier
+    }));
+  } catch {
+    return [];
+  }
+}
+async function searchAwesomeList(source, query) {
+  try {
+    const res = await fetch(source.url);
+    if (!res.ok)
+      return [];
+    const text = await res.text();
+    const results = [];
+    const linkPattern = /\[([^\]]+)\]\((https?:\/\/[^)]+)\)(?:\s*[-\u2013]\s*([^\n]+))?/g;
+    const q = query.toLowerCase();
+    let match;
+    while ((match = linkPattern.exec(text)) !== null) {
+      const name = match[1].trim();
+      const url2 = match[2].trim();
+      const description = match[3]?.trim() || "";
+      if ((url2.includes("github.com") || url2.includes("npmjs.com")) && name.length > 2) {
+        if (q === "" || `${name} ${description}`.toLowerCase().includes(q)) {
+          results.push({
+            name,
+            description,
+            source: "awesome",
+            sourceId: source.id,
+            url: url2,
+            githubRepo: url2.includes("github.com") ? url2 : undefined,
+            installCmd: url2.includes("npmjs.com") ? `npx -y ${url2.split("/").pop()}` : undefined
+          });
+        }
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function scoreNpmPackage(pkg) {
+  const name = pkg.name.toLowerCase();
+  const keywords = (pkg.keywords || []).map((k) => k.toLowerCase());
+  let score = 0;
+  if (name.includes("mcp-server"))
+    score += 3;
+  else if (name.startsWith("mcp-") || name.endsWith("-mcp"))
+    score += 2;
+  else if (name.includes("mcp"))
+    score += 1;
+  if (keywords.includes("mcp"))
+    score += 1;
+  if (keywords.includes("mcp-server"))
+    score += 2;
+  if (keywords.some((k) => k.includes("modelcontextprotocol")))
+    score += 2;
+  return score;
+}
+async function searchNpm(source, query) {
+  try {
+    const url2 = new URL(source.url);
+    url2.searchParams.set("text", `mcp-server ${query}`);
+    url2.searchParams.set("size", "50");
+    const res = await fetch(url2.toString());
+    if (!res.ok)
+      return [];
+    const data = await res.json();
+    const q = query.toLowerCase();
+    const scored = (data.objects || []).map((o) => ({ pkg: o.package, score: scoreNpmPackage(o.package) })).filter(({ pkg, score }) => {
+      if (score < 1)
+        return false;
+      const text = `${pkg.name} ${pkg.description || ""} ${(pkg.keywords || []).join(" ")}`.toLowerCase();
+      return q === "" || text.includes(q);
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map(({ pkg }) => ({
+      name: pkg.name,
+      description: pkg.description || "",
+      source: "npm",
+      sourceId: source.id,
+      url: pkg.links?.repository || pkg.links?.npm,
+      npmPackage: pkg.name,
+      installCmd: `npx -y ${pkg.name}`
+    }));
+  } catch {
+    return [];
+  }
+}
+async function searchGitHubTopic(source, query) {
+  const token = process.env.GITHUB_TOKEN;
+  try {
+    const url2 = new URL(source.url);
+    const q = query ? `${query} topic:mcp-server` : "topic:mcp-server";
+    url2.searchParams.set("q", q);
+    url2.searchParams.set("sort", "stars");
+    url2.searchParams.set("per_page", "30");
+    const headers = {
+      Accept: "application/vnd.github.v3+json"
+    };
+    if (token)
+      headers["Authorization"] = `Bearer ${token}`;
+    const res = await fetch(url2.toString(), { headers });
+    if (!res.ok)
+      return [];
+    const data = await res.json();
+    return (data.items || []).map((repo) => ({
+      name: repo.full_name,
+      description: repo.description || "",
+      source: "github",
+      sourceId: source.id,
+      url: repo.html_url,
+      githubRepo: repo.html_url,
+      stars: repo.stargazers_count
+    }));
+  } catch {
+    return [];
+  }
+}
+async function fetchSource(source) {
+  switch (source.type) {
+    case "mcp-registry":
+      return searchMcpRegistry(source, "");
+    case "awesome-list":
+      return searchAwesomeList(source, "");
+    case "npm-search":
+      return searchNpm(source, "");
+    case "github-topic":
+      return searchGitHubTopic(source, "");
+    default:
+      return [];
   }
 }
+function filterResults(results, query) {
+  if (!query)
+    return results;
+  const q = query.toLowerCase();
+  return results.filter((r) => {
+    const text = `${r.name} ${r.description || ""}`.toLowerCase();
+    return text.includes(q);
+  });
+}
+async function searchSource(source, query, noCache = false) {
+  if (!noCache) {
+    const cached2 = readCache(source.id);
+    if (cached2 && Date.now() - cached2.cachedAt < DEFAULT_TTL_MS) {
+      return filterResults(cached2.results, query);
+    }
+  }
+  const results = await fetchSource(source);
+  writeCache(source.id, results);
+  return filterResults(results, query);
+}
+function deduplicate(results) {
+  const seen = new Set;
+  return results.filter((r) => {
+    const key = r.npmPackage || r.githubRepo || r.name.toLowerCase();
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function findServers(query, opts = {}) {
+  let sources = listSources().filter((s) => s.enabled);
+  if (opts.sources && opts.sources.length > 0) {
+    sources = sources.filter((s) => opts.sources.includes(s.id));
+  }
+  const limit = opts.limit ?? 20;
+  const all = await Promise.all(sources.map((s) => searchSource(s, query, opts.noCache)));
+  const flat = all.flat();
+  const deduped = deduplicate(flat);
+  const typeOrder = {
+    "mcp-registry": 0,
+    "awesome-list": 1,
+    "npm-search": 2,
+    "github-topic": 3
+  };
+  const sourceTypeMap = new Map(sources.map((s) => [s.id, s.type]));
+  deduped.sort((a, b) => {
+    const aType = a.sourceId ? sourceTypeMap.get(a.sourceId) ?? "" : a.source;
+    const bType = b.sourceId ? sourceTypeMap.get(b.sourceId) ?? "" : b.source;
+    const ao = typeOrder[aType] ?? 99;
+    const bo = typeOrder[bType] ?? 99;
+    if (ao !== bo)
+      return ao - bo;
+    return (b.stars ?? 0) - (a.stars ?? 0);
+  });
+  return deduped.slice(0, limit * Math.max(sources.length, 1));
+}
+var CACHE_DIR, DEFAULT_TTL_MS;
+var init_sources = __esm(() => {
+  init_db();
+  init_config();
+  CACHE_DIR = join2(MCPS_DIR, "cache");
+  DEFAULT_TTL_MS = 10 * 60 * 1000;
+});
 
 // src/lib/registry.ts
+init_db();
 function parseRow(row) {
   return {
     id: row.id,
     name: row.name,
     description: row.description || null,
     command: row.command,
-    args: JSON.parse(row.args),
-    env: JSON.parse(row.env),
+    args: safeJsonParse(row.args, []),
+    env: safeJsonParse(row.env, {}),
     transport: row.transport,
     url: row.url || null,
     source: row.source,
     enabled: row.enabled === 1,
     created_at: row.created_at,
-    updated_at: row.updated_at
+    updated_at: row.updated_at,
+    last_connected_at: row.last_connected_at ?? null,
+    last_error: row.last_error ?? null
   };
 }
+function safeJsonParse(value, fallback) {
+  if (typeof value !== "string")
+    return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
 function generateId(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
+function normalizeCandidate(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function pickNameFromArgs(args) {
+  if (!args || args.length === 0)
+    return;
+  const ddIndex = args.indexOf("--");
+  if (ddIndex >= 0 && ddIndex < args.length - 1) {
+    const after = normalizeCandidate(args[ddIndex + 1]);
+    if (after)
+      return after;
+  }
+  for (const arg of args) {
+    const candidate = normalizeCandidate(arg);
+    if (!candidate)
+      continue;
+    if (candidate.startsWith("-"))
+      continue;
+    return candidate;
+  }
+  return;
+}
+function pickId(candidates) {
+  for (const candidate of candidates) {
+    if (!candidate)
+      continue;
+    const id = generateId(candidate);
+    if (id)
+      return id;
+  }
+  return null;
+}
 function addServer(opts) {
   const db2 = getDb();
-  const name = opts.name || opts.args?.[0] || opts.command;
-  const id = generateId(name);
+  const command = normalizeCandidate(opts.command);
+  if (!command) {
+    throw new Error("Command is required");
+  }
+  const argName = pickNameFromArgs(opts.args);
+  const name = normalizeCandidate(opts.name) || argName || command;
+  const id = pickId([normalizeCandidate(opts.name), argName, command]) || null;
+  if (!id) {
+    throw new Error("Unable to generate a valid server ID");
+  }
   const row = db2.prepare(`INSERT INTO servers (id, name, description, command, args, env, transport, url, source)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-       RETURNING *`).get(id, name, opts.description || null, opts.command, JSON.stringify(opts.args || []), JSON.stringify(opts.env || {}), opts.transport || "stdio", opts.url || null, opts.source || "local");
+       RETURNING *`).get(id, name, opts.description || null, command, JSON.stringify(opts.args || []), JSON.stringify(opts.env || {}), opts.transport || "stdio", opts.url || null, opts.source || "local");
   return parseRow(row);
 }
 function removeServer(id) {
@@ -7096,6 +7474,9 @@ function updateServer(id, updates) {
   sets.push("updated_at = datetime('now')");
   values.push(id);
   const row = db2.prepare(`UPDATE servers SET ${sets.join(", ")} WHERE id = ? RETURNING *`).get(...values);
+  if (!row) {
+    throw new Error(`Server "${id}" not found`);
+  }
   return parseRow(row);
 }
 function enableServer(id) {
@@ -7104,74 +7485,55 @@ function enableServer(id) {
 function disableServer(id) {
   return updateServer(id, { enabled: false });
 }
+function setServerEnv(id, key, value) {
+  const db2 = getDb();
+  const server = getServer(id);
+  if (!server)
+    throw new Error(`Server "${id}" not found`);
+  const env = { ...server.env, [key]: value };
+  db2.prepare("UPDATE servers SET env = ?, updated_at = datetime('now') WHERE id = ?").run(JSON.stringify(env), id);
+}
+function unsetServerEnv(id, key) {
+  const db2 = getDb();
+  const server = getServer(id);
+  if (!server)
+    throw new Error(`Server "${id}" not found`);
+  const env = { ...server.env };
+  delete env[key];
+  db2.prepare("UPDATE servers SET env = ?, updated_at = datetime('now') WHERE id = ?").run(JSON.stringify(env), id);
+}
 function cacheTools(serverId, tools) {
   const db2 = getDb();
-  db2.prepare("DELETE FROM tool_cache WHERE server_id = ?").run(serverId);
   const insert = db2.prepare("INSERT INTO tool_cache (server_id, name, description, input_schema) VALUES (?, ?, ?, ?)");
+  const uniqueTools = [];
+  const seen = new Set;
   for (const tool of tools) {
-    insert.run(serverId, tool.name, tool.description, JSON.stringify(tool.input_schema));
-  }
-}
-// src/lib/remote.ts
-function parseRegistryEntry(entry) {
-  const s = entry.server;
-  return {
-    id: s.name,
-    name: s.name,
-    description: s.description || "",
-    repository: s.repository,
-    packages: s.packages || []
-  };
-}
-async function searchRegistry(query) {
-  const res = await fetch(REGISTRY_API_URL);
-  if (!res.ok) {
-    throw new Error(`Registry API error: ${res.status} ${res.statusText}`);
-  }
-  const data = await res.json();
-  const entries = data.servers || [];
-  const q = query.toLowerCase();
-  return entries.map(parseRegistryEntry).filter((s) => s.name.toLowerCase().includes(q) || s.description?.toLowerCase().includes(q) || s.id.toLowerCase().includes(q));
-}
-async function getRegistryServer(id) {
-  const res = await fetch(REGISTRY_API_URL);
-  if (!res.ok) {
-    throw new Error(`Registry API error: ${res.status} ${res.statusText}`);
-  }
-  const data = await res.json();
-  const entries = data.servers || [];
-  const all = entries.map(parseRegistryEntry);
-  return all.find((s) => s.id === id) || null;
-}
-async function installFromRegistry(id) {
-  const server = await getRegistryServer(id);
-  if (!server) {
-    throw new Error(`Server "${id}" not found in registry`);
+    const name = tool.name?.trim();
+    if (!name || seen.has(name))
+      continue;
+    seen.add(name);
+    uniqueTools.push({
+      name,
+      description: tool.description || "",
+      input_schema: tool.input_schema || {}
+    });
   }
-  const pkg = server.packages?.[0];
-  let command = "npx";
-  let args = [];
-  let transport = "stdio";
-  if (pkg) {
-    if (pkg.registryType === "npm") {
-      command = "npx";
-      args = ["-y", pkg.identifier];
-    } else {
-      command = pkg.identifier;
-    }
-    if (pkg.transport?.type) {
-      transport = pkg.transport.type;
+  const run = db2.transaction((rows) => {
+    db2.prepare("DELETE FROM tool_cache WHERE server_id = ?").run(serverId);
+    for (const tool of rows) {
+      insert.run(serverId, tool.name, tool.description, JSON.stringify(tool.input_schema));
     }
-  }
-  return addServer({
-    name: server.name,
-    description: server.description,
-    command,
-    args,
-    transport,
-    source: "registry"
   });
+  run(uniqueTools);
 }
+function getToolCounts() {
+  const db2 = getDb();
+  const rows = db2.prepare("SELECT server_id, COUNT(*) as count FROM tool_cache GROUP BY server_id").all();
+  return new Map(rows.map((row) => [row.server_id, Number(row.count)]));
+}
+// src/lib/doctor.ts
+import { execFileSync } from "child_process";
+
 // node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({
   status: "aborted"
@@ -15284,54 +15646,126 @@ class StreamableHTTPClientTransport {
 }
 
 // src/lib/proxy.ts
+init_config();
+init_db();
 var connections = new Map;
+var inflightConnections = new Map;
+function buildEnv(extra) {
+  const merged = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string")
+      merged[key] = value;
+  }
+  for (const [key, value] of Object.entries(extra || {})) {
+    if (value === undefined || value === null)
+      continue;
+    merged[key] = String(value);
+  }
+  return merged;
+}
+function requireUrl(entry) {
+  if (!entry.url) {
+    throw new Error(`Server "${entry.id}" is missing a URL for ${entry.transport} transport`);
+  }
+  try {
+    return new URL(entry.url);
+  } catch {
+    throw new Error(`Server "${entry.id}" has an invalid URL: ${entry.url}`);
+  }
+}
 async function connectToServer(entry) {
   if (connections.has(entry.id)) {
     return connections.get(entry.id);
   }
+  const inflight = inflightConnections.get(entry.id);
+  if (inflight) {
+    return inflight;
+  }
   const client = new Client({ name: "mcps-proxy", version: "0.0.1" });
   let transport;
-  if (entry.transport === "stdio") {
-    transport = new StdioClientTransport({
-      command: entry.command,
-      args: entry.args,
-      env: { ...process.env, ...entry.env }
-    });
-  } else if (entry.transport === "sse") {
-    transport = new SSEClientTransport(new URL(entry.url));
-  } else {
-    transport = new StreamableHTTPClientTransport(new URL(entry.url));
-  }
-  await client.connect(transport);
-  const result = await client.listTools();
-  const tools = (result.tools || []).map((t) => ({
-    server_id: entry.id,
-    name: t.name,
-    description: t.description || "",
-    input_schema: t.inputSchema || {}
-  }));
-  cacheTools(entry.id, tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.input_schema })));
-  const connected = {
-    entry,
-    tools,
-    disconnect: async () => {
-      await client.close();
-      connections.delete(entry.id);
+  const connectPromise = (async () => {
+    try {
+      if (entry.transport === "stdio") {
+        if (!entry.command?.trim()) {
+          throw new Error(`Server "${entry.id}" is missing a command`);
+        }
+        transport = new StdioClientTransport({
+          command: entry.command,
+          args: entry.args,
+          env: buildEnv(entry.env)
+        });
+      } else if (entry.transport === "sse") {
+        transport = new SSEClientTransport(requireUrl(entry));
+      } else {
+        transport = new StreamableHTTPClientTransport(requireUrl(entry));
+      }
+      await client.connect(transport);
+      const result = await client.listTools();
+      const tools = (result.tools || []).map((t) => ({
+        server_id: entry.id,
+        name: t.name,
+        description: t.description || "",
+        input_schema: t.inputSchema || {}
+      }));
+      cacheTools(entry.id, tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.input_schema })));
+      const connected = {
+        entry,
+        tools,
+        disconnect: async () => {
+          try {
+            await client.close();
+          } finally {
+            connections.delete(entry.id);
+          }
+        }
+      };
+      connected._client = client;
+      connections.set(entry.id, connected);
+      try {
+        getDb().prepare("UPDATE servers SET last_connected_at = datetime('now'), last_error = NULL WHERE id = ?").run(entry.id);
+      } catch {}
+      return connected;
+    } catch (err) {
+      try {
+        getDb().prepare("UPDATE servers SET last_error = ? WHERE id = ?").run(err.message, entry.id);
+      } catch {}
+      try {
+        await client.close();
+      } catch {}
+      throw err;
     }
-  };
-  connected._client = client;
-  connections.set(entry.id, connected);
-  return connected;
+  })();
+  inflightConnections.set(entry.id, connectPromise);
+  try {
+    return await connectPromise;
+  } finally {
+    inflightConnections.delete(entry.id);
+  }
 }
 async function disconnectServer(id) {
   const conn = connections.get(id);
   if (conn) {
     await conn.disconnect();
+    return;
+  }
+  const inflight = inflightConnections.get(id);
+  if (inflight) {
+    try {
+      const pending = await inflight;
+      await pending.disconnect();
+    } catch {}
   }
 }
 async function disconnectAll() {
   const ids = Array.from(connections.keys());
-  await Promise.all(ids.map((id) => disconnectServer(id)));
+  await Promise.allSettled(ids.map((id) => disconnectServer(id)));
+  const inflight = Array.from(inflightConnections.values());
+  await Promise.allSettled(inflight.map(async (promise2) => {
+    try {
+      const conn = await promise2;
+      await conn.disconnect();
+    } catch {}
+  }));
 }
 function listAllTools() {
   const tools = [];
@@ -15346,12 +15780,19 @@ function listAllTools() {
   return tools;
 }
 async function callTool(prefixedName, args) {
-  const sepIdx = prefixedName.indexOf(TOOL_PREFIX_SEPARATOR);
+  const normalized = prefixedName.trim();
+  if (!normalized) {
+    throw new Error("Tool name is required");
+  }
+  const sepIdx = normalized.indexOf(TOOL_PREFIX_SEPARATOR);
   if (sepIdx === -1) {
     throw new Error(`Invalid tool name "${prefixedName}" \u2014 expected format: server_id${TOOL_PREFIX_SEPARATOR}tool_name`);
   }
-  const serverId = prefixedName.slice(0, sepIdx);
-  const toolName = prefixedName.slice(sepIdx + TOOL_PREFIX_SEPARATOR.length);
+  const serverId = normalized.slice(0, sepIdx).trim();
+  const toolName = normalized.slice(sepIdx + TOOL_PREFIX_SEPARATOR.length).trim();
+  if (!serverId || !toolName) {
+    throw new Error(`Invalid tool name "${prefixedName}" \u2014 expected format: server_id${TOOL_PREFIX_SEPARATOR}tool_name`);
+  }
   const conn = connections.get(serverId);
   if (!conn) {
     throw new Error(`Server "${serverId}" is not connected`);
@@ -15381,23 +15822,243 @@ async function refreshTools(id) {
   cacheTools(id, tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.input_schema })));
   return tools;
 }
+
+// src/lib/doctor.ts
+async function diagnoseServer(server) {
+  const checks3 = [];
+  if (server.transport === "stdio") {
+    try {
+      execFileSync("which", [server.command], { stdio: "pipe" });
+      checks3.push({ name: "command on PATH", pass: true, message: `${server.command} found` });
+    } catch {
+      checks3.push({ name: "command on PATH", pass: false, message: `${server.command} not found on PATH` });
+    }
+  }
+  const missingEnv = Object.entries(server.env).filter(([, v]) => !v);
+  if (Object.keys(server.env).length === 0) {
+    checks3.push({ name: "env vars", pass: true, message: "no env vars required" });
+  } else if (missingEnv.length > 0) {
+    checks3.push({ name: "env vars", pass: false, message: `missing values for: ${missingEnv.map(([k]) => k).join(", ")}` });
+  } else {
+    checks3.push({ name: "env vars", pass: true, message: `${Object.keys(server.env).length} env var(s) set` });
+  }
+  if (server.transport !== "stdio" && server.url) {
+    try {
+      const res = await fetch(server.url, { signal: AbortSignal.timeout(5000) });
+      checks3.push({ name: "URL reachable", pass: res.ok || res.status < 500, message: `HTTP ${res.status}` });
+    } catch (err) {
+      checks3.push({ name: "URL reachable", pass: false, message: `unreachable: ${err.message}` });
+    }
+  }
+  if (server.enabled) {
+    try {
+      await Promise.race([
+        connectToServer(server),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("timeout after 10s")), 1e4))
+      ]);
+      await disconnectServer(server.id);
+      checks3.push({ name: "connect & list tools", pass: true, message: "connected successfully" });
+    } catch (err) {
+      checks3.push({ name: "connect & list tools", pass: false, message: err.message });
+    }
+  } else {
+    checks3.push({ name: "connect & list tools", pass: true, message: "skipped (server disabled)" });
+  }
+  return {
+    server,
+    checks: checks3,
+    healthy: checks3.every((c) => c.pass)
+  };
+}
+// src/lib/remote.ts
+init_config();
+function parseRegistryEntry(entry) {
+  const s = entry.server;
+  return {
+    id: s.name,
+    name: s.name,
+    description: s.description || "",
+    repository: s.repository,
+    packages: s.packages || []
+  };
+}
+async function searchRegistry(query) {
+  const res = await fetch(REGISTRY_API_URL);
+  if (!res.ok) {
+    throw new Error(`Registry API error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  const entries = data.servers || [];
+  const q = query.toLowerCase();
+  return entries.map(parseRegistryEntry).filter((s) => s.name.toLowerCase().includes(q) || s.description?.toLowerCase().includes(q) || s.id.toLowerCase().includes(q));
+}
+async function getRegistryServer(id) {
+  const res = await fetch(REGISTRY_API_URL);
+  if (!res.ok) {
+    throw new Error(`Registry API error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  const entries = data.servers || [];
+  const all = entries.map(parseRegistryEntry);
+  return all.find((s) => s.id === id) || null;
+}
+async function installFromRegistry(id) {
+  const server = await getRegistryServer(id);
+  if (!server) {
+    throw new Error(`Server "${id}" not found in registry`);
+  }
+  const pkg = server.packages?.[0];
+  let command = "npx";
+  let args = [];
+  let transport = "stdio";
+  if (pkg) {
+    if (pkg.registryType === "npm") {
+      command = "npx";
+      args = ["-y", pkg.identifier];
+    } else {
+      command = pkg.identifier;
+    }
+    if (pkg.transport?.type) {
+      transport = pkg.transport.type;
+    }
+  }
+  return addServer({
+    name: server.name,
+    description: server.description,
+    command,
+    args,
+    transport,
+    source: "registry"
+  });
+}
+// src/lib/finder.ts
+init_sources();
+async function listAwesomeServers() {
+  const { listSources: listSources2, searchSource: searchSource2 } = await Promise.resolve().then(() => (init_sources(), exports_sources));
+  const source = listSources2().find((s) => s.type === "awesome-list" && s.enabled);
+  if (!source)
+    return [];
+  return searchSource2(source, "");
+}
+
+// src/index.ts
+init_sources();
+
+// src/lib/install.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+function installToClaude(entry) {
+  try {
+    const args = [
+      "mcp",
+      "add",
+      "--transport",
+      entry.transport,
+      "--scope",
+      "user"
+    ];
+    for (const [k, v] of Object.entries(entry.env)) {
+      args.push("--env", `${k}=${v}`);
+    }
+    args.push(entry.id, "--", entry.command, ...entry.args);
+    execFileSync2("claude", args, { stdio: "pipe" });
+    return { agent: "claude", success: true };
+  } catch (err) {
+    return { agent: "claude", success: false, error: err.message };
+  }
+}
+function installToCodex(entry) {
+  try {
+    const configDir = join3(homedir2(), ".codex");
+    const configPath = join3(configDir, "config.toml");
+    if (!existsSync2(configDir)) {
+      mkdirSync3(configDir, { recursive: true });
+    }
+    const block = `
+[mcp_servers.${entry.id}]
+` + `command = ${JSON.stringify(entry.command)}
+` + `args = [${entry.args.map((a) => JSON.stringify(a)).join(", ")}]
+`;
+    const existing = existsSync2(configPath) ? readFileSync2(configPath, "utf-8") : "";
+    if (existing.includes(`[mcp_servers.${entry.id}]`)) {
+      return { agent: "codex", success: true };
+    }
+    writeFileSync2(configPath, existing + block, "utf-8");
+    return { agent: "codex", success: true };
+  } catch (err) {
+    return { agent: "codex", success: false, error: err.message };
+  }
+}
+function installToGemini(entry) {
+  try {
+    const configDir = join3(homedir2(), ".gemini");
+    const configPath = join3(configDir, "settings.json");
+    if (!existsSync2(configDir)) {
+      mkdirSync3(configDir, { recursive: true });
+    }
+    let settings = {};
+    if (existsSync2(configPath)) {
+      settings = JSON.parse(readFileSync2(configPath, "utf-8"));
+    }
+    if (!settings.mcpServers)
+      settings.mcpServers = {};
+    settings.mcpServers[entry.id] = {
+      command: entry.command,
+      args: entry.args,
+      ...Object.keys(entry.env).length > 0 ? { env: entry.env } : {}
+    };
+    writeFileSync2(configPath, JSON.stringify(settings, null, 2), "utf-8");
+    return { agent: "gemini", success: true };
+  } catch (err) {
+    return { agent: "gemini", success: false, error: err.message };
+  }
+}
+function installToAgents(entry, targets = ["claude", "codex", "gemini"]) {
+  return targets.map((target) => {
+    if (target === "claude")
+      return installToClaude(entry);
+    if (target === "codex")
+      return installToCodex(entry);
+    if (target === "gemini")
+      return installToGemini(entry);
+    return { agent: target, success: false, error: "Unknown target" };
+  });
+}
+
+// src/index.ts
+init_db();
 export {
   updateServer,
+  unsetServerEnv,
+  setServerEnv,
   searchRegistry,
+  removeSource,
   removeServer,
   refreshTools,
+  listSources,
   listServers,
+  listAwesomeServers,
   listAllTools,
+  installToAgents,
   installFromRegistry,
+  getToolCounts,
+  getSource,
   getServer,
   getRegistryServer,
   getDb,
+  findServers,
+  enableSource,
   enableServer,
   disconnectServer,
   disconnectAll,
+  disableSource,
   disableServer,
+  diagnoseServer,
   connectToServer,
   closeDb,
   callTool,
+  addSource,
   addServer
 };