mcpman 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -159,9 +159,9 @@ async function atomicWrite(filePath, content) {
     throw err;
   }
 }
-async function pathExists(p11) {
+async function pathExists(p12) {
   try {
-    await import_node_fs3.default.promises.access(p11);
+    await import_node_fs3.default.promises.access(p12);
     return true;
   } catch {
     return false;
@@ -237,6 +237,12 @@ var init_base_client_handler = __esm({
 function getHomedir() {
   return import_node_os3.default.homedir();
 }
+function getMcpmanDir() {
+  return import_node_path4.default.join(import_node_os3.default.homedir(), ".mcpman");
+}
+function getConfigPath() {
+  return import_node_path4.default.join(getMcpmanDir(), "config.json");
+}
 function getAppDataDir() {
   const home = getHomedir();
   if (process.platform === "darwin") {
@@ -432,12 +438,12 @@ __export(vault_service_exports, {
   writeVault: () => writeVault
 });
 function getVaultPath() {
-  return import_node_path6.default.join(import_node_os4.default.homedir(), ".mcpman", "vault.enc");
+  return import_node_path7.default.join(import_node_os4.default.homedir(), ".mcpman", "vault.enc");
 }
 function readVault(vaultPath = getVaultPath()) {
   const empty = { version: 1, servers: {} };
   try {
-    const raw = import_node_fs4.default.readFileSync(vaultPath, "utf-8");
+    const raw = import_node_fs5.default.readFileSync(vaultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || typeof parsed.servers !== "object") return empty;
     return parsed;
@@ -446,16 +452,16 @@ function readVault(vaultPath = getVaultPath()) {
   }
 }
 function writeVault(data, vaultPath = getVaultPath()) {
-  const dir = import_node_path6.default.dirname(vaultPath);
-  import_node_fs4.default.mkdirSync(dir, { recursive: true });
+  const dir = import_node_path7.default.dirname(vaultPath);
+  import_node_fs5.default.mkdirSync(dir, { recursive: true });
   const tmp = `${vaultPath}.tmp`;
-  import_node_fs4.default.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
+  import_node_fs5.default.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
   if (process.platform !== "win32") {
-    import_node_fs4.default.chmodSync(tmp, 384);
+    import_node_fs5.default.chmodSync(tmp, 384);
   }
-  import_node_fs4.default.renameSync(tmp, vaultPath);
+  import_node_fs5.default.renameSync(tmp, vaultPath);
   if (process.platform !== "win32") {
-    import_node_fs4.default.chmodSync(vaultPath, 384);
+    import_node_fs5.default.chmodSync(vaultPath, 384);
   }
 }
 function encrypt(value, password2) {
@@ -482,20 +488,20 @@ function decrypt(entry, password2) {
   ]);
   return decrypted.toString("utf-8");
 }
-async function getMasterPassword(confirm8 = false) {
+async function getMasterPassword(confirm9 = false) {
   if (_cachedPassword) return _cachedPassword;
-  const password2 = await p3.password({
+  const password2 = await p4.password({
     message: "Enter vault master password:",
     validate: (v) => v.length < 8 ? "Password must be at least 8 characters" : void 0
   });
-  if (p3.isCancel(password2)) {
-    p3.cancel("Vault access cancelled.");
+  if (p4.isCancel(password2)) {
+    p4.cancel("Vault access cancelled.");
     process.exit(0);
   }
-  if (confirm8) {
-    const confirm22 = await p3.password({ message: "Confirm master password:" });
-    if (p3.isCancel(confirm22) || confirm22 !== password2) {
-      p3.cancel("Passwords do not match.");
+  if (confirm9) {
+    const confirm22 = await p4.password({ message: "Confirm master password:" });
+    if (p4.isCancel(confirm22) || confirm22 !== password2) {
+      p4.cancel("Passwords do not match.");
       process.exit(1);
     }
   }
@@ -545,16 +551,16 @@ function listSecrets(server, vaultPath = getVaultPath()) {
     keys: Object.keys(keys)
   }));
 }
-var import_node_crypto2, import_node_fs4, import_node_os4, import_node_path6, p3, _cachedPassword;
+var import_node_crypto2, import_node_fs5, import_node_os4, import_node_path7, p4, _cachedPassword;
 var init_vault_service = __esm({
   "src/core/vault-service.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_crypto2 = __toESM(require("crypto"), 1);
-    import_node_fs4 = __toESM(require("fs"), 1);
+    import_node_fs5 = __toESM(require("fs"), 1);
     import_node_os4 = __toESM(require("os"), 1);
-    import_node_path6 = __toESM(require("path"), 1);
-    p3 = __toESM(require("@clack/prompts"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
+    p4 = __toESM(require("@clack/prompts"), 1);
     _cachedPassword = null;
     process.on("exit", () => {
       _cachedPassword = null;
@@ -564,7 +570,7 @@ var init_vault_service = __esm({
 
 // src/index.ts
 init_cjs_shims();
-var import_citty10 = require("citty");
+var import_citty14 = require("citty");
 
 // src/commands/audit.ts
 init_cjs_shims();
@@ -767,11 +773,11 @@ async function scanAllServers(servers, concurrency = 3) {
   const results = [];
   const executing = /* @__PURE__ */ new Set();
   for (const [name, entry] of entries) {
-    const p11 = scanServer(name, entry).then((r) => {
+    const p12 = scanServer(name, entry).then((r) => {
       results.push(r);
-      executing.delete(p11);
+      executing.delete(p12);
     });
-    executing.add(p11);
+    executing.add(p12);
     if (executing.size >= concurrency) await Promise.race(executing);
   }
   await Promise.all(executing);
@@ -886,11 +892,11 @@ async function checkAllVersions(lockfile) {
   const results = [];
   const executing = /* @__PURE__ */ new Set();
   for (const [name, entry] of entries) {
-    const p11 = checkVersion(name, entry).then((r) => {
+    const p12 = checkVersion(name, entry).then((r) => {
       results.push(r);
-      executing.delete(p11);
+      executing.delete(p12);
     });
-    executing.add(p11);
+    executing.add(p12);
     if (executing.size >= 5) {
       await Promise.race(executing);
     }
@@ -1334,10 +1340,160 @@ async function runAuditFix(reports, servers, skipConfirm) {
 `);
 }
 
-// src/commands/doctor.ts
+// src/commands/config.ts
 init_cjs_shims();
 var import_citty2 = require("citty");
 var import_picocolors2 = __toESM(require("picocolors"), 1);
+var p2 = __toESM(require("@clack/prompts"), 1);
+
+// src/core/config-service.ts
+init_cjs_shims();
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+init_paths();
+var VALID_KEYS = /* @__PURE__ */ new Set([
+  "defaultClient",
+  "updateCheckInterval",
+  "preferredRegistry",
+  "vaultTimeout"
+]);
+function readConfig(configPath = getConfigPath()) {
+  try {
+    const raw = import_node_fs4.default.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function writeConfig(data, configPath = getConfigPath()) {
+  const dir = import_node_path5.default.dirname(configPath);
+  import_node_fs4.default.mkdirSync(dir, { recursive: true });
+  const tmp = `${configPath}.tmp`;
+  import_node_fs4.default.writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+  import_node_fs4.default.renameSync(tmp, configPath);
+}
+function getConfigValue(key, configPath = getConfigPath()) {
+  const data = readConfig(configPath);
+  if (!VALID_KEYS.has(key)) return void 0;
+  return data[key];
+}
+function setConfigValue(key, value, configPath = getConfigPath()) {
+  const data = readConfig(configPath);
+  if (!VALID_KEYS.has(key)) {
+    throw new Error(`Unknown config key: "${key}". Valid keys: ${[...VALID_KEYS].join(", ")}`);
+  }
+  data[key] = value;
+  writeConfig(data, configPath);
+}
+
+// src/commands/config.ts
+function coerceValue(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!Number.isNaN(num) && raw.trim() !== "") return num;
+  return raw;
+}
+var setCommand = (0, import_citty2.defineCommand)({
+  meta: { name: "set", description: "Set a config value" },
+  args: {
+    key: {
+      type: "positional",
+      description: "Config key (e.g. defaultClient)",
+      required: true
+    },
+    value: {
+      type: "positional",
+      description: "Value to set",
+      required: true
+    }
+  },
+  run({ args }) {
+    try {
+      const coerced = coerceValue(args.value);
+      setConfigValue(args.key, coerced);
+      console.log(
+        `${import_picocolors2.default.green("\u2713")} Set ${import_picocolors2.default.bold(args.key)} = ${import_picocolors2.default.cyan(String(coerced))}`
+      );
+    } catch (err) {
+      console.error(`${import_picocolors2.default.red("\u2717")} ${String(err)}`);
+      process.exit(1);
+    }
+  }
+});
+var getCommand = (0, import_citty2.defineCommand)({
+  meta: { name: "get", description: "Get a config value" },
+  args: {
+    key: {
+      type: "positional",
+      description: "Config key to read",
+      required: true
+    }
+  },
+  run({ args }) {
+    const val = getConfigValue(args.key);
+    if (val === void 0) {
+      console.log(import_picocolors2.default.dim(`${args.key}: (not set)`));
+    } else {
+      console.log(`${import_picocolors2.default.bold(args.key)}: ${import_picocolors2.default.cyan(String(val))}`);
+    }
+  }
+});
+var listCommand = (0, import_citty2.defineCommand)({
+  meta: { name: "list", description: "List all config values" },
+  run() {
+    const data = readConfig();
+    const entries = Object.entries(data);
+    if (entries.length === 0) {
+      console.log(import_picocolors2.default.dim("No config values set. Use `mcpman config set <key> <value>`."));
+      return;
+    }
+    console.log("");
+    console.log(import_picocolors2.default.bold("mcpman config:"));
+    console.log("");
+    for (const [key, val] of entries) {
+      console.log(`  ${import_picocolors2.default.green("\u25CF")} ${import_picocolors2.default.bold(key)}  ${import_picocolors2.default.cyan(String(val))}`);
+    }
+    console.log("");
+    console.log(import_picocolors2.default.dim(`  ${entries.length} key${entries.length !== 1 ? "s" : ""} configured`));
+  }
+});
+var resetCommand = (0, import_citty2.defineCommand)({
+  meta: { name: "reset", description: "Reset config to defaults (removes config file)" },
+  async run() {
+    const confirmed = await p2.confirm({
+      message: "Reset all config values to defaults?",
+      initialValue: false
+    });
+    if (p2.isCancel(confirmed) || !confirmed) {
+      p2.cancel("Cancelled.");
+      return;
+    }
+    writeConfig({});
+    console.log(`${import_picocolors2.default.green("\u2713")} Config reset to defaults.`);
+  }
+});
+var config_default = (0, import_citty2.defineCommand)({
+  meta: {
+    name: "config",
+    description: "Manage mcpman CLI configuration"
+  },
+  subCommands: {
+    set: setCommand,
+    get: getCommand,
+    list: listCommand,
+    reset: resetCommand
+  }
+});
+
+// src/commands/doctor.ts
+init_cjs_shims();
+var import_citty3 = require("citty");
+var import_picocolors3 = __toESM(require("picocolors"), 1);
 
 // src/core/server-inventory.ts
 init_cjs_shims();
@@ -1608,12 +1764,12 @@ async function quickHealthProbe(config, timeoutMs = 3e3) {
 
 // src/commands/doctor.ts
 var CHECK_ICON = {
-  pass: import_picocolors2.default.green("\u2713"),
-  fail: import_picocolors2.default.red("\u2717"),
-  skip: import_picocolors2.default.dim("-"),
-  warn: import_picocolors2.default.yellow("\u26A0")
+  pass: import_picocolors3.default.green("\u2713"),
+  fail: import_picocolors3.default.red("\u2717"),
+  skip: import_picocolors3.default.dim("-"),
+  warn: import_picocolors3.default.yellow("\u26A0")
 };
-var doctor_default = (0, import_citty2.defineCommand)({
+var doctor_default = (0, import_citty3.defineCommand)({
   meta: {
     name: "doctor",
     description: "Check MCP server health and configuration"
@@ -1626,10 +1782,10 @@ var doctor_default = (0, import_citty2.defineCommand)({
     }
   },
   async run({ args }) {
-    console.log(import_picocolors2.default.bold("\n  mcpman doctor\n"));
+    console.log(import_picocolors3.default.bold("\n  mcpman doctor\n"));
     const servers = await getInstalledServers();
     if (servers.length === 0) {
-      console.log(import_picocolors2.default.dim("  No MCP servers installed. Run mcpman install <server> to get started."));
+      console.log(import_picocolors3.default.dim("  No MCP servers installed. Run mcpman install <server> to get started."));
       return;
     }
     const tasks = servers.map((s) => () => checkServerHealth(s.name, s.config));
@@ -1641,14 +1797,14 @@ var doctor_default = (0, import_citty2.defineCommand)({
       if (result.status === "healthy") passed++;
       else failed++;
     }
-    console.log(import_picocolors2.default.dim("  " + "\u2500".repeat(50)));
+    console.log(import_picocolors3.default.dim("  " + "\u2500".repeat(50)));
     const parts = [];
-    if (passed > 0) parts.push(import_picocolors2.default.green(`${passed} healthy`));
-    if (failed > 0) parts.push(import_picocolors2.default.red(`${failed} unhealthy`));
+    if (passed > 0) parts.push(import_picocolors3.default.green(`${passed} healthy`));
+    if (failed > 0) parts.push(import_picocolors3.default.red(`${failed} unhealthy`));
     console.log(`  Summary: ${parts.join(", ")}`);
     if (failed > 0) {
       if (!args.fix) {
-        console.log(import_picocolors2.default.dim(`  Run ${import_picocolors2.default.cyan("mcpman doctor --fix")} for fix suggestions.
+        console.log(import_picocolors3.default.dim(`  Run ${import_picocolors3.default.cyan("mcpman doctor --fix")} for fix suggestions.
 `));
       }
       process.exit(1);
@@ -1657,13 +1813,13 @@ var doctor_default = (0, import_citty2.defineCommand)({
   }
 });
 function printServerResult(result, showFix) {
-  const icon = result.status === "healthy" ? import_picocolors2.default.green("\u25CF") : import_picocolors2.default.red("\u25CF");
-  console.log(`  ${icon} ${import_picocolors2.default.bold(result.serverName)}`);
+  const icon = result.status === "healthy" ? import_picocolors3.default.green("\u25CF") : import_picocolors3.default.red("\u25CF");
+  console.log(`  ${icon} ${import_picocolors3.default.bold(result.serverName)}`);
   for (const check of result.checks) {
     const checkIcon = check.skipped ? CHECK_ICON.skip : check.passed ? CHECK_ICON.pass : CHECK_ICON.fail;
     console.log(`    ${checkIcon} ${check.name}: ${check.message}`);
     if (showFix && !check.passed && !check.skipped && check.fix) {
-      console.log(`      ${import_picocolors2.default.yellow("\u2192")} Fix: ${import_picocolors2.default.cyan(check.fix)}`);
+      console.log(`      ${import_picocolors3.default.yellow("\u2192")} Fix: ${import_picocolors3.default.cyan(check.fix)}`);
     }
   }
   console.log();
@@ -1672,11 +1828,11 @@ async function runParallel(tasks, concurrency) {
   const results = [];
   const executing = /* @__PURE__ */ new Set();
   for (const task of tasks) {
-    const p11 = task().then((r) => {
+    const p12 = task().then((r) => {
       results.push(r);
-      executing.delete(p11);
+      executing.delete(p12);
     });
-    executing.add(p11);
+    executing.add(p12);
     if (executing.size >= concurrency) {
       await Promise.race(executing);
     }
@@ -1685,12 +1841,177 @@ async function runParallel(tasks, concurrency) {
   return results;
 }
 
+// src/commands/info.ts
+init_cjs_shims();
+var import_citty4 = require("citty");
+var import_picocolors4 = __toESM(require("picocolors"), 1);
+var import_nanospinner2 = require("nanospinner");
+
+// src/core/package-info.ts
+init_cjs_shims();
+init_trust_scorer();
+async function buildInfo(name, entry, source = "npm") {
+  const resolvedSource = entry?.source ?? source;
+  let weeklyDownloads = 0;
+  let maintainerCount = 0;
+  let packageAge = 0;
+  let lastPublish = "";
+  let deprecated = false;
+  let trustScore = null;
+  let riskLevel = "UNKNOWN";
+  if (resolvedSource === "npm") {
+    const metadata = await fetchNpmMetadata(name);
+    if (!metadata && !entry) {
+      return null;
+    }
+    if (metadata) {
+      weeklyDownloads = metadata.weeklyDownloads;
+      maintainerCount = metadata.maintainerCount;
+      packageAge = metadata.packageAge;
+      lastPublish = metadata.lastPublish;
+      deprecated = metadata.deprecated;
+      const scored = computeTrustScore(metadata, []);
+      trustScore = scored.score;
+      riskLevel = scored.riskLevel;
+    }
+  }
+  return {
+    name,
+    version: entry?.version ?? "unknown",
+    description: "",
+    source: resolvedSource,
+    runtime: entry?.runtime ?? "node",
+    envVars: entry?.envVars ?? [],
+    weeklyDownloads,
+    maintainerCount,
+    packageAge,
+    lastPublish,
+    deprecated,
+    trustScore,
+    riskLevel,
+    installedClients: entry?.clients ?? [],
+    isInstalled: entry !== null
+  };
+}
+async function getPackageInfo(serverName) {
+  const lockfile = readLockfile();
+  const entry = lockfile.servers[serverName] ?? null;
+  return buildInfo(serverName, entry);
+}
+
+// src/commands/info.ts
+function colorRisk2(score, riskLevel) {
+  const label = score !== null ? `${score}/100 (${riskLevel})` : riskLevel;
+  if (riskLevel === "LOW") return import_picocolors4.default.green(label);
+  if (riskLevel === "MEDIUM") return import_picocolors4.default.yellow(label);
+  if (riskLevel === "HIGH") return import_picocolors4.default.red(label);
+  if (riskLevel === "CRITICAL") return import_picocolors4.default.bold(import_picocolors4.default.red(label));
+  return import_picocolors4.default.dim(label);
+}
+function formatDaysAgo(isoDate) {
+  if (!isoDate) return "unknown";
+  const days = Math.floor((Date.now() - new Date(isoDate).getTime()) / 864e5);
+  if (days === 0) return "today";
+  if (days === 1) return "1 day ago";
+  return `${days} days ago`;
+}
+function printInfo(info2) {
+  const installedBadge = info2.isInstalled ? import_picocolors4.default.green(" [installed]") : import_picocolors4.default.dim(" [not installed]");
+  console.log();
+  console.log(import_picocolors4.default.bold(`  ${info2.name}@${info2.version}`) + installedBadge);
+  console.log(import_picocolors4.default.dim("  " + "\u2500".repeat(60)));
+  console.log(`  ${import_picocolors4.default.dim("Source:")}   ${info2.source}`);
+  console.log(`  ${import_picocolors4.default.dim("Runtime:")}  ${info2.runtime}`);
+  if (info2.description) {
+    console.log(`  ${import_picocolors4.default.dim("Description:")} ${info2.description}`);
+  }
+  if (info2.deprecated) {
+    console.log(`  ${import_picocolors4.default.red("[DEPRECATED]")} This package is deprecated`);
+  }
+  console.log();
+  console.log(`  ${import_picocolors4.default.bold("Trust & Security")}`);
+  console.log(`  ${import_picocolors4.default.dim("Trust score:")}   ${colorRisk2(info2.trustScore, info2.riskLevel)}`);
+  if (info2.source === "npm") {
+    console.log(
+      `  ${import_picocolors4.default.dim("Downloads:")}    ${info2.weeklyDownloads.toLocaleString()}/week  ${import_picocolors4.default.dim("|")}  ${import_picocolors4.default.dim("Age:")} ${info2.packageAge}d  ${import_picocolors4.default.dim("|")}  ${import_picocolors4.default.dim("Maintainers:")} ${info2.maintainerCount}`
+    );
+    if (info2.lastPublish) {
+      console.log(`  ${import_picocolors4.default.dim("Last publish:")} ${formatDaysAgo(info2.lastPublish)}`);
+    }
+  } else {
+    console.log(import_picocolors4.default.dim("  (Trust data available for npm packages only)"));
+  }
+  console.log();
+  console.log(`  ${import_picocolors4.default.bold("Environment Variables")}`);
+  if (info2.envVars.length > 0) {
+    for (const env of info2.envVars) {
+      console.log(`    ${import_picocolors4.default.cyan("\u2022")} ${env}`);
+    }
+  } else {
+    console.log(import_picocolors4.default.dim("    none required"));
+  }
+  console.log();
+  console.log(`  ${import_picocolors4.default.bold("Installed Clients")}`);
+  if (info2.installedClients.length > 0) {
+    for (const client of info2.installedClients) {
+      console.log(`    ${import_picocolors4.default.green("\u2713")} ${client}`);
+    }
+  } else {
+    console.log(import_picocolors4.default.dim("    Not installed in any client"));
+  }
+  console.log();
+  console.log(import_picocolors4.default.dim("  " + "\u2500".repeat(60)));
+  console.log();
+}
+var info_default = (0, import_citty4.defineCommand)({
+  meta: {
+    name: "info",
+    description: "Show detailed metadata for an MCP server (installed or from registry)"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name (e.g. @modelcontextprotocol/server-filesystem)",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output results as JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const spinner5 = (0, import_nanospinner2.createSpinner)(`Fetching info for ${args.server}...`).start();
+    let info2;
+    try {
+      info2 = await getPackageInfo(args.server);
+    } catch (err) {
+      spinner5.error({ text: "Failed to fetch package info" });
+      console.error(import_picocolors4.default.red(String(err)));
+      process.exit(1);
+    }
+    if (!info2) {
+      spinner5.error({ text: `Package not found: ${args.server}` });
+      console.log(import_picocolors4.default.dim(`
+  "${args.server}" was not found in the npm registry or your lockfile.
+`));
+      process.exit(1);
+    }
+    spinner5.success({ text: `Found ${args.server}` });
+    if (args.json) {
+      console.log(JSON.stringify(info2, null, 2));
+      return;
+    }
+    printInfo(info2);
+  }
+});
+
 // src/commands/init.ts
 init_cjs_shims();
-var import_citty3 = require("citty");
-var p2 = __toESM(require("@clack/prompts"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var init_default = (0, import_citty3.defineCommand)({
+var import_citty5 = require("citty");
+var p3 = __toESM(require("@clack/prompts"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var init_default = (0, import_citty5.defineCommand)({
   meta: {
     name: "init",
     description: "Initialize mcpman.lock in the current project"
@@ -1705,17 +2026,17 @@ var init_default = (0, import_citty3.defineCommand)({
   },
   async run({ args }) {
     const nonInteractive = args.yes || !process.stdout.isTTY;
-    p2.intro("mcpman init");
-    const targetPath = import_node_path5.default.join(process.cwd(), LOCKFILE_NAME);
+    p3.intro("mcpman init");
+    const targetPath = import_node_path6.default.join(process.cwd(), LOCKFILE_NAME);
     const existing = findLockfile();
     if (existing) {
       if (nonInteractive) {
-        p2.log.warn(`Lockfile already exists: ${existing} \u2014 overwriting (non-interactive).`);
+        p3.log.warn(`Lockfile already exists: ${existing} \u2014 overwriting (non-interactive).`);
       } else {
-        p2.log.warn(`Lockfile already exists: ${existing}`);
-        const overwrite = await p2.confirm({ message: "Overwrite?" });
-        if (p2.isCancel(overwrite) || !overwrite) {
-          p2.outro("Cancelled.");
+        p3.log.warn(`Lockfile already exists: ${existing}`);
+        const overwrite = await p3.confirm({ message: "Overwrite?" });
+        if (p3.isCancel(overwrite) || !overwrite) {
+          p3.outro("Cancelled.");
           return;
         }
       }
@@ -1725,7 +2046,7 @@ var init_default = (0, import_citty3.defineCommand)({
       const mod = await Promise.resolve().then(() => (init_client_detector(), client_detector_exports));
       clients = await mod.getInstalledClients();
     } catch {
-      p2.log.warn("Could not detect AI clients \u2014 creating empty lockfile.");
+      p3.log.warn("Could not detect AI clients \u2014 creating empty lockfile.");
     }
     const clientServers = [];
     for (const client of clients) {
@@ -1739,26 +2060,26 @@ var init_default = (0, import_citty3.defineCommand)({
     }
     createEmptyLockfile(targetPath);
     if (clientServers.length === 0) {
-      p2.log.info("No existing servers found in any client config.");
-      p2.outro(`Created ${LOCKFILE_NAME} \u2014 add it to version control!`);
+      p3.log.info("No existing servers found in any client config.");
+      p3.outro(`Created ${LOCKFILE_NAME} \u2014 add it to version control!`);
       return;
     }
     let selected;
     if (nonInteractive) {
       selected = clientServers.map((cs) => cs.client.type);
-      p2.log.info(`Non-interactive mode: importing all ${clientServers.length} client(s).`);
+      p3.log.info(`Non-interactive mode: importing all ${clientServers.length} client(s).`);
     } else {
       const options = clientServers.map((cs) => ({
         value: cs.client.type,
         label: `${cs.client.displayName} (${Object.keys(cs.servers).length} servers)`
       }));
-      const toImport = await p2.multiselect({
+      const toImport = await p3.multiselect({
         message: "Import existing servers into lockfile?",
         options,
         required: false
       });
-      if (p2.isCancel(toImport)) {
-        p2.outro(`Created empty ${LOCKFILE_NAME}`);
+      if (p3.isCancel(toImport)) {
+        p3.outro(`Created empty ${LOCKFILE_NAME}`);
         return;
       }
       selected = toImport;
@@ -1784,7 +2105,7 @@ var init_default = (0, import_citty3.defineCommand)({
         importCount++;
       }
     }
-    p2.outro(
+    p3.outro(
       `Created ${LOCKFILE_NAME} with ${importCount} server(s) \u2014 commit to version control!`
     );
   }
@@ -1792,15 +2113,15 @@ var init_default = (0, import_citty3.defineCommand)({
 
 // src/commands/install.ts
 init_cjs_shims();
-var import_citty4 = require("citty");
+var import_citty6 = require("citty");
 
 // src/core/installer.ts
 init_cjs_shims();
-var p5 = __toESM(require("@clack/prompts"), 1);
+var p6 = __toESM(require("@clack/prompts"), 1);
 
 // src/core/installer-vault-helpers.ts
 init_cjs_shims();
-var p4 = __toESM(require("@clack/prompts"), 1);
+var p5 = __toESM(require("@clack/prompts"), 1);
 init_vault_service();
 async function tryLoadVaultSecrets(serverName) {
   try {
@@ -1818,17 +2139,17 @@ async function offerVaultSave(serverName, newVars, yes) {
   if (Object.keys(newVars).length === 0) return;
   if (yes) return;
   try {
-    const save = await p4.confirm({
+    const save = await p5.confirm({
       message: `Save ${Object.keys(newVars).length} env var(s) to encrypted vault for future installs?`
     });
-    if (p4.isCancel(save) || !save) return;
+    if (p5.isCancel(save) || !save) return;
     const password2 = await getMasterPassword();
     for (const [key, value] of Object.entries(newVars)) {
       setSecret(serverName, key, value, password2);
     }
-    p4.log.success(`Credentials saved to vault for '${serverName}'`);
+    p5.log.success(`Credentials saved to vault for '${serverName}'`);
   } catch (err) {
-    p4.log.warn(`Could not save to vault: ${err instanceof Error ? err.message : String(err)}`);
+    p5.log.warn(`Could not save to vault: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 
@@ -1842,43 +2163,43 @@ async function loadClients2() {
   }
 }
 async function installServer(input, options = {}) {
-  p5.intro("mcpman install");
-  const spinner5 = p5.spinner();
+  p6.intro("mcpman install");
+  const spinner5 = p6.spinner();
   spinner5.start("Resolving server...");
   let metadata;
   try {
     metadata = await resolveServer(input);
   } catch (err) {
     spinner5.stop("Resolution failed");
-    p5.log.error(err instanceof Error ? err.message : String(err));
+    p6.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
   spinner5.stop(`Found: ${metadata.name}@${metadata.version}`);
   const clients = await loadClients2();
   if (clients.length === 0) {
-    p5.log.warn("No supported AI clients detected on this machine.");
-    p5.log.info("Supported: Claude Desktop, Cursor, VS Code, Windsurf");
+    p6.log.warn("No supported AI clients detected on this machine.");
+    p6.log.info("Supported: Claude Desktop, Cursor, VS Code, Windsurf");
     process.exit(1);
   }
   let selectedClients;
   if (options.client) {
     const found = clients.find((c) => c.type === options.client || c.displayName.toLowerCase() === options.client?.toLowerCase());
     if (!found) {
-      p5.log.error(`Client '${options.client}' not found or not installed.`);
-      p5.log.info(`Available: ${clients.map((c) => c.type).join(", ")}`);
+      p6.log.error(`Client '${options.client}' not found or not installed.`);
+      p6.log.info(`Available: ${clients.map((c) => c.type).join(", ")}`);
       process.exit(1);
     }
     selectedClients = [found];
   } else if (options.yes || clients.length === 1) {
     selectedClients = clients;
   } else {
-    const chosen = await p5.multiselect({
+    const chosen = await p6.multiselect({
       message: "Install to which client(s)?",
       options: clients.map((c) => ({ value: c.type, label: c.displayName })),
       required: true
     });
-    if (p5.isCancel(chosen)) {
-      p5.outro("Cancelled.");
+    if (p6.isCancel(chosen)) {
+      p6.outro("Cancelled.");
       process.exit(0);
     }
     selectedClients = clients.filter((c) => chosen.includes(c.type));
@@ -1893,13 +2214,13 @@ async function installServer(input, options = {}) {
       collectedEnv[envVar.name] = envVar.default;
       continue;
     }
-    const val = await p5.text({
+    const val = await p6.text({
       message: `${envVar.name}${envVar.description ? ` \u2014 ${envVar.description}` : ""}`,
       placeholder: envVar.default ?? "",
       validate: (v) => envVar.required && !v ? "Required" : void 0
     });
-    if (p5.isCancel(val)) {
-      p5.outro("Cancelled.");
+    if (p6.isCancel(val)) {
+      p6.outro("Cancelled.");
       process.exit(0);
     }
     collectedEnv[envVar.name] = val;
@@ -1918,7 +2239,7 @@ async function installServer(input, options = {}) {
       clientTypes.push(client.type);
     } catch (err) {
       spinner5.stop("Partial failure");
-      p5.log.warn(`Failed to write to ${client.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+      p6.log.warn(`Failed to write to ${client.displayName}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   spinner5.stop("Config written");
@@ -1937,14 +2258,14 @@ async function installServer(input, options = {}) {
     clients: clientTypes
   });
   const lockPath = findLockfile() ?? "mcpman.lock (global)";
-  p5.log.success(`Lockfile updated: ${lockPath}`);
+  p6.log.success(`Lockfile updated: ${lockPath}`);
   await offerVaultSave(metadata.name, newlyEnteredVars, options.yes ?? false);
-  p5.outro(`${metadata.name}@${metadata.version} installed to ${clientTypes.join(", ")}`);
+  p6.outro(`${metadata.name}@${metadata.version} installed to ${clientTypes.join(", ")}`);
 }
 
 // src/utils/logger.ts
 init_cjs_shims();
-var import_picocolors3 = __toESM(require("picocolors"), 1);
+var import_picocolors5 = __toESM(require("picocolors"), 1);
 var noColor = process.env.NO_COLOR !== void 0 || process.argv.includes("--no-color");
 var isVerbose = process.argv.includes("--verbose");
 var isJson = process.argv.includes("--json");
@@ -1953,19 +2274,19 @@ function colorize(fn, text2) {
 }
 function info(message) {
   if (isJson) return;
-  console.log(`${colorize(import_picocolors3.default.cyan, "i")} ${message}`);
+  console.log(`${colorize(import_picocolors5.default.cyan, "i")} ${message}`);
 }
 function error(message) {
   if (isJson) return;
-  console.error(`${colorize(import_picocolors3.default.red, "\u2717")} ${message}`);
+  console.error(`${colorize(import_picocolors5.default.red, "\u2717")} ${message}`);
 }
 function json(data) {
   console.log(JSON.stringify(data, null, 2));
 }
 
 // src/commands/install.ts
-var p6 = __toESM(require("@clack/prompts"), 1);
-var install_default = (0, import_citty4.defineCommand)({
+var p7 = __toESM(require("@clack/prompts"), 1);
+var install_default = (0, import_citty6.defineCommand)({
   meta: {
     name: "install",
     description: "Install an MCP server into one or more AI clients"
@@ -2014,8 +2335,8 @@ async function restoreFromLockfile() {
     info("Lockfile is empty \u2014 nothing to restore.");
     return;
   }
-  p6.intro(`mcpman install (restore from ${lockPath})`);
-  p6.log.info(`Restoring ${entries.length} server(s)...`);
+  p7.intro(`mcpman install (restore from ${lockPath})`);
+  p7.log.info(`Restoring ${entries.length} server(s)...`);
   for (const [name, entry] of entries) {
     const input = entry.source === "smithery" ? `smithery:${name}` : entry.source === "github" ? entry.resolved : name;
     await installServer(input, {
@@ -2023,19 +2344,19 @@ async function restoreFromLockfile() {
       yes: true
     });
   }
-  p6.outro("Restore complete.");
+  p7.outro("Restore complete.");
 }
 
 // src/commands/list.ts
 init_cjs_shims();
-var import_citty5 = require("citty");
-var import_picocolors4 = __toESM(require("picocolors"), 1);
+var import_citty7 = require("citty");
+var import_picocolors6 = __toESM(require("picocolors"), 1);
 var STATUS_ICON = {
-  healthy: import_picocolors4.default.green("\u25CF"),
-  unhealthy: import_picocolors4.default.red("\u25CF"),
-  unknown: import_picocolors4.default.dim("\u25CB")
+  healthy: import_picocolors6.default.green("\u25CF"),
+  unhealthy: import_picocolors6.default.red("\u25CF"),
+  unknown: import_picocolors6.default.dim("\u25CB")
 };
-var list_default = (0, import_citty5.defineCommand)({
+var list_default = (0, import_citty7.defineCommand)({
   meta: {
     name: "list",
     description: "List installed MCP servers"
@@ -2055,7 +2376,7 @@ var list_default = (0, import_citty5.defineCommand)({
     const servers = await getInstalledServers(args.client);
     if (servers.length === 0) {
       const filter = args.client ? ` for client "${args.client}"` : "";
-      console.log(import_picocolors4.default.dim(`No MCP servers installed${filter}. Run ${import_picocolors4.default.cyan("mcpman install <server>")} to get started.`));
+      console.log(import_picocolors6.default.dim(`No MCP servers installed${filter}. Run ${import_picocolors6.default.cyan("mcpman install <server>")} to get started.`));
       return;
     }
     const withStatus = await Promise.all(
@@ -2079,8 +2400,8 @@ var list_default = (0, import_citty5.defineCommand)({
     const nameWidth = Math.max(4, ...withStatus.map((s) => s.name.length));
     const clientsWidth = Math.max(7, ...withStatus.map((s) => formatClients(s.clients).length));
     const header = `  ${pad("NAME", nameWidth)}  ${pad("CLIENT(S)", clientsWidth)}  ${pad("COMMAND", 20)}  STATUS`;
-    console.log(import_picocolors4.default.dim(header));
-    console.log(import_picocolors4.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientsWidth)}  ${"-".repeat(20)}  ------`));
+    console.log(import_picocolors6.default.dim(header));
+    console.log(import_picocolors6.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientsWidth)}  ${"-".repeat(20)}  ------`));
     for (const s of withStatus) {
       const icon = STATUS_ICON[s.status];
       const clientsStr = formatClients(s.clients);
@@ -2088,7 +2409,7 @@ var list_default = (0, import_citty5.defineCommand)({
       console.log(`  ${pad(s.name, nameWidth)}  ${pad(clientsStr, clientsWidth)}  ${pad(cmdStr, 20)}  ${icon} ${s.status}`);
     }
     const clientSet = new Set(withStatus.flatMap((s) => s.clients));
-    console.log(import_picocolors4.default.dim(`
+    console.log(import_picocolors6.default.dim(`
   ${withStatus.length} server${withStatus.length !== 1 ? "s" : ""} \xB7 ${clientSet.size} client${clientSet.size !== 1 ? "s" : ""}`));
   }
 });
@@ -2110,9 +2431,9 @@ function formatClients(clients) {
 
 // src/commands/remove.ts
 init_cjs_shims();
-var import_citty6 = require("citty");
-var p7 = __toESM(require("@clack/prompts"), 1);
-var import_picocolors5 = __toESM(require("picocolors"), 1);
+var import_citty8 = require("citty");
+var p8 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors7 = __toESM(require("picocolors"), 1);
 init_client_detector();
 var CLIENT_DISPLAY2 = {
   "claude-desktop": "Claude",
@@ -2123,7 +2444,7 @@ var CLIENT_DISPLAY2 = {
 function clientDisplayName(type) {
   return CLIENT_DISPLAY2[type] ?? type;
 }
-var remove_default = (0, import_citty6.defineCommand)({
+var remove_default = (0, import_citty8.defineCommand)({
   meta: {
     name: "remove",
     description: "Remove an MCP server from one or more AI clients"
@@ -2150,17 +2471,17 @@ var remove_default = (0, import_citty6.defineCommand)({
     }
   },
   async run({ args }) {
-    p7.intro(import_picocolors5.default.bold("mcpman remove"));
+    p8.intro(import_picocolors7.default.bold("mcpman remove"));
     const serverName = args.server;
     const servers = await getInstalledServers();
     const match = servers.find((s) => s.name === serverName);
     if (!match) {
-      p7.log.warn(`Server "${serverName}" is not installed.`);
+      p8.log.warn(`Server "${serverName}" is not installed.`);
       const similar = servers.filter((s) => s.name.includes(serverName) || serverName.includes(s.name));
       if (similar.length > 0) {
-        p7.log.info(`Did you mean: ${similar.map((s) => import_picocolors5.default.cyan(s.name)).join(", ")}?`);
+        p8.log.info(`Did you mean: ${similar.map((s) => import_picocolors7.default.cyan(s.name)).join(", ")}?`);
       }
-      p7.outro("Nothing to remove.");
+      p8.outro("Nothing to remove.");
       return;
     }
     let targetClients;
@@ -2168,15 +2489,15 @@ var remove_default = (0, import_citty6.defineCommand)({
       targetClients = match.clients;
     } else if (args.client) {
       if (!match.clients.includes(args.client)) {
-        p7.log.warn(`Server "${serverName}" is not installed in client "${args.client}".`);
-        p7.outro("Nothing to remove.");
+        p8.log.warn(`Server "${serverName}" is not installed in client "${args.client}".`);
+        p8.outro("Nothing to remove.");
         return;
       }
       targetClients = [args.client];
     } else if (match.clients.length === 1) {
       targetClients = match.clients;
     } else {
-      const selected = await p7.multiselect({
+      const selected = await p8.multiselect({
         message: `Remove "${serverName}" from which clients?`,
         options: match.clients.map((c) => ({
           value: c,
@@ -2184,19 +2505,19 @@ var remove_default = (0, import_citty6.defineCommand)({
         })),
         required: true
       });
-      if (p7.isCancel(selected)) {
-        p7.outro("Cancelled.");
+      if (p8.isCancel(selected)) {
+        p8.outro("Cancelled.");
         process.exit(0);
       }
       targetClients = selected;
     }
     if (!args.yes) {
       const clientNames = targetClients.map(clientDisplayName).join(", ");
-      const confirmed = await p7.confirm({
-        message: `Remove ${import_picocolors5.default.cyan(serverName)} from ${import_picocolors5.default.yellow(clientNames)}?`
+      const confirmed = await p8.confirm({
+        message: `Remove ${import_picocolors7.default.cyan(serverName)} from ${import_picocolors7.default.yellow(clientNames)}?`
       });
-      if (p7.isCancel(confirmed) || !confirmed) {
-        p7.outro("Cancelled.");
+      if (p8.isCancel(confirmed) || !confirmed) {
+        p8.outro("Cancelled.");
         return;
       }
     }
@@ -2210,26 +2531,273 @@ var remove_default = (0, import_citty6.defineCommand)({
       }
       try {
         await handler.removeServer(serverName);
-        p7.log.success(`Removed from ${clientDisplayName(clientType)}`);
+        p8.log.success(`Removed from ${clientDisplayName(clientType)}`);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         errors.push(`${clientDisplayName(clientType)}: ${msg}`);
       }
     }
     if (errors.length > 0) {
-      for (const e of errors) p7.log.error(e);
-      p7.outro(import_picocolors5.default.red("Completed with errors."));
+      for (const e of errors) p8.log.error(e);
+      p8.outro(import_picocolors7.default.red("Completed with errors."));
+      process.exit(1);
+    }
+    p8.outro(import_picocolors7.default.green(`Removed "${serverName}" successfully.`));
+  }
+});
+
+// src/commands/run.ts
+init_cjs_shims();
+var import_citty9 = require("citty");
+var import_node_child_process3 = require("child_process");
+var import_picocolors8 = __toESM(require("picocolors"), 1);
+init_vault_service();
+var run_default = (0, import_citty9.defineCommand)({
+  meta: {
+    name: "run",
+    description: "Run an installed MCP server with vault secrets injected"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name to run (as installed in lockfile)",
+      required: true
+    },
+    env: {
+      type: "string",
+      description: "Override env var KEY=VAL (repeatable)",
+      alias: "e"
+    }
+  },
+  async run({ args }) {
+    const serverName = args.server;
+    const lockfile = readLockfile();
+    const entry = lockfile.servers[serverName];
+    if (!entry) {
+      console.error(import_picocolors8.default.red(`  Error: Server '${serverName}' is not installed.`));
+      console.error(import_picocolors8.default.dim(`  Run ${import_picocolors8.default.cyan("mcpman install <server>")} to install it first.`));
       process.exit(1);
     }
-    p7.outro(import_picocolors5.default.green(`Removed "${serverName}" successfully.`));
+    const lockfileEnv = parseEnvFlags(entry.envVars);
+    const vaultEnv = await loadVaultSecrets(serverName);
+    const cliEnv = parseEnvFlags(args.env);
+    const finalEnv = {
+      ...process.env,
+      ...lockfileEnv,
+      ...vaultEnv,
+      ...cliEnv
+    };
+    console.log(import_picocolors8.default.dim(`  Running ${import_picocolors8.default.cyan(serverName)}...`));
+    const child = (0, import_node_child_process3.spawn)(entry.command, entry.args, {
+      env: finalEnv,
+      stdio: "inherit"
+    });
+    const forwardSignal = (signal) => {
+      if (!child.killed) {
+        child.kill(signal);
+      }
+    };
+    process.on("SIGINT", () => forwardSignal("SIGINT"));
+    process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+    await new Promise((resolve) => {
+      child.on("close", (code) => {
+        process.exit(code ?? 0);
+        resolve();
+      });
+      child.on("error", (err) => {
+        console.error(import_picocolors8.default.red(`  Failed to start '${serverName}': ${err.message}`));
+        process.exit(1);
+        resolve();
+      });
+    });
+  }
+});
+async function loadVaultSecrets(serverName) {
+  try {
+    const entries = listSecrets(serverName);
+    if (entries.length === 0 || entries[0].keys.length === 0) {
+      return {};
+    }
+    const password2 = await getMasterPassword();
+    return getSecretsForServer(serverName, password2);
+  } catch {
+    console.warn(import_picocolors8.default.yellow("  Warning: Could not load vault secrets, continuing without them."));
+    return {};
+  }
+}
+
+// src/commands/search.ts
+init_cjs_shims();
+var import_citty10 = require("citty");
+var import_picocolors9 = __toESM(require("picocolors"), 1);
+var import_nanospinner3 = require("nanospinner");
+
+// src/core/registry-search.ts
+init_cjs_shims();
+var SEARCH_TIMEOUT_MS = 1e4;
+async function searchNpm(query, limit = 20) {
+  const cap = Math.min(limit, 100);
+  const url = `https://registry.npmjs.org/-/v1/search?text=mcp+${encodeURIComponent(query)}&size=${cap}`;
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const objects = Array.isArray(data["objects"]) ? data["objects"] : [];
+    return objects.map((obj) => {
+      const pkg = obj["package"] ?? {};
+      const dl = obj["downloads"];
+      return {
+        name: typeof pkg["name"] === "string" ? pkg["name"] : "",
+        description: typeof pkg["description"] === "string" ? pkg["description"] : "",
+        version: typeof pkg["version"] === "string" ? pkg["version"] : "",
+        date: typeof pkg["date"] === "string" ? pkg["date"] : "",
+        downloads: typeof dl?.["weekly"] === "number" ? dl["weekly"] : 0,
+        keywords: Array.isArray(pkg["keywords"]) ? pkg["keywords"] : []
+      };
+    }).filter((r) => r.name !== "");
+  } catch {
+    return [];
+  }
+}
+async function searchSmithery(query, limit = 20) {
+  const cap = Math.min(limit, 100);
+  const url = `https://api.smithery.ai/v1/servers?q=${encodeURIComponent(query)}&limit=${cap}`;
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    const servers = Array.isArray(data["servers"]) ? data["servers"] : [];
+    return servers.map((s) => ({
+      name: typeof s["name"] === "string" ? s["name"] : "",
+      description: typeof s["description"] === "string" ? s["description"] : "",
+      version: typeof s["version"] === "string" ? s["version"] : "latest",
+      runtime: typeof s["runtime"] === "string" ? s["runtime"] : "node"
+    })).filter((r) => r.name !== "");
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/search.ts
+function truncate2(s, max) {
+  return s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
+}
+function pad2(s, width) {
+  return s.length >= width ? s : s + " ".repeat(width - s.length);
+}
+function highlightMatch(name, query) {
+  const idx = name.toLowerCase().indexOf(query.toLowerCase());
+  if (idx === -1) return name;
+  return name.slice(0, idx) + import_picocolors9.default.yellow(name.slice(idx, idx + query.length)) + name.slice(idx + query.length);
+}
+function formatDownloads(n) {
+  if (!n) return import_picocolors9.default.dim("\u2014");
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+function printNpmResults(results, query) {
+  const nameWidth = Math.max(4, ...results.map((r) => r.name.length), 20);
+  const verWidth = Math.max(7, ...results.map((r) => r.version.length));
+  const dlWidth = 9;
+  const descMax = 50;
+  const header = `  ${pad2("NAME", nameWidth)}  ${pad2("VERSION", verWidth)}  ${pad2("DOWNLOADS", dlWidth)}  DESCRIPTION`;
+  console.log(import_picocolors9.default.dim(header));
+  console.log(import_picocolors9.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(verWidth)}  ${"-".repeat(dlWidth)}  ${"-".repeat(descMax)}`));
+  for (const r of results) {
+    const name = highlightMatch(pad2(r.name, nameWidth), query);
+    const ver = pad2(r.version, verWidth);
+    const dl = pad2(formatDownloads(r.downloads), dlWidth);
+    const desc = truncate2(r.description || import_picocolors9.default.dim("(no description)"), descMax);
+    console.log(`  ${name}  ${import_picocolors9.default.dim(ver)}  ${dl}  ${desc}`);
+  }
+}
+function printSmitheryResults(results, query) {
+  const nameWidth = Math.max(4, ...results.map((r) => r.name.length), 20);
+  const verWidth = Math.max(7, ...results.map((r) => r.version.length));
+  const descMax = 50;
+  const header = `  ${pad2("NAME", nameWidth)}  ${pad2("VERSION", verWidth)}  DESCRIPTION`;
+  console.log(import_picocolors9.default.dim(header));
+  console.log(import_picocolors9.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(verWidth)}  ${"-".repeat(descMax)}`));
+  for (const r of results) {
+    const name = highlightMatch(pad2(r.name, nameWidth), query);
+    const ver = pad2(r.version, verWidth);
+    const desc = truncate2(r.description || import_picocolors9.default.dim("(no description)"), descMax);
+    console.log(`  ${name}  ${import_picocolors9.default.dim(ver)}  ${desc}`);
+  }
+}
+var search_default = (0, import_citty10.defineCommand)({
+  meta: {
+    name: "search",
+    description: "Search for MCP servers on npm or Smithery registry"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    },
+    registry: {
+      type: "string",
+      description: "Registry to search: npm or smithery (default: npm)",
+      default: "npm"
+    },
+    limit: {
+      type: "string",
+      description: "Maximum number of results (default: 20, max: 100)",
+      default: "20"
+    }
+  },
+  async run({ args }) {
+    const query = args.query;
+    const registry = args.registry.toLowerCase();
+    const limit = Math.min(Math.max(1, Number.parseInt(args.limit, 10) || 20), 100);
+    if (registry !== "npm" && registry !== "smithery") {
+      console.error(import_picocolors9.default.red(`  Unknown registry "${registry}". Use "npm" or "smithery".`));
+      process.exit(1);
+    }
+    const spinner5 = (0, import_nanospinner3.createSpinner)(`Searching ${registry} for "${query}"...`).start();
+    if (registry === "npm") {
+      const results2 = await searchNpm(query, limit);
+      spinner5.stop();
+      if (results2.length === 0) {
+        console.log(import_picocolors9.default.dim(`
+  No results found for "${query}" on npm.
+`));
+        return;
+      }
+      console.log(import_picocolors9.default.bold(`
+  mcpman search \u2014 npm (${results2.length} result${results2.length !== 1 ? "s" : ""})
+`));
+      printNpmResults(results2, query);
+      console.log(import_picocolors9.default.dim(`
+  Install with: mcpman install <name>
+`));
+      return;
+    }
+    const results = await searchSmithery(query, limit);
+    spinner5.stop();
+    if (results.length === 0) {
+      console.log(import_picocolors9.default.dim(`
+  No results found for "${query}" on Smithery.
+`));
+      return;
+    }
+    console.log(import_picocolors9.default.bold(`
+  mcpman search \u2014 Smithery (${results.length} result${results.length !== 1 ? "s" : ""})
+`));
+    printSmitheryResults(results, query);
+    console.log(import_picocolors9.default.dim(`
+  Install with: mcpman install <name>
+`));
   }
 });
 
 // src/commands/secrets.ts
 init_cjs_shims();
-var import_citty7 = require("citty");
-var import_picocolors6 = __toESM(require("picocolors"), 1);
-var p8 = __toESM(require("@clack/prompts"), 1);
+var import_citty11 = require("citty");
+var import_picocolors10 = __toESM(require("picocolors"), 1);
+var p9 = __toESM(require("@clack/prompts"), 1);
 init_vault_service();
 function maskValue(value) {
   if (value.length <= 8) return "***";
@@ -2240,7 +2808,7 @@ function parseKeyValue(input) {
   if (idx <= 0) return null;
   return { key: input.slice(0, idx), value: input.slice(idx + 1) };
 }
-var setCommand = (0, import_citty7.defineCommand)({
+var setCommand2 = (0, import_citty11.defineCommand)({
   meta: { name: "set", description: "Store an encrypted secret for a server" },
   args: {
     server: {
@@ -2257,30 +2825,30 @@ var setCommand = (0, import_citty7.defineCommand)({
   async run({ args }) {
     const parsed = parseKeyValue(args.keyvalue);
     if (!parsed) {
-      console.error(import_picocolors6.default.red("\u2717") + " Invalid format. Expected KEY=VALUE");
+      console.error(import_picocolors10.default.red("\u2717") + " Invalid format. Expected KEY=VALUE");
       process.exit(1);
     }
-    p8.intro(import_picocolors6.default.cyan("mcpman secrets set"));
+    p9.intro(import_picocolors10.default.cyan("mcpman secrets set"));
     const isNew = listSecrets(args.server).length === 0 || !listSecrets(args.server)[0]?.keys.includes(parsed.key);
     const vaultPath = (await Promise.resolve().then(() => (init_vault_service(), vault_service_exports))).getVaultPath();
     const vaultExists = (await import("fs")).existsSync(vaultPath);
     const password2 = await getMasterPassword(!vaultExists && isNew);
-    const spin = p8.spinner();
+    const spin = p9.spinner();
     spin.start("Encrypting secret...");
     try {
       setSecret(args.server, parsed.key, parsed.value, password2);
       spin.stop(
-        `${import_picocolors6.default.green("\u2713")} Stored ${import_picocolors6.default.bold(parsed.key)} for ${import_picocolors6.default.cyan(args.server)}`
+        `${import_picocolors10.default.green("\u2713")} Stored ${import_picocolors10.default.bold(parsed.key)} for ${import_picocolors10.default.cyan(args.server)}`
       );
     } catch (err) {
-      spin.stop(import_picocolors6.default.red("\u2717") + " Failed to store secret");
-      console.error(import_picocolors6.default.dim(String(err)));
+      spin.stop(import_picocolors10.default.red("\u2717") + " Failed to store secret");
+      console.error(import_picocolors10.default.dim(String(err)));
       process.exit(1);
     }
-    p8.outro(import_picocolors6.default.dim("Secret encrypted and saved to vault."));
+    p9.outro(import_picocolors10.default.dim("Secret encrypted and saved to vault."));
   }
 });
-var listCommand = (0, import_citty7.defineCommand)({
+var listCommand2 = (0, import_citty11.defineCommand)({
   meta: { name: "list", description: "List secret keys stored in the vault" },
   args: {
     server: {
@@ -2292,23 +2860,23 @@ var listCommand = (0, import_citty7.defineCommand)({
   async run({ args }) {
     const results = listSecrets(args.server || void 0);
     if (results.length === 0) {
-      const filter = args.server ? ` for ${import_picocolors6.default.cyan(args.server)}` : "";
-      console.log(import_picocolors6.default.dim(`No secrets stored${filter}.`));
+      const filter = args.server ? ` for ${import_picocolors10.default.cyan(args.server)}` : "";
+      console.log(import_picocolors10.default.dim(`No secrets stored${filter}.`));
       return;
     }
     console.log("");
     for (const { server, keys } of results) {
-      console.log(import_picocolors6.default.bold(import_picocolors6.default.cyan(server)));
+      console.log(import_picocolors10.default.bold(import_picocolors10.default.cyan(server)));
       for (const key of keys) {
-        console.log(`  ${import_picocolors6.default.green("\u25CF")} ${import_picocolors6.default.bold(key)}  ${import_picocolors6.default.dim(maskValue("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022"))}`);
+        console.log(`  ${import_picocolors10.default.green("\u25CF")} ${import_picocolors10.default.bold(key)}  ${import_picocolors10.default.dim(maskValue("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022"))}`);
       }
       console.log("");
     }
     const total = results.reduce((n, r) => n + r.keys.length, 0);
-    console.log(import_picocolors6.default.dim(`  ${total} secret${total !== 1 ? "s" : ""} in ${results.length} server${results.length !== 1 ? "s" : ""}`));
+    console.log(import_picocolors10.default.dim(`  ${total} secret${total !== 1 ? "s" : ""} in ${results.length} server${results.length !== 1 ? "s" : ""}`));
   }
 });
-var removeCommand = (0, import_citty7.defineCommand)({
+var removeCommand = (0, import_citty11.defineCommand)({
   meta: { name: "remove", description: "Delete a secret from the vault" },
   args: {
     server: {
@@ -2323,41 +2891,41 @@ var removeCommand = (0, import_citty7.defineCommand)({
     }
   },
   async run({ args }) {
-    const confirmed = await p8.confirm({
-      message: `Remove ${import_picocolors6.default.bold(args.key)} from ${import_picocolors6.default.cyan(args.server)}?`,
+    const confirmed = await p9.confirm({
+      message: `Remove ${import_picocolors10.default.bold(args.key)} from ${import_picocolors10.default.cyan(args.server)}?`,
       initialValue: false
     });
-    if (p8.isCancel(confirmed) || !confirmed) {
-      p8.cancel("Cancelled.");
+    if (p9.isCancel(confirmed) || !confirmed) {
+      p9.cancel("Cancelled.");
       return;
     }
     try {
       removeSecret(args.server, args.key);
-      console.log(`${import_picocolors6.default.green("\u2713")} Removed ${import_picocolors6.default.bold(args.key)} from ${import_picocolors6.default.cyan(args.server)}`);
+      console.log(`${import_picocolors10.default.green("\u2713")} Removed ${import_picocolors10.default.bold(args.key)} from ${import_picocolors10.default.cyan(args.server)}`);
     } catch (err) {
-      console.error(import_picocolors6.default.red("\u2717") + " Failed to remove secret");
-      console.error(import_picocolors6.default.dim(String(err)));
+      console.error(import_picocolors10.default.red("\u2717") + " Failed to remove secret");
+      console.error(import_picocolors10.default.dim(String(err)));
       process.exit(1);
     }
   }
 });
-var secrets_default = (0, import_citty7.defineCommand)({
+var secrets_default = (0, import_citty11.defineCommand)({
   meta: {
     name: "secrets",
     description: "Manage encrypted secrets for MCP servers"
   },
   subCommands: {
-    set: setCommand,
-    list: listCommand,
+    set: setCommand2,
+    list: listCommand2,
     remove: removeCommand
   }
 });
 
 // src/commands/sync.ts
 init_cjs_shims();
-var import_citty8 = require("citty");
-var p9 = __toESM(require("@clack/prompts"), 1);
-var import_picocolors7 = __toESM(require("picocolors"), 1);
+var import_citty12 = require("citty");
+var p10 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors11 = __toESM(require("picocolors"), 1);
 
 // src/core/config-diff.ts
 init_cjs_shims();
@@ -2510,7 +3078,7 @@ var CLIENT_DISPLAY3 = {
   vscode: "VS Code",
   windsurf: "Windsurf"
 };
-var sync_default = (0, import_citty8.defineCommand)({
+var sync_default = (0, import_citty12.defineCommand)({
   meta: {
     name: "sync",
     description: "Sync MCP server configs across all detected AI clients"
@@ -2537,28 +3105,28 @@ var sync_default = (0, import_citty8.defineCommand)({
     }
   },
   async run({ args }) {
-    p9.intro(`${import_picocolors7.default.cyan("mcpman sync")}`);
+    p10.intro(`${import_picocolors11.default.cyan("mcpman sync")}`);
     const sourceClient = args.source;
     if (sourceClient && !VALID_CLIENTS.includes(sourceClient)) {
-      p9.log.error(`Invalid --source "${sourceClient}". Must be one of: ${VALID_CLIENTS.join(", ")}`);
+      p10.log.error(`Invalid --source "${sourceClient}". Must be one of: ${VALID_CLIENTS.join(", ")}`);
       process.exit(1);
     }
-    const spinner5 = p9.spinner();
+    const spinner5 = p10.spinner();
     spinner5.start("Detecting clients and reading configs...");
     const { configs, handlers } = await getClientConfigs();
     spinner5.stop(`Found ${configs.size} client(s)`);
     if (configs.size === 0) {
-      p9.log.warn("No AI clients detected. Install Claude Desktop, Cursor, VS Code, or Windsurf first.");
+      p10.log.warn("No AI clients detected. Install Claude Desktop, Cursor, VS Code, or Windsurf first.");
       process.exit(0);
     }
     const diffOptions = { remove: args.remove };
     let actions;
     if (sourceClient) {
       if (!configs.has(sourceClient)) {
-        p9.log.error(`Source client "${sourceClient}" is not detected or its config is unreadable.`);
+        p10.log.error(`Source client "${sourceClient}" is not detected or its config is unreadable.`);
         process.exit(1);
       }
-      p9.log.info(`Using ${CLIENT_DISPLAY3[sourceClient]} as source of truth`);
+      p10.log.info(`Using ${CLIENT_DISPLAY3[sourceClient]} as source of truth`);
       actions = computeDiffFromClient(sourceClient, configs, diffOptions);
     } else {
       const lockfile = readLockfile();
@@ -2569,32 +3137,32 @@ var sync_default = (0, import_citty8.defineCommand)({
     const extraCount = actions.filter((a) => a.action === "extra").length;
     const removeCount = actions.filter((a) => a.action === "remove").length;
     if (addCount === 0 && removeCount === 0 && extraCount === 0) {
-      p9.outro(import_picocolors7.default.green("All clients are in sync."));
+      p10.outro(import_picocolors11.default.green("All clients are in sync."));
       process.exit(0);
     }
     const parts = [];
-    if (addCount > 0) parts.push(import_picocolors7.default.green(`${addCount} to add`));
-    if (removeCount > 0) parts.push(import_picocolors7.default.red(`${removeCount} to remove`));
-    if (extraCount > 0) parts.push(import_picocolors7.default.yellow(`${extraCount} extra (informational)`));
-    p9.log.info(parts.join("  \xB7  "));
+    if (addCount > 0) parts.push(import_picocolors11.default.green(`${addCount} to add`));
+    if (removeCount > 0) parts.push(import_picocolors11.default.red(`${removeCount} to remove`));
+    if (extraCount > 0) parts.push(import_picocolors11.default.yellow(`${extraCount} extra (informational)`));
+    p10.log.info(parts.join("  \xB7  "));
     if (args["dry-run"]) {
-      p9.outro(import_picocolors7.default.dim("Dry run \u2014 no changes applied."));
+      p10.outro(import_picocolors11.default.dim("Dry run \u2014 no changes applied."));
       process.exit(1);
     }
     if (addCount === 0 && removeCount === 0) {
-      p9.outro(import_picocolors7.default.dim("No additions needed. Extra servers left untouched."));
+      p10.outro(import_picocolors11.default.dim("No additions needed. Extra servers left untouched."));
       process.exit(1);
     }
     if (!args.yes) {
       const actionParts = [];
       if (addCount > 0) actionParts.push(`${addCount} addition(s)`);
       if (removeCount > 0) actionParts.push(`${removeCount} removal(s)`);
-      const confirmed = await p9.confirm({
+      const confirmed = await p10.confirm({
         message: `Apply ${actionParts.join(" and ")} to client configs?`,
         initialValue: true
       });
-      if (p9.isCancel(confirmed) || !confirmed) {
-        p9.outro(import_picocolors7.default.dim("Cancelled \u2014 no changes applied."));
+      if (p10.isCancel(confirmed) || !confirmed) {
+        p10.outro(import_picocolors11.default.dim("Cancelled \u2014 no changes applied."));
         process.exit(0);
       }
     }
@@ -2602,74 +3170,74 @@ var sync_default = (0, import_citty8.defineCommand)({
     const result = await applySyncActions(actions, handlers);
     spinner5.stop("Done");
     if (result.applied > 0) {
-      p9.log.success(`Added ${result.applied} server(s) to client configs.`);
+      p10.log.success(`Added ${result.applied} server(s) to client configs.`);
     }
     if (result.removed > 0) {
-      p9.log.success(`Removed ${result.removed} server(s) from client configs.`);
+      p10.log.success(`Removed ${result.removed} server(s) from client configs.`);
     }
     if (result.failed > 0) {
       for (const e of result.errors) {
-        p9.log.error(`Failed to sync "${e.server}" on ${e.client}: ${e.error}`);
+        p10.log.error(`Failed to sync "${e.server}" on ${e.client}: ${e.error}`);
       }
     }
-    p9.outro(result.failed === 0 ? import_picocolors7.default.green("Sync complete.") : import_picocolors7.default.yellow("Sync complete with errors."));
+    p10.outro(result.failed === 0 ? import_picocolors11.default.green("Sync complete.") : import_picocolors11.default.yellow("Sync complete with errors."));
     process.exit(result.failed > 0 ? 1 : 0);
   }
 });
 function printDiffTable(actions) {
   if (actions.length === 0) {
-    p9.log.info("No actions to display.");
+    p10.log.info("No actions to display.");
     return;
   }
   const nameWidth = Math.max(6, ...actions.map((a) => a.server.length));
   const clientWidth = Math.max(6, ...actions.map((a) => CLIENT_DISPLAY3[a.client]?.length ?? a.client.length));
-  const header = `  ${pad2("SERVER", nameWidth)}  ${pad2("CLIENT", clientWidth)}  STATUS`;
-  console.log(import_picocolors7.default.dim(header));
-  console.log(import_picocolors7.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientWidth)}  ------`));
+  const header = `  ${pad3("SERVER", nameWidth)}  ${pad3("CLIENT", clientWidth)}  STATUS`;
+  console.log(import_picocolors11.default.dim(header));
+  console.log(import_picocolors11.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientWidth)}  ------`));
   for (const action of actions) {
     const clientDisplay = CLIENT_DISPLAY3[action.client] ?? action.client;
     const [icon, statusText] = formatAction(action.action);
-    console.log(`  ${pad2(action.server, nameWidth)}  ${pad2(clientDisplay, clientWidth)}  ${icon} ${statusText}`);
+    console.log(`  ${pad3(action.server, nameWidth)}  ${pad3(clientDisplay, clientWidth)}  ${icon} ${statusText}`);
   }
   console.log("");
 }
 function formatAction(action) {
   switch (action) {
     case "add":
-      return [import_picocolors7.default.green("+"), import_picocolors7.default.green("missing \u2014 will add")];
+      return [import_picocolors11.default.green("+"), import_picocolors11.default.green("missing \u2014 will add")];
     case "extra":
-      return [import_picocolors7.default.yellow("?"), import_picocolors7.default.yellow("extra (not in lockfile)")];
+      return [import_picocolors11.default.yellow("?"), import_picocolors11.default.yellow("extra (not in lockfile)")];
     case "remove":
-      return [import_picocolors7.default.red("\u2013"), import_picocolors7.default.red("extra \u2014 will remove")];
+      return [import_picocolors11.default.red("\u2013"), import_picocolors11.default.red("extra \u2014 will remove")];
     case "ok":
-      return [import_picocolors7.default.dim("\xB7"), import_picocolors7.default.dim("in sync")];
+      return [import_picocolors11.default.dim("\xB7"), import_picocolors11.default.dim("in sync")];
   }
 }
-function pad2(s, width) {
+function pad3(s, width) {
   return s.length >= width ? s : s + " ".repeat(width - s.length);
 }
 
 // src/commands/update.ts
 init_cjs_shims();
-var import_citty9 = require("citty");
-var p10 = __toESM(require("@clack/prompts"), 1);
-var import_picocolors9 = __toESM(require("picocolors"), 1);
+var import_citty13 = require("citty");
+var p11 = __toESM(require("@clack/prompts"), 1);
+var import_picocolors13 = __toESM(require("picocolors"), 1);
 
 // src/core/update-notifier.ts
 init_cjs_shims();
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_node_os5 = __toESM(require("os"), 1);
-var import_picocolors8 = __toESM(require("picocolors"), 1);
-var CACHE_FILE = import_node_path7.default.join(import_node_os5.default.homedir(), ".mcpman", ".update-check");
+var import_picocolors12 = __toESM(require("picocolors"), 1);
+var CACHE_FILE = import_node_path8.default.join(import_node_os5.default.homedir(), ".mcpman", ".update-check");
 var TTL_MS = 24 * 60 * 60 * 1e3;
 function writeUpdateCache(data) {
   try {
-    const dir = import_node_path7.default.dirname(CACHE_FILE);
-    if (!import_node_fs5.default.existsSync(dir)) import_node_fs5.default.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path8.default.dirname(CACHE_FILE);
+    if (!import_node_fs6.default.existsSync(dir)) import_node_fs6.default.mkdirSync(dir, { recursive: true });
     const tmp = `${CACHE_FILE}.tmp`;
-    import_node_fs5.default.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-    import_node_fs5.default.renameSync(tmp, CACHE_FILE);
+    import_node_fs6.default.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+    import_node_fs6.default.renameSync(tmp, CACHE_FILE);
   } catch {
   }
 }
@@ -2692,19 +3260,19 @@ function printTable(updates) {
     "LATEST".padEnd(VER_W),
     "STATUS"
   ].join("  ");
-  console.log(import_picocolors9.default.bold(`
+  console.log(import_picocolors13.default.bold(`
   ${header}`));
-  console.log(import_picocolors9.default.dim(`  ${"\u2500".repeat(NAME_W + VER_W * 2 + 20)}`));
+  console.log(import_picocolors13.default.dim(`  ${"\u2500".repeat(NAME_W + VER_W * 2 + 20)}`));
   for (const u of updates) {
     const nameCol = u.server.slice(0, NAME_W).padEnd(NAME_W);
     const curCol = u.currentVersion.padEnd(VER_W);
     const latCol = u.latestVersion.padEnd(VER_W);
-    const statusCol = u.hasUpdate ? import_picocolors9.default.yellow(`Update available${u.updateType ? ` [${u.updateType}]` : ""}`) : import_picocolors9.default.green("Up to date");
+    const statusCol = u.hasUpdate ? import_picocolors13.default.yellow(`Update available${u.updateType ? ` [${u.updateType}]` : ""}`) : import_picocolors13.default.green("Up to date");
     console.log(`  ${nameCol}  ${curCol}  ${latCol}  ${statusCol}`);
   }
   console.log();
 }
-var update_default = (0, import_citty9.defineCommand)({
+var update_default = (0, import_citty13.defineCommand)({
   meta: {
     name: "update",
     description: "Check for and apply updates to installed MCP servers"
@@ -2743,7 +3311,7 @@ var update_default = (0, import_citty9.defineCommand)({
       }
       process.exit(1);
     }
-    const spinner5 = p10.spinner();
+    const spinner5 = p11.spinner();
     spinner5.start("Checking versions...");
     let updates;
     try {
@@ -2765,27 +3333,27 @@ var update_default = (0, import_citty9.defineCommand)({
     printTable(updates);
     const outdated = updates.filter((u) => u.hasUpdate);
     if (outdated.length === 0) {
-      console.log(import_picocolors9.default.green("  All servers are up to date."));
+      console.log(import_picocolors13.default.green("  All servers are up to date."));
       return;
     }
     if (args.check) {
-      console.log(import_picocolors9.default.yellow(`  ${outdated.length} update(s) available. Run mcpman update to apply.`));
+      console.log(import_picocolors13.default.yellow(`  ${outdated.length} update(s) available. Run mcpman update to apply.`));
       return;
     }
     if (!args.yes) {
-      const confirmed = await p10.confirm({
+      const confirmed = await p11.confirm({
         message: `Apply ${outdated.length} update(s)?`,
         initialValue: true
       });
-      if (p10.isCancel(confirmed) || !confirmed) {
-        p10.outro("Cancelled.");
+      if (p11.isCancel(confirmed) || !confirmed) {
+        p11.outro("Cancelled.");
         return;
       }
     }
     const clients = await loadClients3();
     let successCount = 0;
     for (const update of outdated) {
-      const s = p10.spinner();
+      const s = p11.spinner();
       s.start(`Updating ${update.server}...`);
       const result = await applyServerUpdate(
         update.server,
@@ -2793,23 +3361,23 @@ var update_default = (0, import_citty9.defineCommand)({
         clients
       );
       if (result.success) {
-        s.stop(`${import_picocolors9.default.green("\u2713")} ${update.server}: ${result.fromVersion} \u2192 ${result.toVersion}`);
+        s.stop(`${import_picocolors13.default.green("\u2713")} ${update.server}: ${result.fromVersion} \u2192 ${result.toVersion}`);
         successCount++;
       } else {
-        s.stop(`${import_picocolors9.default.red("\u2717")} ${update.server}: ${result.error}`);
+        s.stop(`${import_picocolors13.default.red("\u2717")} ${update.server}: ${result.error}`);
       }
     }
     const freshLockfile = readLockfile(resolveLockfilePath());
     const freshUpdates = await checkAllVersions(freshLockfile);
     writeUpdateCache({ lastCheck: (/* @__PURE__ */ new Date()).toISOString(), updates: freshUpdates });
-    p10.outro(`${successCount} of ${outdated.length} server(s) updated.`);
+    p11.outro(`${successCount} of ${outdated.length} server(s) updated.`);
   }
 });
 
 // src/utils/constants.ts
 init_cjs_shims();
 var APP_NAME = "mcpman";
-var APP_VERSION = "0.3.0";
+var APP_VERSION = "0.4.0";
 var APP_DESCRIPTION = "The package manager for MCP servers";
 
 // src/index.ts
@@ -2817,7 +3385,7 @@ process.on("SIGINT", () => {
   console.log("\nAborted.");
   process.exit(130);
 });
-var main = (0, import_citty10.defineCommand)({
+var main = (0, import_citty14.defineCommand)({
   meta: {
     name: APP_NAME,
     version: APP_VERSION,
@@ -2832,7 +3400,11 @@ var main = (0, import_citty10.defineCommand)({
     secrets: secrets_default,
     sync: sync_default,
     audit: audit_default,
-    update: update_default
+    update: update_default,
+    config: config_default,
+    search: search_default,
+    info: info_default,
+    run: run_default
   }
 });
-(0, import_citty10.runMain)(main);
+(0, import_citty14.runMain)(main);