@hasna/mcps 0.0.2 → 0.0.4

package/bin/mcp.js

@@ -25,6 +25,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // node_modules/ajv/dist/compile/codegen/code.js
@@ -6286,7 +6287,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;
@@ -6499,6 +6500,383 @@ var require_dist = __commonJS((exports, module) => {
   exports.default = formatsPlugin;
 });
 
+// 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;
+}
+var db = null;
+var init_db = __esm(() => {
+  init_config();
+});
+
+// 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 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;
+});
+
 // node_modules/isexe/windows.js
 var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
@@ -20023,86 +20401,91 @@ class StdioServerTransport {
   }
 }
 
-// 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/mcp/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
 
 // 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) {
@@ -20158,6 +20541,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) {
@@ -20168,14 +20554,40 @@ function disableServer(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));
+    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 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));
+    }
+  });
+  run(uniqueTools);
+}
+function getCachedTools(serverId) {
+  const db2 = getDb();
+  const rows = db2.prepare("SELECT name, description, input_schema FROM tool_cache WHERE server_id = ? ORDER BY name").all(serverId);
+  return rows.map((r) => ({
+    name: r.name,
+    description: r.description,
+    input_schema: safeJsonParse(r.input_schema, {})
+  }));
 }
 
 // src/lib/remote.ts
+init_config();
 function parseRegistryEntry(entry) {
   const s = entry.server;
   return {
@@ -20236,6 +20648,102 @@ async function installFromRegistry(id) {
   });
 }
 
