@hasna/mcps 0.0.2 → 0.0.4

package/bin/index.js

@@ -26,6 +26,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/commander/lib/error.js
@@ -1867,6 +1868,94 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
+// 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 });
@@ -8126,7 +8215,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;
@@ -8795,6 +8884,361 @@ var require_cross_spawn = __commonJS((exports, module) => {
   module.exports._enoent = enoent;
 });
 
+// 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;
+});
+
+// package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "@hasna/mcps",
+    version: "0.0.4",
+    description: "Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers",
+    type: "module",
+    main: "dist/index.js",
+    types: "dist/index.d.ts",
+    exports: {
+      ".": {
+        import: "./dist/index.js",
+        types: "./dist/index.d.ts"
+      }
+    },
+    bin: {
+      mcps: "bin/index.js",
+      "mcps-mcp": "bin/mcp.js"
+    },
+    files: [
+      "dist/",
+      "bin/",
+      "dashboard/dist/",
+      "LICENSE",
+      "README.md"
+    ],
+    scripts: {
+      build: "bun run build:dashboard && bun build ./src/cli/index.tsx --outdir ./bin --target bun --external ink --external react --external chalk && bun build ./src/mcp/index.ts --outfile ./bin/mcp.js --target bun && bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist",
+      "build:dashboard": "cd dashboard && bun install && bun run build",
+      dev: "bun run src/cli/index.tsx",
+      "dev:mcp": "bun run src/mcp/index.ts",
+      "dev:dashboard": "cd dashboard && bun run dev",
+      serve: "bun run src/cli/index.tsx serve",
+      test: "bun test",
+      typecheck: "tsc --noEmit",
+      prepublishOnly: "bun run build"
+    },
+    dependencies: {
+      "@modelcontextprotocol/sdk": "^1.26.0",
+      chalk: "^5.3.0",
+      commander: "^12.1.0",
+      ink: "^5.0.1",
+      "ink-select-input": "^6.0.0",
+      "ink-spinner": "^5.0.0",
+      "ink-text-input": "^6.0.0",
+      react: "^18.2.0",
+      zod: "^3.23.0"
+    },
+    devDependencies: {
+      "@types/bun": "latest",
+      "@types/react": "^18.2.0",
+      typescript: "^5"
+    },
+    engines: {
+      bun: ">=1.0.0"
+    },
+    license: "Apache-2.0"
+  };
+});
+
 // node_modules/cli-spinners/spinners.json
 var require_spinners = __commonJS((exports, module) => {
   module.exports = {
@@ -10455,93 +10899,90 @@ var {
 import React10 from "react";
 import { render } from "ink";
 import chalk2 from "chalk";
-
-// 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;
-}
-function closeDb() {
-  if (db) {
-    db.close();
-    db = null;
-  }
-}
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath3 } 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) {
@@ -10597,6 +11038,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) {
@@ -10605,84 +11049,79 @@ 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));
+    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 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)]));
+}
+function cloneServer(id, newName) {
+  const server = getServer(id);
+  if (!server)
+    throw new Error(`Server "${id}" not found`);
+  return addServer({
+    name: newName,
+    description: server.description ?? undefined,
+    command: server.command,
+    args: server.args,
+    env: server.env,
+    transport: server.transport,
+    url: server.url ?? undefined,
+    source: server.source
+  });
 }
 function getCachedTools(serverId) {
   const db2 = getDb();
-  const rows = db2.prepare("SELECT name, description, input_schema FROM tool_cache WHERE server_id = ?").all(serverId);
+  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: JSON.parse(r.input_schema)
+    input_schema: safeJsonParse(r.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 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/doctor.ts
+import { execFileSync } from "child_process";
 
 // node_modules/zod/v3/external.js
 var exports_external = {};
@@ -24909,54 +25348,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.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 = [];
@@ -24971,12 +25483,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`);
@@ -24992,17 +25511,247 @@ 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
+async function diagnoseServer(server) {
+  const checks4 = [];
+  if (server.transport === "stdio") {
+    try {
+      const path = execFileSync("which", [server.command], { stdio: "pipe" }).toString().trim();
+      let version2 = "";
+      try {
+        version2 = execFileSync(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/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/cli/index.tsx
+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/cli/index.tsx
+init_db();
+import * as readline from "readline";
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 class ExperimentalServerTasks {
   constructor(_server) {
@@ -26224,14 +26973,31 @@ class StdioServerTransport {
 }
 
 // src/mcp/index.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+init_sources();
+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 }) => {
@@ -26282,17 +27048,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) {
@@ -26302,12 +27135,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("connect_and_list_tools", "Connect to all enabled MCP servers and list their available tools", {}, async () => {
-  await connectAllEnabled();
-  const tools = listAllTools();
+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 () => {
+  let tools = [];
+  try {
+    await connectAllEnabled();
+    tools = listAllTools();
+  } finally {
+    await disconnectAll().catch(() => {
+      return;
+    });
+  }
   return {
     content: [{ type: "text", text: JSON.stringify(tools, null, 2) }]
   };
@@ -26317,6 +27246,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) {
@@ -26326,6 +27277,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);
@@ -26339,27 +27297,32 @@ if (isDirectRun) {
 }
 
 // src/server/serve.ts
-import { existsSync } from "fs";
-import { join as join2, dirname, extname } from "path";
-import { fileURLToPath } from "url";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5, dirname as dirname3, extname, resolve, relative, sep } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+init_sources();
+init_db();
+function redactServer(server2) {
+  return { ...server2, env: {} };
+}
 function resolveDashboardDir() {
   const candidates = [];
   try {
-    const scriptDir = dirname(fileURLToPath(import.meta.url));
-    candidates.push(join2(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join2(scriptDir, "..", "..", "dashboard", "dist"));
+    const scriptDir = dirname3(fileURLToPath2(import.meta.url));
+    candidates.push(join5(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join5(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
-    const mainDir = dirname(process.argv[1]);
-    candidates.push(join2(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join2(mainDir, "..", "..", "dashboard", "dist"));
+    const mainDir = dirname3(process.argv[1]);
+    candidates.push(join5(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join5(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join2(process.cwd(), "dashboard", "dist"));
+  candidates.push(join5(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync(candidate))
+    if (existsSync3(candidate))
       return candidate;
   }
-  return join2(process.cwd(), "dashboard", "dist");
+  return join5(process.cwd(), "dashboard", "dist");
 }
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
@@ -26375,13 +27338,15 @@ var MIME_TYPES = {
 };
 var SECURITY_HEADERS = {
   "X-Content-Type-Options": "nosniff",
-  "X-Frame-Options": "DENY"
+  "X-Frame-Options": "DENY",
+  "Referrer-Policy": "no-referrer"
 };
 function json(data, status = 200, port) {
   return new Response(JSON.stringify(data), {
     status,
     headers: {
       "Content-Type": "application/json",
+      "Cache-Control": "no-store",
       "Access-Control-Allow-Origin": port ? `http://localhost:${port}` : "*",
       ...SECURITY_HEADERS
     }
@@ -26391,27 +27356,94 @@ function isValidId(id) {
   return /^[a-z0-9-]+$/.test(id);
 }
 var MAX_BODY_SIZE = 1024 * 1024;
+function isLoopbackHost(hostname2) {
+  return hostname2 === "127.0.0.1" || hostname2 === "localhost" || hostname2 === "::1";
+}
+function isAllowedOrigin(req, port, host) {
+  const origin = req.headers.get("origin");
+  if (!origin)
+    return true;
+  if (origin === "null")
+    return false;
+  try {
+    const url2 = new URL(origin);
+    if (url2.port && url2.port !== String(port))
+      return false;
+    if (isLoopbackHost(url2.hostname))
+      return true;
+    const normalizedHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    return url2.hostname === normalizedHost;
+  } catch {
+    return false;
+  }
+}
+function isAuthorized(req, host) {
+  const token = process.env.MCPS_API_TOKEN;
+  if (!token) {
+    return isLoopbackHost(host);
+  }
+  const auth2 = req.headers.get("authorization");
+  if (auth2 === `Bearer ${token}`)
+    return true;
+  return isLoopbackHost(host);
+}
+function unauthorizedResponse(port) {
+  return new Response(JSON.stringify({ error: "Unauthorized" }), {
+    status: 401,
+    headers: {
+      "Content-Type": "application/json",
+      "Cache-Control": "no-store",
+      "Access-Control-Allow-Origin": port ? `http://localhost:${port}` : "*",
+      "WWW-Authenticate": "Bearer",
+      ...SECURITY_HEADERS
+    }
+  });
+}
 function getAllServersWithToolCount() {
   const servers = listServers();
+  if (servers.length === 0)
+    return [];
+  const counts = getToolCounts();
   return servers.map((s) => ({
-    ...s,
-    toolCount: getCachedTools(s.id).length
+    ...redactServer(s),
+    toolCount: counts.get(s.id) ?? 0
   }));
 }
 function serveStaticFile(filePath) {
-  if (!existsSync(filePath))
+  if (!existsSync3(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
   return new Response(Bun.file(filePath), {
-    headers: { "Content-Type": contentType }
+    headers: { "Content-Type": contentType, ...SECURITY_HEADERS }
   });
 }
+function resolveStaticPath(baseDir, urlPath) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(urlPath);
+  } catch {
+    return null;
+  }
+  const stripped = decoded.replace(/^\/+/, "");
+  const resolved = resolve(baseDir, stripped);
+  const rel = relative(baseDir, resolved);
+  if (rel.startsWith("..") || rel.includes(`..${sep}`)) {
+    return null;
+  }
+  return resolved;
+}
+function formatHostForUrl(host) {
+  if (host.includes(":") && !host.startsWith("["))
+    return `[${host}]`;
+  return host;
+}
 async function startServer(port, options) {
   const shouldOpen = options?.open ?? true;
+  const host = options?.host ?? "127.0.0.1";
   getDb();
   const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync(dashboardDir);
+  const dashboardExists = existsSync3(dashboardDir);
   if (!dashboardExists) {
     console.error(`
 Dashboard not found at: ${dashboardDir}`);
@@ -26422,10 +27454,19 @@ Dashboard not found at: ${dashboardDir}`);
   }
   const server2 = Bun.serve({
     port,
+    hostname: host,
     async fetch(req) {
       const url2 = new URL(req.url);
       const path = url2.pathname;
       const method = req.method;
+      if (path.startsWith("/api/") && method !== "OPTIONS") {
+        if (!isAuthorized(req, host)) {
+          return unauthorizedResponse(port);
+        }
+        if (!isAllowedOrigin(req, port, host)) {
+          return json({ error: "Forbidden" }, 403, port);
+        }
+      }
       if (path === "/api/servers" && method === "GET") {
         return json(getAllServersWithToolCount(), 200, port);
       }
@@ -26434,15 +27475,39 @@ Dashboard not found at: ${dashboardDir}`);
           const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
           if (contentLength > MAX_BODY_SIZE)
             return json({ error: "Request body too large" }, 413, port);
-          const body = await req.json();
-          if (!body.command)
+          let body;
+          try {
+            body = await req.json();
+          } catch {
+            return json({ error: "Invalid JSON body" }, 400, port);
+          }
+          const command = body.command?.trim();
+          if (!command)
             return json({ error: "Missing 'command'" }, 400, port);
+          const transport = body.transport || "stdio";
+          if (!["stdio", "sse", "streamable-http"].includes(transport)) {
+            return json({ error: "Invalid transport type" }, 400, port);
+          }
+          if (transport !== "stdio" && !body.url) {
+            return json({ error: "Missing 'url' for non-stdio transport" }, 400, port);
+          }
+          if (body.url) {
+            try {
+              new URL(body.url);
+            } catch {
+              return json({ error: "Invalid 'url' format" }, 400, port);
+            }
+          }
+          if (body.args && (!Array.isArray(body.args) || body.args.some((arg) => typeof arg !== "string"))) {
+            return json({ error: "Invalid 'args' format" }, 400, port);
+          }
+          const args = body.args || [];
           const entry = addServer({
             name: body.name,
-            command: body.command,
-            args: body.args || [],
+            command,
+            args,
             description: body.description,
-            transport: body.transport || "stdio",
+            transport,
             url: body.url
           });
           return json(entry, 200, port);
@@ -26459,7 +27524,7 @@ Dashboard not found at: ${dashboardDir}`);
         if (!entry)
           return json({ error: `Server '${id}' not found` }, 404, port);
         const tools = getCachedTools(id);
-        return json({ ...entry, toolCount: tools.length, tools }, 200, port);
+        return json({ ...redactServer(entry), toolCount: tools.length, tools }, 200, port);
       }
       if (singleMatch && method === "DELETE") {
         const id = singleMatch[1];
@@ -26477,6 +27542,9 @@ Dashboard not found at: ${dashboardDir}`);
         if (!isValidId(id))
           return json({ error: "Invalid server ID" }, 400, port);
         try {
+          const existing = getServer(id);
+          if (!existing)
+            return json({ error: `Server '${id}' not found` }, 404, port);
           enableServer(id);
           return json({ success: true }, 200, port);
         } catch (e) {
@@ -26489,29 +27557,277 @@ Dashboard not found at: ${dashboardDir}`);
         if (!isValidId(id))
           return json({ error: "Invalid server ID" }, 400, port);
         try {
+          const existing = getServer(id);
+          if (!existing)
+            return json({ error: `Server '${id}' not found` }, 404, port);
           disableServer(id);
           return json({ success: true }, 200, port);
         } catch (e) {
           return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
         }
       }
+      if (singleMatch && method === "PATCH") {
+        const id = singleMatch[1];
+        if (!isValidId(id))
+          return json({ error: "Invalid server ID" }, 400, port);
+        const existing = getServer(id);
+        if (!existing)
+          return json({ error: `Server '${id}' not found` }, 404, port);
+        try {
+          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+          if (contentLength > MAX_BODY_SIZE)
+            return json({ error: "Request body too large" }, 413, port);
+          let body;
+          try {
+            body = await req.json();
+          } catch {
+            return json({ error: "Invalid JSON body" }, 400, port);
+          }
+          const fields = {};
+          if (body.name !== undefined)
+            fields.name = body.name;
+          if (body.description !== undefined)
+            fields.description = body.description;
+          if (body.command !== undefined)
+            fields.command = body.command;
+          if (body.transport !== undefined)
+            fields.transport = body.transport;
+          if (body.url !== undefined)
+            fields.url = body.url;
+          if (body.args !== undefined) {
+            if (!Array.isArray(body.args) || body.args.some((a) => typeof a !== "string")) {
+              return json({ error: "Invalid 'args' format" }, 400, port);
+            }
+            fields.args = body.args;
+          }
+          const updated = updateServer(id, fields);
+          return json(redactServer(updated), 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to update server" }, 500, port);
+        }
+      }
+      const serverEnvMatch = path.match(/^\/api\/servers\/([^/]+)\/env$/);
+      if (serverEnvMatch && method === "POST") {
+        const id = serverEnvMatch[1];
+        if (!isValidId(id))
+          return json({ error: "Invalid server ID" }, 400, port);
+        try {
+          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+          if (contentLength > MAX_BODY_SIZE)
+            return json({ error: "Request body too large" }, 413, port);
+          let body;
+          try {
+            body = await req.json();
+          } catch {
+            return json({ error: "Invalid JSON body" }, 400, port);
+          }
+          if (!body.key || typeof body.key !== "string")
+            return json({ error: "Missing 'key'" }, 400, port);
+          if (typeof body.value !== "string")
+            return json({ error: "Missing 'value'" }, 400, port);
+          setServerEnv(id, body.key, body.value);
+          return json({ ok: true }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const serverEnvKeyMatch = path.match(/^\/api\/servers\/([^/]+)\/env\/([^/]+)$/);
+      if (serverEnvKeyMatch && method === "DELETE") {
+        const id = serverEnvKeyMatch[1];
+        const key = decodeURIComponent(serverEnvKeyMatch[2]);
+        if (!isValidId(id))
+          return json({ error: "Invalid server ID" }, 400, port);
+        try {
+          unsetServerEnv(id, key);
+          return json({ ok: true }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const serverToolsMatch = path.match(/^\/api\/servers\/([^/]+)\/tools$/);
+      if (serverToolsMatch && method === "GET") {
+        const id = serverToolsMatch[1];
+        if (!isValidId(id))
+          return json({ error: "Invalid server ID" }, 400, port);
+        const entry = getServer(id);
+        if (!entry)
+          return json({ error: `Server '${id}' not found` }, 404, port);
+        const tools = getCachedTools(id);
+        return json(tools, 200, port);
+      }
+      const serverCallMatch = path.match(/^\/api\/servers\/([^/]+)\/call$/);
+      if (serverCallMatch && method === "POST") {
+        const id = serverCallMatch[1];
+        if (!isValidId(id))
+          return json({ error: "Invalid server ID" }, 400, port);
+        const entry = getServer(id);
+        if (!entry)
+          return json({ error: `Server '${id}' not found` }, 404, port);
+        try {
+          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+          if (contentLength > MAX_BODY_SIZE)
+            return json({ error: "Request body too large" }, 413, port);
+          let body;
+          try {
+            body = await req.json();
+          } catch {
+            return json({ error: "Invalid JSON body" }, 400, port);
+          }
+          if (!body.tool || typeof body.tool !== "string")
+            return json({ error: "Missing 'tool'" }, 400, port);
+          await connectToServer(entry);
+          const toolName = `${id}__${body.tool}`;
+          const result = await callTool(toolName, body.args || {});
+          await disconnectServer(id).catch(() => {
+            return;
+          });
+          return json({ content: result.content }, 200, port);
+        } catch (e) {
+          await disconnectServer(id).catch(() => {
+            return;
+          });
+          return json({ error: e instanceof Error ? e.message : "Failed to call tool" }, 500, port);
+        }
+      }
+      const serverDoctorMatch = path.match(/^\/api\/servers\/([^/]+)\/doctor$/);
+      if (serverDoctorMatch && method === "GET") {
+        const id = serverDoctorMatch[1];
+        if (!isValidId(id))
+          return json({ error: "Invalid server ID" }, 400, port);
+        const entry = getServer(id);
+        if (!entry)
+          return json({ error: `Server '${id}' not found` }, 404, port);
+        try {
+          const report = await diagnoseServer(entry);
+          return json(report, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to diagnose server" }, 500, port);
+        }
+      }
+      if (path === "/api/sources" && method === "GET") {
+        return json(listSources(), 200, port);
+      }
+      if (path === "/api/sources" && method === "POST") {
+        try {
+          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+          if (contentLength > MAX_BODY_SIZE)
+            return json({ error: "Request body too large" }, 413, port);
+          let body;
+          try {
+            body = await req.json();
+          } catch {
+            return json({ error: "Invalid JSON body" }, 400, port);
+          }
+          if (!body.name)
+            return json({ error: "Missing 'name'" }, 400, port);
+          if (!body.type)
+            return json({ error: "Missing 'type'" }, 400, port);
+          if (!body.url)
+            return json({ error: "Missing 'url'" }, 400, port);
+          const source = addSource({
+            name: body.name,
+            type: body.type,
+            url: body.url,
+            description: body.description
+          });
+          return json(source, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed to add source" }, 500, port);
+        }
+      }
+      const singleSourceMatch = path.match(/^\/api\/sources\/([^/]+)$/);
+      if (singleSourceMatch && method === "DELETE") {
+        const id = singleSourceMatch[1];
+        try {
+          removeSource(id);
+          return json({ ok: true }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const sourceEnableMatch = path.match(/^\/api\/sources\/([^/]+)\/enable$/);
+      if (sourceEnableMatch && method === "POST") {
+        const id = sourceEnableMatch[1];
+        try {
+          enableSource(id);
+          return json({ ok: true }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      const sourceDisableMatch = path.match(/^\/api\/sources\/([^/]+)\/disable$/);
+      if (sourceDisableMatch && method === "POST") {
+        const id = sourceDisableMatch[1];
+        try {
+          disableSource(id);
+          return json({ ok: true }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Failed" }, 500, port);
+        }
+      }
+      if (path === "/api/find" && method === "GET") {
+        try {
+          const q = url2.searchParams.get("q") || "";
+          const sourcesParam = url2.searchParams.get("sources");
+          const limitParam = url2.searchParams.get("limit");
+          const sources = sourcesParam ? sourcesParam.split(",").filter(Boolean) : undefined;
+          const limit = limitParam ? parseInt(limitParam, 10) : undefined;
+          const results = await findServers(q, { sources, limit });
+          return json(results, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Find failed" }, 500, port);
+        }
+      }
+      if (path === "/api/update" && method === "POST") {
+        if (!isLoopbackHost(host)) {
+          return json({ error: "Update only allowed on loopback host" }, 403, port);
+        }
+        try {
+          const { execFileSync: execFileSync3 } = await import("child_process");
+          const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+          const currentVersion = pkg.version;
+          const latest = execFileSync3("npm", ["view", "@hasna/mcps", "version"], {
+            encoding: "utf-8"
+          }).trim();
+          if (latest === currentVersion) {
+            return json({ success: true, current: currentVersion, latest, upToDate: true }, 200, port);
+          }
+          execFileSync3("bun", ["install", "-g", "@hasna/mcps@latest"], { stdio: "pipe" });
+          return json({ success: true, current: currentVersion, latest, upToDate: false, updated: true }, 200, port);
+        } catch (e) {
+          return json({ error: e instanceof Error ? e.message : "Update failed" }, 500, port);
+        }
+      }
+      if (path === "/api/version" && method === "GET") {
+        try {
+          const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+          return json({ version: pkg.version }, 200, port);
+        } catch {
+          return json({ version: "unknown" }, 200, port);
+        }
+      }
       if (method === "OPTIONS") {
+        if (!isAllowedOrigin(req, port, host)) {
+          return json({ error: "Forbidden" }, 403, port);
+        }
         return new Response(null, {
           headers: {
             "Access-Control-Allow-Origin": `http://localhost:${port}`,
-            "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+            "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
             "Access-Control-Allow-Headers": "Content-Type"
           }
         });
       }
       if (dashboardExists && (method === "GET" || method === "HEAD")) {
         if (path !== "/") {
-          const filePath = join2(dashboardDir, path);
-          const res2 = serveStaticFile(filePath);
-          if (res2)
-            return res2;
+          const safePath = resolveStaticPath(dashboardDir, path);
+          if (safePath) {
+            const res2 = serveStaticFile(safePath);
+            if (res2)
+              return res2;
+          }
         }
-        const indexPath = join2(dashboardDir, "index.html");
+        const indexPath = join5(dashboardDir, "index.html");
         const res = serveStaticFile(indexPath);
         if (res)
           return res;
@@ -26526,19 +27842,24 @@ Dashboard not found at: ${dashboardDir}`);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  const serverUrl = `http://localhost:${port}`;
+  const displayHost = host === "0.0.0.0" ? "localhost" : host;
+  const serverUrl = `http://${formatHostForUrl(displayHost)}:${port}`;
   console.log(`MCPs Dashboard running at ${serverUrl}`);
   if (shouldOpen) {
     try {
-      const { exec } = await import("child_process");
-      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-      exec(`${openCmd} ${serverUrl}`);
+      const { execFile } = await import("child_process");
+      if (process.platform === "win32") {
+        execFile("cmd", ["/c", "start", "", serverUrl]);
+      } else {
+        const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
+        execFile(openCmd, [serverUrl]);
+      }
     } catch {}
   }
 }
 
 // src/cli/components/App.tsx
-import { useState as useState7 } from "react";
+import { useEffect as useEffect5, useState as useState7 } from "react";
 import { Box as Box7, Text as Text9, useApp, useInput as useInput4 } from "ink";
 
 // src/cli/components/ServerList.tsx
@@ -26951,6 +28272,7 @@ var SelectInput_default = SelectInput;
 import { jsxDEV } from "react/jsx-dev-runtime";
 function ServerList({ onSelect, onSearch }) {
   const servers = listServers();
+  const toolCounts = getToolCounts();
   useInput2((input) => {
     if (input === "s") {
       onSearch();
@@ -26972,10 +28294,9 @@ function ServerList({ onSelect, onSearch }) {
     }, undefined, true, undefined, this);
   }
   const items = servers.map((s) => {
-    const cached2 = getCachedTools(s.id);
+    const cachedCount = toolCounts.get(s.id) ?? 0;
     const status = s.enabled ? "\u25CF" : "\u25CB";
-    const statusColor = s.enabled ? "green" : "red";
-    const toolInfo = cached2.length > 0 ? ` (${cached2.length} tools)` : "";
+    const toolInfo = cachedCount > 0 ? ` (${cachedCount} tools)` : "";
     return {
       label: `${status} ${s.name} [${s.id}]${toolInfo}`,
       value: s.id,
@@ -27033,7 +28354,10 @@ function ServerDetail({ server: server2, onSelectTool, onBack }) {
   const [loading, setLoading] = useState3(false);
   const [error2, setError] = useState3(null);
   const cachedTools = getCachedTools(server2.id);
+  const cachedKey = cachedTools.map((t) => `${t.name}|${t.description}|${JSON.stringify(t.input_schema)}`).join(";");
   useEffect3(() => {
+    setLoading(false);
+    setError(null);
     if (cachedTools.length > 0) {
       setTools(cachedTools.map((t) => ({
         server_id: server2.id,
@@ -27041,8 +28365,10 @@ function ServerDetail({ server: server2, onSelectTool, onBack }) {
         description: t.description,
         input_schema: t.input_schema
       })));
+    } else {
+      setTools([]);
     }
-  }, [server2.id]);
+  }, [server2.id, cachedKey]);
   const handleConnect = async () => {
     setLoading(true);
     setError(null);
@@ -27366,6 +28692,7 @@ function SearchView({ onBack }) {
 // src/cli/components/ToolCall.tsx
 import { useState as useState6 } from "react";
 import { Box as Box6, Text as Text8 } from "ink";
+init_config();
 import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
 function ToolCall({ server: server2, tool, onBack }) {
   const [argsInput, setArgsInput] = useState6("{}");
@@ -27496,6 +28823,7 @@ function ToolCall({ server: server2, tool, onBack }) {
 }
 
 // src/cli/components/App.tsx
+init_db();
 import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
 function App() {
   const { exit } = useApp();
@@ -27503,7 +28831,7 @@ function App() {
   const [selectedServer, setSelectedServer] = useState7(null);
   const [selectedTool, setSelectedTool] = useState7(null);
   useInput4((input, key) => {
-    if (input === "q" && view === "servers") {
+    if (input === "q" && view !== "search" && view !== "call") {
       exit();
     }
     if (key.escape) {
@@ -27520,6 +28848,13 @@ function App() {
       }
     }
   });
+  useEffect5(() => {
+    return () => {
+      disconnectAll().catch(() => {
+        return;
+      }).finally(() => closeDb());
+    };
+  }, []);
   const handleSelectServer = (server2) => {
     setSelectedServer(server2);
     setView("detail");
@@ -27581,7 +28916,7 @@ function App() {
         marginTop: 1,
         children: /* @__PURE__ */ jsxDEV5(Text9, {
           dimColor: true,
-          children: view === "servers" ? "\u2191\u2193 navigate \xB7 enter select \xB7 s search \xB7 q quit" : "esc back \xB7 q quit"
+          children: view === "servers" ? "\u2191\u2193 navigate \xB7 enter select \xB7 s search \xB7 q quit" : view === "detail" ? "esc back \xB7 q quit" : "esc back"
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this)
     ]
@@ -27589,23 +28924,62 @@ function App() {
 }
 
 // src/cli/index.tsx
+var VERSION2 = (() => {
+  try {
+    const pkgPath = join6(dirname4(fileURLToPath3(import.meta.url)), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    return pkg.version || "0.0.1";
+  } catch {
+    return "0.0.1";
+  }
+})();
 var program2 = new Command;
-program2.name("mcps").description("Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers").version("0.0.1").enablePositionalOptions();
-program2.command("list").description("List registered MCP servers").action(() => {
+program2.name("mcps").description("Meta-MCP registry & CLI \u2014 discover, manage, and proxy MCP servers").version(VERSION2).enablePositionalOptions();
+program2.command("list").description("List registered MCP servers").option("--json", "Output as JSON").option("--verbose", "Show detailed info including health, command, and transport").action((opts) => {
   const servers = listServers();
+  if (opts.json) {
+    const toolCounts2 = getToolCounts();
+    console.log(JSON.stringify(servers.map((s) => ({ ...s, toolCount: toolCounts2.get(s.id) ?? 0 })), null, 2));
+    closeDb();
+    return;
+  }
   if (servers.length === 0) {
     console.log(chalk2.dim("No servers registered. Use `mcps add` or `mcps search` to get started."));
     closeDb();
     return;
   }
+  const toolCounts = getToolCounts();
   for (const s of servers) {
     const status = s.enabled ? chalk2.green("enabled") : chalk2.red("disabled");
-    const cached2 = getCachedTools(s.id);
-    const toolCount = cached2.length > 0 ? chalk2.dim(` (${cached2.length} tools)`) : "";
-    console.log(`  ${chalk2.bold(s.name)} ${chalk2.dim(`[${s.id}]`)} \u2014 ${status}${toolCount}`);
+    const cachedCount = toolCounts.get(s.id) ?? 0;
+    const toolCount = cachedCount > 0 ? chalk2.dim(` (${cachedCount} tools)`) : "";
+    const errorWarning = s.last_error ? chalk2.red(" \u26A0") : "";
+    console.log(`  ${chalk2.bold(s.name)} ${chalk2.dim(`[${s.id}]`)} \u2014 ${status}${toolCount}${errorWarning}`);
     if (s.description)
       console.log(`    ${chalk2.dim(s.description)}`);
-    console.log(`    ${chalk2.dim(`${s.command} ${s.args.join(" ")}`)}`);
+    if (opts.verbose) {
+      console.log(`    Command:   ${chalk2.dim(`${s.command} ${s.args.join(" ")}`)}`);
+      console.log(`    Transport: ${chalk2.dim(s.transport)}`);
+      const now = Date.now();
+      if (s.last_connected_at) {
+        const connectedAt = new Date(s.last_connected_at).getTime();
+        const daysDiff = Math.floor((now - connectedAt) / (1000 * 60 * 60 * 24));
+        const connectedLabel = daysDiff === 0 ? "today" : daysDiff === 1 ? "1 day ago" : `${daysDiff} days ago`;
+        const connectedColor = !s.last_error && daysDiff < 7 ? chalk2.green : chalk2.yellow;
+        console.log(`    Connected: ${connectedColor(connectedLabel)}`);
+      } else {
+        console.log(`    Connected: ${chalk2.dim("never")}`);
+      }
+      if (s.last_error) {
+        console.log(`    Error:     ${chalk2.red(s.last_error)}`);
+      }
+      const hasError = !!s.last_error;
+      const daysSinceConnect = s.last_connected_at ? Math.floor((Date.now() - new Date(s.last_connected_at).getTime()) / (1000 * 60 * 60 * 24)) : Infinity;
+      const healthIcon = hasError ? chalk2.red("\u2717 unhealthy") : daysSinceConnect < 7 ? chalk2.green("\u2713 healthy") : chalk2.yellow("\u26A0 stale");
+      console.log(`    Health:    ${healthIcon}`);
+    } else {
+      console.log(`    ${chalk2.dim(`${s.command} ${s.args.join(" ")}`)}`);
+    }
   }
   closeDb();
 });
@@ -27630,10 +29004,25 @@ ${results.length} result(s). Use \`mcps add --from-registry <id>\` to install.`)
   } catch (err) {
     console.error(chalk2.red(`Search failed: ${err.message}`));
     process.exit(1);
+  } finally {
+    closeDb();
   }
-  closeDb();
 });
-program2.command("add").passThroughOptions().argument("[command]", "Command to run the MCP server").argument("[args...]", "Arguments for the command").option("--name <name>", "Display name for the server").option("--description <desc>", "Description").option("--from-registry <id>", "Install from official registry by ID").option("--transport <type>", "Transport type: stdio, sse, streamable-http", "stdio").option("--url <url>", "URL for remote transports").option("--env <pairs...>", "Environment variables as KEY=VALUE pairs").description("Add a local MCP server").action(async (command, args, opts) => {
+async function promptReadline(rl, question) {
+  return new Promise((resolve2) => rl.question(question, resolve2));
+}
+function detectSourceType(url2) {
+  if (url2.includes("raw.githubusercontent.com") || url2.endsWith(".md"))
+    return "awesome-list";
+  if (url2.includes("registry.npmjs.org"))
+    return "npm-search";
+  if (url2.includes("api.github.com/search"))
+    return "github-topic";
+  if (url2.includes("/v0/servers") || url2.includes("/servers"))
+    return "mcp-registry";
+  return null;
+}
+program2.command("add").passThroughOptions().argument("[command]", "Command to run the MCP server").argument("[args...]", "Arguments for the command").option("--name <name>", "Display name for the server").option("--description <desc>", "Description").option("--from-registry <id>", "Install from official registry by ID").option("--transport <type>", "Transport type: stdio, sse, streamable-http", "stdio").option("--url <url>", "URL for remote transports").option("--env <pairs...>", "Environment variables as KEY=VALUE pairs").option("--wizard", "Interactive setup wizard").option("--force", "Register even if duplicate command exists").description("Add a local MCP server").action(async (command, args, opts) => {
   try {
     if (opts.fromRegistry) {
       console.log(chalk2.dim(`Installing "${opts.fromRegistry}" from registry...`));
@@ -27643,14 +29032,84 @@ program2.command("add").passThroughOptions().argument("[command]", "Command to r
       closeDb();
       return;
     }
+    if (opts.wizard) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const transport = await promptReadline(rl, "Transport [stdio/sse/http] (default: stdio): ") || "stdio";
+      const wizardCommand = await promptReadline(rl, "Command (e.g. npx, node, bunx): ");
+      if (!wizardCommand) {
+        console.error(chalk2.red("Command is required"));
+        rl.close();
+        closeDb();
+        process.exit(1);
+      }
+      const argsStr = await promptReadline(rl, "Arguments (space-separated, e.g. -y @pkg/name): ");
+      const wizardArgs = argsStr.trim() ? argsStr.trim().split(/\s+/) : [];
+      const wizardName = await promptReadline(rl, "Display name (optional, press enter to skip): ");
+      const wizardDescription = await promptReadline(rl, "Description (optional): ");
+      const env = {};
+      console.log(chalk2.dim("Add env vars (KEY=VALUE). Press enter with empty key to skip."));
+      while (true) {
+        const pair = await promptReadline(rl, "  Env var (KEY=VALUE or empty to done): ");
+        if (!pair.trim())
+          break;
+        const eqIdx = pair.indexOf("=");
+        if (eqIdx > 0)
+          env[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+      }
+      rl.close();
+      console.log(chalk2.bold(`
+Server to add:`));
+      console.log(`  Command:   ${wizardCommand} ${wizardArgs.join(" ")}`);
+      console.log(`  Transport: ${transport}`);
+      if (wizardName)
+        console.log(`  Name:      ${wizardName}`);
+      if (Object.keys(env).length)
+        console.log(`  Env:       ${Object.keys(env).join(", ")}`);
+      const confirm = await new Promise((resolve2) => {
+        const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl2.question(chalk2.bold("Add this server? [Y/n]: "), (ans) => {
+          rl2.close();
+          resolve2(ans);
+        });
+      });
+      if (confirm.toLowerCase() === "n") {
+        console.log("Aborted.");
+        closeDb();
+        return;
+      }
+      const server3 = addServer({
+        command: wizardCommand,
+        args: wizardArgs,
+        name: wizardName || undefined,
+        description: wizardDescription || undefined,
+        transport,
+        env
+      });
+      console.log(chalk2.green(`Added: ${server3.name} [${server3.id}]`));
+      closeDb();
+      return;
+    }
     if (!command) {
-      console.error(chalk2.red("Error: command is required (or use --from-registry)"));
+      console.error(chalk2.red("Error: command is required (or use --from-registry or --wizard)"));
+      closeDb();
       process.exit(1);
     }
+    const existing = listServers();
+    const duplicate = existing.find((s) => s.command === command && JSON.stringify(s.args) === JSON.stringify(args));
+    if (duplicate) {
+      console.log(chalk2.yellow(`Warning: server "${duplicate.name}" [${duplicate.id}] already uses this command.`));
+      if (!opts.force) {
+        console.log(chalk2.dim("Use --force to register anyway."));
+        closeDb();
+        return;
+      }
+    }
     const envMap = {};
     if (opts.env) {
       for (const pair of opts.env) {
         const [key, ...rest] = pair.split("=");
+        if (!key)
+          continue;
         envMap[key] = rest.join("=");
       }
     }
@@ -27671,6 +29130,43 @@ program2.command("add").passThroughOptions().argument("[command]", "Command to r
     } else {
       console.error(chalk2.red(`Failed to add server: ${err.message}`));
     }
+    closeDb();
+    process.exit(1);
+  }
+  closeDb();
+});
+program2.command("update-server").argument("<id>", "Server ID to update").description("Update fields of a registered server").option("--name <name>", "New display name").option("--description <desc>", "New description").option("--command <cmd>", "New command").option("--args <args...>", "New args list").option("--transport <type>", "New transport type").option("--url <url>", "New URL").action((id, opts) => {
+  const server2 = getServer(id);
+  if (!server2) {
+    console.error(chalk2.red(`Server "${id}" not found.`));
+    closeDb();
+    process.exit(1);
+  }
+  const fields = {};
+  if (opts.name !== undefined)
+    fields.name = opts.name;
+  if (opts.description !== undefined)
+    fields.description = opts.description;
+  if (opts.command !== undefined)
+    fields.command = opts.command;
+  if (opts.args !== undefined)
+    fields.args = opts.args;
+  if (opts.transport !== undefined)
+    fields.transport = opts.transport;
+  if (opts.url !== undefined)
+    fields.url = opts.url;
+  const updated = updateServer(id, fields);
+  console.log(chalk2.green(`Updated server: ${updated.name} [${updated.id}]`));
+  closeDb();
+});
+program2.command("clone").argument("<id>", "Server ID to clone").argument("<new-name>", "Name for the cloned server").description("Clone a server with a new name").action((id, newName) => {
+  try {
+    const cloned = cloneServer(id, newName);
+    console.log(chalk2.green(`Cloned server: ${cloned.name} [${cloned.id}]`));
+    console.log(chalk2.dim(`  ${cloned.command} ${cloned.args.join(" ")}`));
+  } catch (err) {
+    console.error(chalk2.red(err.message));
+    closeDb();
     process.exit(1);
   }
   closeDb();
@@ -27679,6 +29175,7 @@ program2.command("remove").argument("<id>", "Server ID to remove").description("
   const server2 = getServer(id);
   if (!server2) {
     console.error(chalk2.red(`Server "${id}" not found.`));
+    closeDb();
     process.exit(1);
   }
   removeServer(id);
@@ -27689,6 +29186,7 @@ program2.command("enable").argument("<id>", "Server ID to enable").description("
   const server2 = getServer(id);
   if (!server2) {
     console.error(chalk2.red(`Server "${id}" not found.`));
+    closeDb();
     process.exit(1);
   }
   enableServer(id);
@@ -27699,6 +29197,7 @@ program2.command("disable").argument("<id>", "Server ID to disable").description
   const server2 = getServer(id);
   if (!server2) {
     console.error(chalk2.red(`Server "${id}" not found.`));
+    closeDb();
     process.exit(1);
   }
   disableServer(id);
@@ -27778,6 +29277,7 @@ program2.command("call").argument("<tool>", "Tool name (server_id__tool_name)").
       }
     }
   }
+  let exitCode = 0;
   try {
     console.log(chalk2.dim(`Connecting to servers...`));
     await connectAllEnabled();
@@ -27786,17 +29286,22 @@ program2.command("call").argument("<tool>", "Tool name (server_id__tool_name)").
     for (const c of result.content) {
       console.log(c.text);
     }
-    await disconnectAll();
   } catch (err) {
     console.error(chalk2.red(`Call failed: ${err.message}`));
-    process.exit(1);
+    exitCode = 1;
   }
+  await disconnectAll().catch(() => {
+    return;
+  });
   closeDb();
+  if (exitCode !== 0)
+    process.exit(exitCode);
 });
 program2.command("info").argument("<id>", "Server ID").description("Show server details & tools").action((id) => {
   const server2 = getServer(id);
   if (!server2) {
     console.error(chalk2.red(`Server "${id}" not found.`));
+    closeDb();
     process.exit(1);
   }
   console.log(chalk2.bold(server2.name) + " " + chalk2.dim(`[${server2.id}]`));
@@ -27825,21 +29330,553 @@ program2.command("info").argument("<id>", "Server ID").description("Show server
   }
   closeDb();
 });
-program2.command("status").description("Show registry stats").action(() => {
+program2.command("status").description("Show registry stats").option("--json", "Output as JSON").action((opts) => {
   const servers = listServers();
   const enabled = servers.filter((s) => s.enabled).length;
   const disabled = servers.length - enabled;
+  const toolCounts = getToolCounts();
   let totalTools = 0;
-  for (const s of servers) {
-    totalTools += getCachedTools(s.id).length;
+  for (const s of servers)
+    totalTools += toolCounts.get(s.id) ?? 0;
+  if (opts.json) {
+    console.log(JSON.stringify({ total: servers.length, enabled, disabled, totalTools }, null, 2));
+    closeDb();
+    return;
   }
   console.log(chalk2.bold("Registry Status"));
   console.log(`  Servers:  ${servers.length} (${chalk2.green(`${enabled} enabled`)}, ${chalk2.red(`${disabled} disabled`)})`);
   console.log(`  Tools:    ${totalTools} (cached)`);
   closeDb();
 });
-program2.command("serve").description("Start the web dashboard").option("--port <port>", "Port to listen on", "19427").option("--no-open", "Don't open browser automatically").action(async (opts) => {
-  await startServer(parseInt(opts.port, 10), { open: opts.open });
+program2.command("doctor").argument("[id]", "Server ID to check (omit to check all)").description("Diagnose server health \u2014 checks PATH, env vars, connectivity").option("--fix", "Attempt to fix issues automatically").action(async (id, opts) => {
+  const { execFileSync: execFileSync22 } = await import("child_process");
+  const servers = id ? [getServer(id)].filter(Boolean) : listServers();
+  if (servers.length === 0) {
+    console.log(chalk2.dim(id ? `Server "${id}" not found.` : "No servers registered."));
+    closeDb();
+    return;
+  }
+  let allHealthy = true;
+  for (const server2 of servers) {
+    console.log(chalk2.bold(`
+${server2.name} [${server2.id}]`));
+    const report = await diagnoseServer(server2);
+    for (const check2 of report.checks) {
+      const icon = check2.pass ? chalk2.green("\u2713") : chalk2.red("\u2717");
+      console.log(`  ${icon} ${check2.name}: ${chalk2.dim(check2.message)}`);
+      if (!check2.pass && opts.fix && check2.fixable && check2.fixHint) {
+        console.log(chalk2.dim(`  Attempting fix: ${check2.fixHint}`));
+        try {
+          execFileSync22("npm", ["install", "-g", check2.fixHint.replace("npm install -g ", "")], { stdio: "inherit" });
+          console.log(chalk2.green(`  Fixed!`));
+        } catch {
+          console.log(chalk2.red(`  Fix failed`));
+        }
+      }
+    }
+    if (!report.healthy)
+      allHealthy = false;
+  }
+  console.log("");
+  if (allHealthy) {
+    console.log(chalk2.green("All checks passed."));
+  } else {
+    console.log(chalk2.red("Some checks failed. Fix issues above."));
+  }
+  closeDb();
+});
+program2.command("completion").argument("<shell>", "Shell type: bash, zsh, fish").description("Generate shell completion script").action((shell) => {
+  const commands = ["list", "search", "find", "add", "remove", "enable", "disable", "info", "status", "tools", "call", "doctor", "install", "export", "import", "env", "sources", "clone", "update-server", "serve", "update", "mcp", "completion"];
+  if (shell === "bash") {
+    console.log(`# Add to ~/.bashrc: eval "$(mcps completion bash)"
+_mcps_complete() {
+  local cur prev words
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local cmds="${commands.join(" ")}"
+  if [ $COMP_CWORD -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "$cmds" -- "$cur") )
+  fi
+}
+complete -F _mcps_complete mcps`);
+  } else if (shell === "zsh") {
+    console.log(`# Add to ~/.zshrc: eval "$(mcps completion zsh)"
+_mcps() {
+  local -a cmds
+  cmds=(${commands.map((c) => `'${c}'`).join(" ")})
+  _describe 'commands' cmds
+}
+compdef _mcps mcps`);
+  } else if (shell === "fish") {
+    const lines = commands.map((c) => `complete -c mcps -f -a '${c}'`).join(`
+`);
+    console.log(`# Add to ~/.config/fish/completions/mcps.fish
+${lines}`);
+  } else {
+    console.error(chalk2.red(`Unknown shell: ${shell}. Use bash, zsh, or fish.`));
+    process.exit(1);
+  }
+  closeDb();
+});
+program2.command("serve").description("Start the web dashboard").option("--port <port>", "Port to listen on", "19427").option("--host <host>", "Host to bind (default: 127.0.0.1)", "127.0.0.1").option("--no-open", "Don't open browser automatically").action(async (opts) => {
+  await startServer(parseInt(opts.port, 10), { open: opts.open, host: opts.host });
+});
+program2.command("update").description("Update mcps to the latest version").action(async () => {
+  const { execFileSync: execFileSync3 } = await import("child_process");
+  const pkg = await Promise.resolve().then(() => __toESM(require_package(), 1));
+  const currentVersion = pkg.version;
+  console.log(chalk2.dim(`Current version: ${currentVersion}`));
+  console.log(chalk2.dim("Checking for updates..."));
+  try {
+    const latest = execFileSync3("npm", ["view", "@hasna/mcps", "version"], {
+      encoding: "utf-8"
+    }).trim();
+    if (latest === currentVersion) {
+      console.log(chalk2.green(`Already on the latest version (${currentVersion}).`));
+      return;
+    }
+    console.log(chalk2.dim(`New version available: ${latest}`));
+    console.log(chalk2.dim("Updating..."));
+    execFileSync3("bun", ["install", "-g", "@hasna/mcps@latest"], { stdio: "inherit" });
+    console.log(chalk2.green(`Updated to ${latest}`));
+  } catch (err) {
+    console.error(chalk2.red(`Update failed: ${err.message}`));
+    closeDb();
+    process.exit(1);
+  }
+});
+program2.command("find").argument("[query]", "Search query (omit to list all from awesome list)").description("Find MCP servers across npm, GitHub, official registry, and awesome lists").option("--source <sources...>", "Source IDs to search (see `mcps sources list`)").option("--limit <n>", "Max results per source", "20").option("--awesome", "List curated servers from punkpeye/awesome-mcp-servers").option("--json", "Output as JSON").option("--install", "After showing results, prompt to select one and install it").option("--yes", "Auto-install without prompting (only when there is exactly 1 result)").option("--no-cache", "Bypass source cache and fetch fresh results").action(async (query, opts) => {
+  try {
+    if (opts.awesome) {
+      console.log(chalk2.dim("Fetching curated awesome-mcp-servers list..."));
+      const results2 = await listAwesomeServers();
+      if (opts.json) {
+        console.log(JSON.stringify(results2, null, 2));
+        closeDb();
+        return;
+      }
+      const allSources = listSources();
+      const sourceNameMap2 = new Map(allSources.map((s) => [s.id, s.name]));
+      for (const r of results2) {
+        const sourceName = r.sourceId ? sourceNameMap2.get(r.sourceId) ?? r.source : r.source;
+        console.log(`  ${chalk2.bold(r.name)} ${chalk2.yellow(`[${sourceName}]`)}`);
+        if (r.description)
+          console.log(`    ${chalk2.dim(r.description)}`);
+        if (r.url)
+          console.log(`    ${chalk2.cyan(r.url)}`);
+      }
+      console.log(chalk2.dim(`
+${results2.length} servers in awesome list.`));
+      closeDb();
+      return;
+    }
+    const q = query || "";
+    const sources = opts.source;
+    const limit = parseInt(opts.limit, 10) || 20;
+    const noCache = opts.cache === false;
+    if (!q) {
+      console.log(chalk2.dim("Tip: provide a query to search, or use --awesome to browse the curated list."));
+    } else {
+      console.log(chalk2.dim(`Searching for "${q}" across ${sources ? sources.join(", ") : "all enabled sources"}...`));
+    }
+    const t0 = Date.now();
+    const results = await findServers(q, { sources, limit, noCache });
+    const elapsed = Date.now() - t0;
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+      closeDb();
+      return;
+    }
+    if (results.length === 0) {
+      console.log(chalk2.dim("No servers found."));
+      closeDb();
+      return;
+    }
+    const countBySource = new Map;
+    for (const r of results) {
+      const key = r.sourceId ?? r.source;
+      countBySource.set(key, (countBySource.get(key) ?? 0) + 1);
+    }
+    const allSourcesList = listSources();
+    const sourceNameMap = new Map(allSourcesList.map((s) => [s.id, s.name]));
+    const sourcesUsed = countBySource.size;
+    const breakdownParts = Array.from(countBySource.entries()).map(([k, n]) => `${sourceNameMap.get(k) ?? k}: ${n}`).join(", ");
+    const sourceColors = {
+      registry: chalk2.blue,
+      npm: chalk2.red,
+      awesome: chalk2.yellow,
+      github: chalk2.magenta
+    };
+    for (let i = 0;i < results.length; i++) {
+      const r = results[i];
+      const sourceName = r.sourceId ? sourceNameMap.get(r.sourceId) ?? r.source : r.source;
+      const sourceLabel = (sourceColors[r.source] ?? chalk2.dim)(`[${sourceName}]`);
+      const stars = r.stars ? chalk2.dim(` \u2605${r.stars}`) : "";
+      const idx = opts.install ? chalk2.dim(`${i + 1}. `) : "  ";
+      console.log(`${idx}${chalk2.bold(r.name)} ${sourceLabel}${stars}`);
+      if (r.description)
+        console.log(`    ${chalk2.dim(r.description)}`);
+      if (r.installCmd)
+        console.log(`    ${chalk2.green(`Install: ${r.installCmd}`)}`);
+      else if (r.url)
+        console.log(`    ${chalk2.cyan(r.url)}`);
+    }
+    console.log(chalk2.dim(`
+Found ${results.length} results across ${sourcesUsed} source${sourcesUsed === 1 ? "" : "s"} (${elapsed}ms)`));
+    if (breakdownParts)
+      console.log(chalk2.dim(`  Breakdown: ${breakdownParts}`));
+    console.log(chalk2.dim(`Use \`mcps add --from-registry <id>\` or \`mcps add npx -y <pkg>\` to install.`));
+    if (opts.install) {
+      let chosen = results[0];
+      if (results.length === 1 && opts.yes) {} else {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve2) => {
+          rl.question(chalk2.cyan(`
+Enter number to install (1-${results.length}), or 0 to cancel: `), resolve2);
+        });
+        rl.close();
+        const num = parseInt(answer, 10);
+        if (!num || num < 1 || num > results.length) {
+          console.log(chalk2.dim("Installation cancelled."));
+          closeDb();
+          return;
+        }
+        chosen = results[num - 1];
+      }
+      if (!chosen.npmPackage && !chosen.installCmd) {
+        console.log(chalk2.yellow(`No install command available for ${chosen.name}, visit ${chosen.url ?? "(no URL)"}`));
+        closeDb();
+        return;
+      }
+      const pkg = chosen.npmPackage ?? chosen.installCmd?.replace(/^npx -y /, "");
+      if (!pkg) {
+        console.log(chalk2.yellow(`No install command available for ${chosen.name}, visit ${chosen.url ?? "(no URL)"}`));
+        closeDb();
+        return;
+      }
+      console.log(chalk2.dim(`Installing ${chosen.name}...`));
+      const server2 = addServer({
+        command: "npx",
+        args: ["-y", pkg],
+        name: chosen.name,
+        description: chosen.description,
+        transport: "stdio"
+      });
+      const results2 = installToAgents(server2, ["claude", "codex", "gemini"]);
+      for (const r of results2) {
+        if (r.success) {
+          console.log(chalk2.green(`  \u2713 ${r.agent}`));
+        } else {
+          console.log(chalk2.red(`  \u2717 ${r.agent}: ${r.error}`));
+        }
+      }
+      console.log(chalk2.green(`
+Installed ${server2.name} [${server2.id}]`));
+    }
+  } catch (err) {
+    console.error(chalk2.red(`Find failed: ${err.message}`));
+    process.exit(1);
+  } finally {
+    closeDb();
+  }
+});
+var sourcesCmd = program2.command("sources").description("Manage search sources");
+sourcesCmd.command("list").description("List all search sources").action(() => {
+  const sources = listSources();
+  if (sources.length === 0) {
+    console.log(chalk2.dim("No sources configured."));
+    closeDb();
+    return;
+  }
+  for (const s of sources) {
+    const status = s.enabled ? chalk2.green("enabled") : chalk2.red("disabled");
+    console.log(`  ${chalk2.bold(s.name)} ${chalk2.dim(`[${s.id}]`)} \u2014 ${chalk2.dim(s.type)} \u2014 ${status}`);
+    if (s.description)
+      console.log(`    ${chalk2.dim(s.description)}`);
+    console.log(`    ${chalk2.cyan(s.url)}`);
+  }
+  closeDb();
+});
+sourcesCmd.command("add").description("Add a new search source").option("--name <name>", "Source name (required)").option("--type <type>", "Source type: mcp-registry, awesome-list, npm-search, github-topic").option("--url <url>", "Source URL (required)").option("--description <desc>", "Description").option("--test", "Test the source after adding by running a sample search").action(async (opts) => {
+  if (!opts.name || !opts.url) {
+    console.error(chalk2.red("Error: --name and --url are required"));
+    closeDb();
+    process.exit(1);
+  }
+  const validTypes = ["mcp-registry", "awesome-list", "npm-search", "github-topic"];
+  let sourceType = opts.type;
+  if (!sourceType) {
+    const detected = detectSourceType(opts.url);
+    if (detected) {
+      console.log(chalk2.dim(`Auto-detected type: ${detected}`));
+      sourceType = detected;
+    } else {
+      console.error(chalk2.red(`Error: could not auto-detect --type. Please specify one of: ${validTypes.join(", ")}`));
+      closeDb();
+      process.exit(1);
+    }
+  }
+  if (!validTypes.includes(sourceType)) {
+    console.error(chalk2.red(`Error: --type must be one of: ${validTypes.join(", ")}`));
+    closeDb();
+    process.exit(1);
+  }
+  try {
+    const source = addSource({
+      name: opts.name,
+      type: sourceType,
+      url: opts.url,
+      description: opts.description
+    });
+    console.log(chalk2.green(`Added source: ${source.name} [${source.id}]`));
+    if (opts.test) {
+      console.log(chalk2.dim("Testing source..."));
+      const testResults = await searchSource(source, "");
+      console.log(chalk2.dim(`  Found ${testResults.length} results`));
+      if (testResults.length === 0)
+        console.log(chalk2.yellow("  Warning: source returned no results"));
+    }
+  } catch (err) {
+    console.error(chalk2.red(`Failed to add source: ${err.message}`));
+    closeDb();
+    process.exit(1);
+  }
+  closeDb();
+});
+sourcesCmd.command("remove").argument("<id>", "Source ID to remove").description("Remove a search source").action((id) => {
+  const source = getSource(id);
+  if (!source) {
+    console.error(chalk2.red(`Source "${id}" not found.`));
+    closeDb();
+    process.exit(1);
+  }
+  removeSource(id);
+  console.log(chalk2.green(`Removed source: ${source.name} [${id}]`));
+  closeDb();
+});
+sourcesCmd.command("enable").argument("<id>", "Source ID to enable").description("Enable a search source").action((id) => {
+  const source = getSource(id);
+  if (!source) {
+    console.error(chalk2.red(`Source "${id}" not found.`));
+    closeDb();
+    process.exit(1);
+  }
+  enableSource(id);
+  console.log(chalk2.green(`Enabled source: ${source.name}`));
+  closeDb();
+});
+sourcesCmd.command("disable").argument("<id>", "Source ID to disable").description("Disable a search source").action((id) => {
+  const source = getSource(id);
+  if (!source) {
+    console.error(chalk2.red(`Source "${id}" not found.`));
+    closeDb();
+    process.exit(1);
+  }
+  disableSource(id);
+  console.log(chalk2.yellow(`Disabled source: ${source.name}`));
+  closeDb();
+});
+sourcesCmd.command("refresh").argument("[id]", "Source ID to refresh (omit to refresh all)").description("Clear cached results for a source").action((id) => {
+  clearCache(id);
+  if (id) {
+    console.log(chalk2.green(`Cleared cache for source: ${id}`));
+  } else {
+    console.log(chalk2.green("Cleared all source caches."));
+  }
+  closeDb();
+});
+sourcesCmd.command("test").argument("<id>", "Source ID to test").description("Test a source by running a sample search").action(async (id) => {
+  const source = getSource(id);
+  if (!source) {
+    console.error(chalk2.red(`Source "${id}" not found.`));
+    closeDb();
+    process.exit(1);
+  }
+  console.log(chalk2.dim(`Testing source "${source.name}"...`));
+  try {
+    const results = await searchSource(source, "", true);
+    console.log(chalk2.green(`\u2713 Source returned ${results.length} results`));
+    if (results.length > 0) {
+      console.log(chalk2.dim("  Sample results:"));
+      for (const r of results.slice(0, 3)) {
+        console.log(`    ${chalk2.bold(r.name)}: ${chalk2.dim(r.description?.slice(0, 60) || "no description")}`);
+      }
+    }
+  } catch (err) {
+    console.error(chalk2.red(`\u2717 Source test failed: ${err.message}`));
+  }
+  closeDb();
+});
+program2.command("install").argument("[id]", "Server ID (from `mcps list`) to install into AI agents").description("Install a registered MCP server into Claude Code, Codex, and/or Gemini").option("--claude", "Install to Claude Code").option("--codex", "Install to Codex").option("--gemini", "Install to Gemini").option("--all", "Install to all agents (default if none specified)").option("--to <agents...>", "Agents to install to: claude, codex, gemini").option("--from-registry <id>", "Add from official registry and install in one step").option("--npm <package>", "Add an npm package as a server and install in one step").action(async (id, opts) => {
+  const targets = [];
+  if (opts.to) {
+    for (const t of opts.to) {
+      if (t === "claude" || t === "codex" || t === "gemini")
+        targets.push(t);
+    }
+  }
+  if (opts.claude && !targets.includes("claude"))
+    targets.push("claude");
+  if (opts.codex && !targets.includes("codex"))
+    targets.push("codex");
+  if (opts.gemini && !targets.includes("gemini"))
+    targets.push("gemini");
+  if (opts.all || targets.length === 0) {
+    if (!targets.includes("claude"))
+      targets.push("claude");
+    if (!targets.includes("codex"))
+      targets.push("codex");
+    if (!targets.includes("gemini"))
+      targets.push("gemini");
+  }
+  let server2;
+  if (opts.fromRegistry) {
+    console.log(chalk2.dim(`Installing "${opts.fromRegistry}" from registry...`));
+    try {
+      server2 = await installFromRegistry(opts.fromRegistry);
+      console.log(chalk2.green(`Added server: ${server2.name} [${server2.id}]`));
+    } catch (err) {
+      console.error(chalk2.red(`Failed to install from registry: ${err.message}`));
+      closeDb();
+      process.exit(1);
+    }
+  } else if (opts.npm) {
+    const pkg = opts.npm;
+    server2 = addServer({ command: "npx", args: ["-y", pkg], name: pkg, transport: "stdio" });
+    console.log(chalk2.green(`Added server: ${server2.name} [${server2.id}]`));
+  } else {
+    if (!id) {
+      console.error(chalk2.red("Error: server ID is required (or use --from-registry or --npm)"));
+      closeDb();
+      process.exit(1);
+    }
+    server2 = getServer(id);
+    if (!server2) {
+      console.error(chalk2.red(`Server "${id}" not found. Use \`mcps add\` first.`));
+      closeDb();
+      process.exit(1);
+    }
+  }
+  console.log(chalk2.dim(`Installing "${server2.name}" to: ${targets.join(", ")}...`));
+  const results = installToAgents(server2, targets);
+  for (const r of results) {
+    if (r.success) {
+      console.log(chalk2.green(`  \u2713 ${r.agent}`));
+    } else {
+      console.log(chalk2.red(`  \u2717 ${r.agent}: ${r.error}`));
+    }
+  }
+  closeDb();
+});
+program2.command("export").description("Export all servers and sources to a JSON file").option("--file <path>", "Output file path", `${process.env.HOME ?? "~"}/.mcps/export.json`).option("--stdout", "Write to stdout instead of a file").action((opts) => {
+  const servers = listServers();
+  const sources = listSources();
+  const payload = {
+    version: 1,
+    exported_at: new Date().toISOString(),
+    servers,
+    sources
+  };
+  const json2 = JSON.stringify(payload, null, 2);
+  if (opts.stdout) {
+    console.log(json2);
+  } else {
+    writeFileSync3(opts.file, json2, "utf-8");
+    console.log(chalk2.green(`Exported ${servers.length} server(s) and ${sources.length} source(s) to ${opts.file}`));
+  }
+  closeDb();
+});
+program2.command("import").argument("<file>", "Path to the export JSON file").description("Import servers and sources from a JSON export file").option("--overwrite", "Overwrite existing entries with matching IDs").action((file, opts) => {
+  let payload;
+  try {
+    payload = JSON.parse(readFileSync4(file, "utf-8"));
+  } catch (err) {
+    console.error(chalk2.red(`Failed to read file: ${err.message}`));
+    closeDb();
+    process.exit(1);
+  }
+  if (!Array.isArray(payload.servers) || !Array.isArray(payload.sources)) {
+    console.error(chalk2.red("Invalid export file format."));
+    closeDb();
+    process.exit(1);
+  }
+  const db2 = getDb();
+  const overwrite = opts.overwrite;
+  const orReplace = overwrite ? "OR REPLACE" : "OR IGNORE";
+  let serversImported = 0;
+  let serversSkipped = 0;
+  for (const s of payload.servers) {
+    const existing = getServer(s.id);
+    if (existing && !overwrite) {
+      serversSkipped++;
+      continue;
+    }
+    db2.run(`INSERT ${orReplace} INTO servers (id, name, description, command, args, env, transport, url, source, enabled, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`, [s.id, s.name, s.description, s.command, JSON.stringify(s.args ?? []), JSON.stringify(s.env ?? {}), s.transport, s.url, s.source, s.enabled ? 1 : 0, s.created_at, s.updated_at]);
+    serversImported++;
+  }
+  let sourcesImported = 0;
+  let sourcesSkipped = 0;
+  for (const s of payload.sources) {
+    const existing = getSource(s.id);
+    if (existing && !overwrite) {
+      sourcesSkipped++;
+      continue;
+    }
+    db2.run(`INSERT ${orReplace} INTO sources (id, name, type, url, description, enabled, created_at) VALUES (?,?,?,?,?,?,?)`, [s.id, s.name, s.type, s.url, s.description, s.enabled ? 1 : 0, s.created_at]);
+    sourcesImported++;
+  }
+  console.log(chalk2.green(`Servers: ${serversImported} imported, ${serversSkipped} skipped.`));
+  console.log(chalk2.green(`Sources: ${sourcesImported} imported, ${sourcesSkipped} skipped.`));
+  closeDb();
+});
+var envCmd = program2.command("env").description("Manage server environment variables");
+envCmd.command("list").argument("<id>").description("List env vars for a server").action((id) => {
+  const server2 = getServer(id);
+  if (!server2) {
+    console.error(chalk2.red(`Server "${id}" not found.`));
+    closeDb();
+    process.exit(1);
+  }
+  const entries = Object.entries(server2.env);
+  if (entries.length === 0) {
+    console.log(chalk2.dim("No env vars set."));
+    closeDb();
+    return;
+  }
+  for (const [k, v] of entries)
+    console.log(`  ${chalk2.bold(k)}=${chalk2.dim(v)}`);
+  closeDb();
+});
+envCmd.command("set").argument("<id>").argument("<pair>", "KEY=VALUE").description("Set an env var").action((id, pair) => {
+  const eqIdx = pair.indexOf("=");
+  if (eqIdx === -1) {
+    console.error(chalk2.red("Format: KEY=VALUE"));
+    closeDb();
+    process.exit(1);
+  }
+  const key = pair.slice(0, eqIdx);
+  const value = pair.slice(eqIdx + 1);
+  try {
+    setServerEnv(id, key, value);
+    console.log(chalk2.green(`Set ${key} on ${id}`));
+  } catch (err) {
+    console.error(chalk2.red(err.message));
+    closeDb();
+    process.exit(1);
+  }
+  closeDb();
+});
+envCmd.command("unset").argument("<id>").argument("<key>").description("Remove an env var").action((id, key) => {
+  try {
+    unsetServerEnv(id, key);
+    console.log(chalk2.green(`Unset ${key} on ${id}`));
+  } catch (err) {
+    console.error(chalk2.red(err.message));
+    closeDb();
+    process.exit(1);
+  }
+  closeDb();
 });
 program2.command("mcp").description("Start meta-MCP server (stdio)").action(async () => {
   await startMcpServer();