+// 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/mcp/index.ts
+init_sources();
+
+// src/lib/install.ts
+import { execFileSync } 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);
+    execFileSync("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" };
+  });
+}
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
 class ExperimentalClientTasks {
   constructor(_client) {
@@ -22613,44 +23121,127 @@ class StreamableHTTPClientTransport {
 }
 
 // src/lib/proxy.ts
+init_config();
+init_db();
 var connections = new Map;
+var inflightConnections = new Map;
+var CONNECT_CONCURRENCY = 4;
+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.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 = [];
@@ -22665,12 +23256,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`);
@@ -22686,26 +23284,108 @@ async function callTool(prefixedName, args) {
 async function connectAllEnabled() {
   const servers = listServers().filter((s) => s.enabled);
   const results = [];
-  for (const server of servers) {
+  let index = 0;
+  const workerCount = Math.min(CONNECT_CONCURRENCY, servers.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (true) {
+      const current = index++;
+      if (current >= servers.length)
+        return;
+      const server = servers[current];
+      try {
+        const conn = await connectToServer(server);
+        results.push(conn);
+      } catch (err) {
+        console.error(`Failed to connect to ${server.name}: ${err.message}`);
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+// src/lib/doctor.ts
+import { execFileSync as execFileSync2 } from "child_process";
+async function diagnoseServer(server) {
+  const checks4 = [];
+  if (server.transport === "stdio") {
+    try {
+      const path = execFileSync2("which", [server.command], { stdio: "pipe" }).toString().trim();
+      let version2 = "";
+      try {
+        version2 = execFileSync2(server.command, ["--version"], { stdio: "pipe" }).toString().trim().split(`
+`)[0];
+      } catch {}
+      checks4.push({ name: "command on PATH", pass: true, message: `${path}${version2 ? ` (${version2})` : ""}` });
+    } catch {
+      checks4.push({
+        name: "command on PATH",
+        pass: false,
+        message: `${server.command} not found on PATH`,
+        fixable: true,
+        fixHint: server.args[0] || server.command
+      });
+    }
+  }
+  const missingEnv = Object.entries(server.env).filter(([, v]) => !v);
+  if (Object.keys(server.env).length === 0) {
+    checks4.push({ name: "env vars", pass: true, message: "no env vars required" });
+  } else if (missingEnv.length > 0) {
+    checks4.push({ name: "env vars", pass: false, message: `missing values for: ${missingEnv.map(([k]) => k).join(", ")}` });
+  } else {
+    checks4.push({ name: "env vars", pass: true, message: `${Object.keys(server.env).length} env var(s) set` });
+  }
+  if (server.transport !== "stdio" && server.url) {
     try {
-      const conn = await connectToServer(server);
-      results.push(conn);
+      const res = await fetch(server.url, { signal: AbortSignal.timeout(5000) });
+      checks4.push({ name: "URL reachable", pass: res.ok || res.status < 500, message: `HTTP ${res.status}` });
     } catch (err) {
-      console.error(`Failed to connect to ${server.name}: ${err.message}`);
+      checks4.push({ name: "URL reachable", pass: false, message: `unreachable: ${err.message}` });
     }
   }
-  return results;
+  if (server.enabled) {
+    try {
+      await Promise.race([
+        connectToServer(server),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("timeout after 10s")), 1e4))
+      ]);
+      await disconnectServer(server.id);
+      checks4.push({ name: "connect & list tools", pass: true, message: "connected successfully" });
+    } catch (err) {
+      checks4.push({ name: "connect & list tools", pass: false, message: err.message });
+    }
+  } else {
+    checks4.push({ name: "connect & list tools", pass: true, message: "skipped (server disabled)" });
+  }
+  return {
+    server,
+    checks: checks4,
+    healthy: checks4.every((c) => c.pass)
+  };
 }
 
 // src/mcp/index.ts
+init_config();
+function redactServerEnv(server) {
+  return { ...server, env: {} };
+}
+var VERSION = (() => {
+  try {
+    const pkgPath = join4(dirname2(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    return pkg.version || "0.0.1";
+  } catch {
+    return "0.0.1";
+  }
+})();
 var server = new McpServer({
   name: "mcps",
-  version: "0.0.1"
+  version: VERSION
 });
 server.tool("list_servers", "List all registered MCP servers", {}, async () => {
   const servers = listServers();
   return {
-    content: [{ type: "text", text: JSON.stringify(servers, null, 2) }]
+    content: [{ type: "text", text: JSON.stringify(servers.map(redactServerEnv), null, 2) }]
   };
 });
 server.tool("search_registry", "Search the official MCP registry for servers", { query: exports_external.string().describe("Search query") }, async ({ query }) => {
@@ -22756,17 +23436,84 @@ server.tool("remove_server", "Remove a registered MCP server", { id: exports_ext
   };
 });
 server.tool("enable_server", "Enable a registered MCP server", { id: exports_external.string().describe("Server ID to enable") }, async ({ id }) => {
+  const existing = getServer(id);
+  if (!existing) {
+    return {
+      content: [{ type: "text", text: `Server "${id}" not found.` }],
+      isError: true
+    };
+  }
   const entry = enableServer(id);
   return {
     content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
   };
 });
 server.tool("disable_server", "Disable a registered MCP server", { id: exports_external.string().describe("Server ID to disable") }, async ({ id }) => {
+  const existing = getServer(id);
+  if (!existing) {
+    return {
+      content: [{ type: "text", text: `Server "${id}" not found.` }],
+      isError: true
+    };
+  }
   const entry = disableServer(id);
   return {
     content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
   };
 });
+server.tool("update_server", "Update fields of a registered MCP server", {
+  id: exports_external.string().describe("Server ID to update"),
+  name: exports_external.string().optional().describe("New display name"),
+  description: exports_external.string().optional().describe("New description"),
+  command: exports_external.string().optional().describe("New command"),
+  args: exports_external.array(exports_external.string()).optional().describe("New args list"),
+  transport: exports_external.enum(["stdio", "sse", "streamable-http"]).optional().describe("New transport type"),
+  url: exports_external.string().optional().describe("New URL for remote transports")
+}, async ({ id, name, description, command, args, transport, url: url2 }) => {
+  const existing = getServer(id);
+  if (!existing) {
+    return {
+      content: [{ type: "text", text: `Server "${id}" not found.` }],
+      isError: true
+    };
+  }
+  const fields = {};
+  if (name !== undefined)
+    fields.name = name;
+  if (description !== undefined)
+    fields.description = description;
+  if (command !== undefined)
+    fields.command = command;
+  if (args !== undefined)
+    fields.args = args;
+  if (transport !== undefined)
+    fields.transport = transport;
+  if (url2 !== undefined)
+    fields.url = url2;
+  const updated = updateServer(id, fields);
+  return {
+    content: [{ type: "text", text: JSON.stringify(redactServerEnv(updated), null, 2) }]
+  };
+});
+server.tool("list_tools", "List all cached tools across registered servers without connecting. Optionally filter by server_id.", { server_id: exports_external.string().optional().describe("Server ID to filter by (optional)") }, async ({ server_id }) => {
+  if (server_id) {
+    const tools = getCachedTools(server_id);
+    return {
+      content: [{ type: "text", text: JSON.stringify(tools.map((t) => ({ ...t, server_id })), null, 2) }]
+    };
+  }
+  const servers = listServers();
+  const allTools = [];
+  for (const s of servers) {
+    const tools = getCachedTools(s.id);
+    for (const t of tools) {
+      allTools.push({ server_id: s.id, ...t });
+    }
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(allTools, null, 2) }]
+  };
+});
 server.tool("get_server_info", "Get detailed information about a registered MCP server", { id: exports_external.string().describe("Server ID") }, async ({ id }) => {
   const entry = getServer(id);
   if (!entry) {
@@ -22776,12 +23523,108 @@ server.tool("get_server_info", "Get detailed information about a registered MCP
     };
   }
   return {
-    content: [{ type: "text", text: JSON.stringify(entry, null, 2) }]
+    content: [{ type: "text", text: JSON.stringify(redactServerEnv(entry), null, 2) }]
+  };
+});
+server.tool("find_mcp_servers", "Search for MCP servers across configured sources (official registry, npm, GitHub topics, awesome lists). Use list_sources to see available source IDs.", {
+  query: exports_external.string().describe("Search query (e.g. 'filesystem', 'postgres', 'browser')"),
+  sources: exports_external.array(exports_external.string()).optional().describe("Source IDs to search (default: all enabled). Use list_sources to get IDs."),
+  limit: exports_external.number().optional().describe("Max results per source (default: 20)")
+}, async ({ query, sources, limit }) => {
+  const results = await findServers(query, { sources, limit });
+  return {
+    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+  };
+});
+server.tool("list_sources", "List all configured search sources for finding MCP servers", {}, async () => {
+  const sources = listSources();
+  return {
+    content: [{ type: "text", text: JSON.stringify(sources, null, 2) }]
+  };
+});
+server.tool("add_source", "Add a new search source for finding MCP servers", {
+  name: exports_external.string().describe("Source name"),
+  type: exports_external.enum(["mcp-registry", "awesome-list", "npm-search", "github-topic"]).describe("Source type"),
+  url: exports_external.string().describe("Source URL endpoint"),
+  description: exports_external.string().optional().describe("Description")
+}, async ({ name, type, url: url2, description }) => {
+  const source = addSource({ name, type, url: url2, description });
+  return {
+    content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
+  };
+});
+server.tool("remove_source", "Remove a search source by ID", { id: exports_external.string().describe("Source ID to remove") }, async ({ id }) => {
+  const existing = getSource(id);
+  if (!existing) {
+    return {
+      content: [{ type: "text", text: `Source "${id}" not found.` }],
+      isError: true
+    };
+  }
+  removeSource(id);
+  return {
+    content: [{ type: "text", text: `Removed source: ${existing.name} [${id}]` }]
+  };
+});
+server.tool("enable_source_finder", "Enable a search source", { id: exports_external.string().describe("Source ID to enable") }, async ({ id }) => {
+  const existing = getSource(id);
+  if (!existing) {
+    return {
+      content: [{ type: "text", text: `Source "${id}" not found.` }],
+      isError: true
+    };
+  }
+  enableSource(id);
+  return {
+    content: [{ type: "text", text: `Enabled source: ${existing.name}` }]
+  };
+});
+server.tool("disable_source_finder", "Disable a search source", { id: exports_external.string().describe("Source ID to disable") }, async ({ id }) => {
+  const existing = getSource(id);
+  if (!existing) {
+    return {
+      content: [{ type: "text", text: `Source "${id}" not found.` }],
+      isError: true
+    };
+  }
+  disableSource(id);
+  return {
+    content: [{ type: "text", text: `Disabled source: ${existing.name}` }]
+  };
+});
+server.tool("install_to_agents", "Install a registered MCP server into Claude Code, Codex, and/or Gemini", {
+  id: exports_external.string().describe("Server ID to install (from list_servers)"),
+  targets: exports_external.array(exports_external.enum(["claude", "codex", "gemini"])).optional().describe("Target agents to install into (default: all)")
+}, async ({ id, targets }) => {
+  const entry = getServer(id);
+  if (!entry) {
+    return {
+      content: [{ type: "text", text: `Server "${id}" not found.` }],
+      isError: true
+    };
+  }
+  const agentTargets = targets ?? ["claude", "codex", "gemini"];
+  const results = installToAgents(entry, agentTargets);
+  return {
+    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+  };
+});
+server.tool("list_awesome_servers", "List all MCP servers from the curated punkpeye/awesome-mcp-servers GitHub list", {}, async () => {
+  const results = await listAwesomeServers();
+  return {
+    content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
   };
 });
 server.tool("connect_and_list_tools", "Connect to all enabled MCP servers and list their available tools", {}, async () => {
-  await connectAllEnabled();
-  const tools = listAllTools();
+  let tools = [];
+  try {
+    await connectAllEnabled();
+    tools = listAllTools();
+  } finally {
+    await disconnectAll().catch(() => {
+      return;
+    });
+  }
   return {
     content: [{ type: "text", text: JSON.stringify(tools, null, 2) }]
   };
@@ -22791,6 +23634,28 @@ server.tool("call_upstream_tool", `Call a tool on a connected upstream MCP serve
   arguments: exports_external.record(exports_external.unknown()).optional().describe("Tool arguments as key-value pairs")
 }, async ({ tool_name, arguments: args }) => {
   try {
+    const sepIdx = tool_name.indexOf(TOOL_PREFIX_SEPARATOR);
+    if (sepIdx === -1) {
+      return {
+        content: [{ type: "text", text: `Error: Invalid tool name "${tool_name}"` }],
+        isError: true
+      };
+    }
+    const serverId = tool_name.slice(0, sepIdx);
+    const entry = getServer(serverId);
+    if (!entry) {
+      return {
+        content: [{ type: "text", text: `Error: Server "${serverId}" not found.` }],
+        isError: true
+      };
+    }
+    if (!entry.enabled) {
+      return {
+        content: [{ type: "text", text: `Error: Server "${serverId}" is disabled.` }],
+        isError: true
+      };
+    }
+    await connectToServer(entry);
     const result = await callTool(tool_name, args || {});
     return { content: result.content };
   } catch (err) {
@@ -22800,6 +23665,13 @@ server.tool("call_upstream_tool", `Call a tool on a connected upstream MCP serve
     };
   }
 });
+server.tool("diagnose_server", "Run health checks on a registered MCP server", { id: exports_external.string().describe("Server ID") }, async ({ id }) => {
+  const entry = getServer(id);
+  if (!entry)
+    return { content: [{ type: "text", text: `Server "${id}" not found.` }], isError: true };
+  const report = await diagnoseServer(entry);
+  return { content: [{ type: "text", text: JSON.stringify(report, null, 2) }] };
+});
 async function startMcpServer() {
   const transport = new StdioServerTransport;
   await server.connect(transport);