mcpman 0.2.0 → 0.3.0

package/dist/index.js

@@ -4,6 +4,7 @@ import {
 } from "./chunk-QY22QTBR.js";
 import {
   getMasterPassword,
+  getSecretsForServer,
   listSecrets,
   removeSecret,
   setSecret
@@ -14,6 +15,7 @@ import { defineCommand as defineCommand10, runMain } from "citty";
 
 // src/commands/audit.ts
 import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { createSpinner } from "nanospinner";
 
@@ -209,17 +211,324 @@ async function scanAllServers(servers, concurrency = 3) {
   const results = [];
   const executing = /* @__PURE__ */ new Set();
   for (const [name, entry] of entries) {
-    const p8 = scanServer(name, entry).then((r) => {
+    const p10 = scanServer(name, entry).then((r) => {
       results.push(r);
-      executing.delete(p8);
+      executing.delete(p10);
     });
-    executing.add(p8);
+    executing.add(p10);
     if (executing.size >= concurrency) await Promise.race(executing);
   }
   await Promise.all(executing);
   return results;
 }
 
+// src/core/version-checker.ts
+function compareVersions(a, b) {
+  const aParts = a.replace(/^v/, "").split(".").map(Number);
+  const bParts = b.replace(/^v/, "").split(".").map(Number);
+  const len = Math.max(aParts.length, bParts.length);
+  for (let i = 0; i < len; i++) {
+    const aN = aParts[i] ?? 0;
+    const bN = bParts[i] ?? 0;
+    if (Number.isNaN(aN) || Number.isNaN(bN)) return 0;
+    if (aN < bN) return -1;
+    if (aN > bN) return 1;
+  }
+  return 0;
+}
+function detectUpdateType(current, latest) {
+  const cParts = current.replace(/^v/, "").split(".").map(Number);
+  const lParts = latest.replace(/^v/, "").split(".").map(Number);
+  if ((lParts[0] ?? 0) > (cParts[0] ?? 0)) return "major";
+  if ((lParts[1] ?? 0) > (cParts[1] ?? 0)) return "minor";
+  return "patch";
+}
+async function fetchNpmLatest(packageName) {
+  try {
+    const res = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
+      {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(8e3)
+      }
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchSmitheryLatest(name) {
+  try {
+    const res = await fetch(
+      `https://registry.smithery.ai/servers/${encodeURIComponent(name)}`,
+      {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(8e3)
+      }
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchGithubLatest(resolved) {
+  const match = resolved.match(/github\.com\/([^/]+)\/([^/]+)/);
+  if (!match) return null;
+  const [, owner, repo] = match;
+  try {
+    const res = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/releases/latest`,
+      {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(8e3)
+      }
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    return typeof data.tag_name === "string" ? data.tag_name.replace(/^v/, "") : null;
+  } catch {
+    return null;
+  }
+}
+async function checkVersion(name, lockEntry) {
+  const current = lockEntry.version;
+  let latest = null;
+  if (lockEntry.source === "npm") {
+    latest = await fetchNpmLatest(name);
+  } else if (lockEntry.source === "smithery") {
+    latest = await fetchSmitheryLatest(name);
+  } else if (lockEntry.source === "github") {
+    latest = await fetchGithubLatest(lockEntry.resolved);
+  }
+  if (!latest || latest === current) {
+    return {
+      server: name,
+      source: lockEntry.source,
+      currentVersion: current,
+      latestVersion: latest ?? current,
+      hasUpdate: false
+    };
+  }
+  const hasUpdate = compareVersions(current, latest) === -1;
+  return {
+    server: name,
+    source: lockEntry.source,
+    currentVersion: current,
+    latestVersion: latest,
+    hasUpdate,
+    updateType: hasUpdate ? detectUpdateType(current, latest) : void 0
+  };
+}
+async function checkAllVersions(lockfile) {
+  const entries = Object.entries(lockfile.servers);
+  if (entries.length === 0) return [];
+  const results = [];
+  const executing = /* @__PURE__ */ new Set();
+  for (const [name, entry] of entries) {
+    const p10 = checkVersion(name, entry).then((r) => {
+      results.push(r);
+      executing.delete(p10);
+    });
+    executing.add(p10);
+    if (executing.size >= 5) {
+      await Promise.race(executing);
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
+
+// src/core/registry.ts
+import { createHash } from "crypto";
+function computeIntegrity(resolvedUrl) {
+  const hash = createHash("sha512").update(resolvedUrl).digest("base64");
+  return `sha512-${hash}`;
+}
+async function resolveFromSmithery(name) {
+  const url = `https://registry.smithery.ai/servers/${encodeURIComponent(name)}`;
+  let data;
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (res.status === 404) {
+      throw new Error(`Server '${name}' not found on Smithery registry`);
+    }
+    if (!res.ok) {
+      throw new Error(`Smithery API error: ${res.status}`);
+    }
+    data = await res.json();
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) throw err;
+    throw new Error(
+      `Cannot reach Smithery registry: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const version = typeof data.version === "string" ? data.version : "latest";
+  const command = typeof data.command === "string" ? data.command : "npx";
+  const args = Array.isArray(data.args) ? data.args : ["-y", `${name}@${version}`];
+  const envVars = Array.isArray(data.envVars) ? data.envVars : [];
+  const resolved = typeof data.resolved === "string" ? data.resolved : `smithery:${name}@${version}`;
+  return {
+    name,
+    version,
+    description: typeof data.description === "string" ? data.description : "",
+    runtime: "node",
+    command,
+    args,
+    envVars,
+    resolved
+  };
+}
+async function resolveFromNpm(packageName) {
+  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+  let data;
+  try {
+    const res = await fetch(url, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (res.status === 404) {
+      throw new Error(`Package '${packageName}' not found on npm`);
+    }
+    if (!res.ok) {
+      throw new Error(`npm registry error: ${res.status}`);
+    }
+    data = await res.json();
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("not found")) throw err;
+    throw new Error(
+      `Cannot reach npm registry: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const version = typeof data.version === "string" ? data.version : "latest";
+  const resolved = `https://registry.npmjs.org/${packageName}/-/${packageName.replace(/^@[^/]+\//, "")}-${version}.tgz`;
+  const mcpField = data.mcp && typeof data.mcp === "object" ? data.mcp : null;
+  const envVars = mcpField?.envVars ? mcpField.envVars : [];
+  return {
+    name: packageName,
+    version,
+    description: typeof data.description === "string" ? data.description : "",
+    runtime: "node",
+    command: "npx",
+    args: ["-y", `${packageName}@${version}`],
+    envVars,
+    resolved
+  };
+}
+async function resolveFromGitHub(githubUrl) {
+  const match = githubUrl.match(/github\.com\/([^/]+)\/([^/]+)/);
+  if (!match) {
+    throw new Error(`Invalid GitHub URL: ${githubUrl}`);
+  }
+  const [, owner, repo] = match;
+  const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/main/package.json`;
+  let pkgData = {};
+  try {
+    const res = await fetch(rawUrl, { signal: AbortSignal.timeout(8e3) });
+    if (res.ok) {
+      pkgData = await res.json();
+    }
+  } catch {
+  }
+  const version = typeof pkgData.version === "string" ? pkgData.version : "main";
+  const name = typeof pkgData.name === "string" ? pkgData.name : `${owner}/${repo}`;
+  return {
+    name,
+    version,
+    description: typeof pkgData.description === "string" ? pkgData.description : "",
+    runtime: "node",
+    command: "npx",
+    args: ["-y", githubUrl],
+    envVars: [],
+    resolved: githubUrl
+  };
+}
+
+// src/core/server-resolver.ts
+function detectSource(input) {
+  if (input.startsWith("smithery:")) {
+    return { type: "smithery", input: input.slice(9) };
+  }
+  if (input.startsWith("https://github.com/") || input.startsWith("github.com/")) {
+    return { type: "github", input };
+  }
+  return { type: "npm", input };
+}
+function parseEnvFlags(envFlags) {
+  if (!envFlags) return {};
+  const flags = Array.isArray(envFlags) ? envFlags : [envFlags];
+  const result = {};
+  for (const flag of flags) {
+    const idx = flag.indexOf("=");
+    if (idx > 0) {
+      result[flag.slice(0, idx)] = flag.slice(idx + 1);
+    }
+  }
+  return result;
+}
+async function resolveServer(input) {
+  const source = detectSource(input);
+  switch (source.type) {
+    case "smithery":
+      return resolveFromSmithery(source.input);
+    case "github":
+      return resolveFromGitHub(source.input);
+    case "npm":
+      return resolveFromNpm(source.input);
+  }
+}
+
+// src/core/server-updater.ts
+async function applyServerUpdate(serverName, lockEntry, clients) {
+  const fromVersion = lockEntry.version;
+  const input = lockEntry.source === "smithery" ? `smithery:${serverName}` : lockEntry.source === "github" ? lockEntry.resolved : serverName;
+  try {
+    const metadata = await resolveServer(input);
+    const integrity = computeIntegrity(metadata.resolved);
+    addEntry(serverName, {
+      ...lockEntry,
+      version: metadata.version,
+      resolved: metadata.resolved,
+      integrity,
+      command: metadata.command,
+      args: metadata.args,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const targetClients = clients.filter(
+      (c) => lockEntry.clients.includes(c.type)
+    );
+    for (const client of targetClients) {
+      try {
+        await client.addServer(serverName, {
+          command: metadata.command,
+          args: metadata.args
+        });
+      } catch {
+      }
+    }
+    return {
+      server: serverName,
+      success: true,
+      fromVersion,
+      toVersion: metadata.version
+    };
+  } catch (err) {
+    return {
+      server: serverName,
+      success: false,
+      fromVersion,
+      toVersion: fromVersion,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
 // src/commands/audit.ts
 function colorRisk(level, score) {
   const label = score !== null ? `${score}/100 (${level})` : level;
@@ -290,7 +599,12 @@ var audit_default = defineCommand({
     },
     fix: {
       type: "boolean",
-      description: "Show available fix versions for vulnerable packages",
+      description: "Apply updates to fix vulnerable packages",
+      default: false
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmation prompt (use with --fix)",
       default: false
     }
   },
@@ -351,17 +665,110 @@ var audit_default = defineCommand({
   Summary: ${parts.join(" | ")}
 `);
     if (args.fix) {
-      const withVulns = reports.filter((r) => r.vulnerabilities.length > 0);
-      if (withVulns.length > 0) {
-        console.log(pc.bold("  Fix suggestions:"));
-        for (const r of withVulns) {
-          console.log(`    ${pc.cyan("\u2192")} Run ${pc.cyan(`mcpman install ${r.server}@latest`)} to update`);
-        }
-        console.log();
-      }
+      await runAuditFix(reports, lockfile.servers, args.yes);
     }
   }
 });
+async function loadClients() {
+  try {
+    const mod = await import("./client-detector-SUIJSIYM.js");
+    return mod.getInstalledClients();
+  } catch {
+    return [];
+  }
+}
+async function runAuditFix(reports, servers, skipConfirm) {
+  const npmWithVulns = reports.filter(
+    (r) => r.vulnerabilities.length > 0 && r.source === "npm"
+  );
+  const nonNpmWithVulns = reports.filter(
+    (r) => r.vulnerabilities.length > 0 && r.source !== "npm"
+  );
+  if (nonNpmWithVulns.length > 0) {
+    console.log(pc.yellow("  Non-npm servers require manual update:"));
+    for (const r of nonNpmWithVulns) {
+      console.log(`    ${pc.dim("\u2192")} ${r.server} (${r.source})`);
+    }
+    console.log();
+  }
+  if (npmWithVulns.length === 0) {
+    console.log(pc.green("  No fixable vulnerabilities found.\n"));
+    return;
+  }
+  const versionSpinner = createSpinner("Checking for available updates...").start();
+  const versionChecks = await Promise.all(
+    npmWithVulns.map((r) => checkVersion(r.server, servers[r.server]))
+  );
+  versionSpinner.success({ text: "Version check complete" });
+  const updatable = versionChecks.filter((u) => u.hasUpdate);
+  if (updatable.length === 0) {
+    console.log(pc.yellow(
+      "  Vulnerable servers have no newer versions available yet.\n  Allow time for registry to publish fixes.\n"
+    ));
+    return;
+  }
+  console.log(pc.bold(`
+  ${updatable.length} server(s) can be updated to fix vulnerabilities:
+`));
+  for (const u of updatable) {
+    console.log(`    ${pc.cyan("\u2192")} ${u.server}  ${pc.dim(u.currentVersion)} \u2192 ${pc.green(u.latestVersion)}`);
+  }
+  console.log();
+  if (!skipConfirm) {
+    const confirmed = await p.confirm({
+      message: `Update ${updatable.length} vulnerable server(s)?`,
+      initialValue: true
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.outro("Cancelled.");
+      return;
+    }
+  }
+  const clients = await loadClients();
+  let successCount = 0;
+  const results = [];
+  for (const u of updatable) {
+    const s = createSpinner(`Updating ${u.server}...`).start();
+    const result = await applyServerUpdate(u.server, servers[u.server], clients);
+    if (result.success) {
+      s.success({ text: `${pc.green("\u2713")} ${u.server}: ${result.fromVersion} \u2192 ${result.toVersion}` });
+      successCount++;
+    } else {
+      s.error({ text: `${pc.red("\u2717")} ${u.server}: ${result.error}` });
+    }
+    results.push({
+      server: u.server,
+      from: result.fromVersion,
+      to: result.toVersion,
+      ok: result.success,
+      error: result.error
+    });
+  }
+  console.log();
+  if (successCount > 0) {
+    const updatedNames = results.filter((r) => r.ok).map((r) => r.server);
+    const freshLockfile = readLockfile();
+    const rescanSpinner = createSpinner("Re-scanning updated servers...").start();
+    const afterReports = await Promise.all(
+      updatedNames.map((name) => scanServer(name, freshLockfile.servers[name]))
+    );
+    rescanSpinner.success({ text: "Re-scan complete" });
+    console.log(pc.bold("\n  Before / After:\n"));
+    for (const after of afterReports) {
+      const before = reports.find((r) => r.server === after.server);
+      const beforeVulns = before?.vulnerabilities.length ?? 0;
+      const afterVulns = after.vulnerabilities.length;
+      const improved = afterVulns < beforeVulns ? pc.green("improved") : pc.yellow("unchanged");
+      console.log(
+        `    ${pc.bold(after.server)}  vulns: ${beforeVulns} \u2192 ${afterVulns}  [${improved}]`
+      );
+    }
+    console.log();
+  }
+  console.log(`
+  ${successCount} of ${updatable.length} server(s) updated.
+`);
+}
 
 // src/commands/doctor.ts
 import { defineCommand as defineCommand2 } from "citty";
@@ -685,141 +1092,31 @@ function printServerResult(result, showFix) {
     console.log(`    ${checkIcon} ${check.name}: ${check.message}`);
     if (showFix && !check.passed && !check.skipped && check.fix) {
       console.log(`      ${pc2.yellow("\u2192")} Fix: ${pc2.cyan(check.fix)}`);
-    }
-  }
-  console.log();
-}
-async function runParallel(tasks, concurrency) {
-  const results = [];
-  const executing = /* @__PURE__ */ new Set();
-  for (const task of tasks) {
-    const p8 = task().then((r) => {
-      results.push(r);
-      executing.delete(p8);
-    });
-    executing.add(p8);
-    if (executing.size >= concurrency) {
-      await Promise.race(executing);
-    }
-  }
-  await Promise.all(executing);
-  return results;
-}
-
-// src/commands/init.ts
-import { defineCommand as defineCommand3 } from "citty";
-import * as p from "@clack/prompts";
-import path3 from "path";
-
-// src/core/registry.ts
-import { createHash } from "crypto";
-function computeIntegrity(resolvedUrl) {
-  const hash = createHash("sha512").update(resolvedUrl).digest("base64");
-  return `sha512-${hash}`;
-}
-async function resolveFromSmithery(name) {
-  const url = `https://registry.smithery.ai/servers/${encodeURIComponent(name)}`;
-  let data;
-  try {
-    const res = await fetch(url, {
-      headers: { Accept: "application/json" },
-      signal: AbortSignal.timeout(8e3)
-    });
-    if (res.status === 404) {
-      throw new Error(`Server '${name}' not found on Smithery registry`);
-    }
-    if (!res.ok) {
-      throw new Error(`Smithery API error: ${res.status}`);
-    }
-    data = await res.json();
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("not found")) throw err;
-    throw new Error(
-      `Cannot reach Smithery registry: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const version = typeof data.version === "string" ? data.version : "latest";
-  const command = typeof data.command === "string" ? data.command : "npx";
-  const args = Array.isArray(data.args) ? data.args : ["-y", `${name}@${version}`];
-  const envVars = Array.isArray(data.envVars) ? data.envVars : [];
-  const resolved = typeof data.resolved === "string" ? data.resolved : `smithery:${name}@${version}`;
-  return {
-    name,
-    version,
-    description: typeof data.description === "string" ? data.description : "",
-    runtime: "node",
-    command,
-    args,
-    envVars,
-    resolved
-  };
-}
-async function resolveFromNpm(packageName) {
-  const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
-  let data;
-  try {
-    const res = await fetch(url, {
-      headers: { Accept: "application/json" },
-      signal: AbortSignal.timeout(8e3)
-    });
-    if (res.status === 404) {
-      throw new Error(`Package '${packageName}' not found on npm`);
-    }
-    if (!res.ok) {
-      throw new Error(`npm registry error: ${res.status}`);
-    }
-    data = await res.json();
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("not found")) throw err;
-    throw new Error(
-      `Cannot reach npm registry: ${err instanceof Error ? err.message : String(err)}`
-    );
+    }
   }
-  const version = typeof data.version === "string" ? data.version : "latest";
-  const resolved = `https://registry.npmjs.org/${packageName}/-/${packageName.replace(/^@[^/]+\//, "")}-${version}.tgz`;
-  const mcpField = data.mcp && typeof data.mcp === "object" ? data.mcp : null;
-  const envVars = mcpField?.envVars ? mcpField.envVars : [];
-  return {
-    name: packageName,
-    version,
-    description: typeof data.description === "string" ? data.description : "",
-    runtime: "node",
-    command: "npx",
-    args: ["-y", `${packageName}@${version}`],
-    envVars,
-    resolved
-  };
+  console.log();
 }
-async function resolveFromGitHub(githubUrl) {
-  const match = githubUrl.match(/github\.com\/([^/]+)\/([^/]+)/);
-  if (!match) {
-    throw new Error(`Invalid GitHub URL: ${githubUrl}`);
-  }
-  const [, owner, repo] = match;
-  const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/main/package.json`;
-  let pkgData = {};
-  try {
-    const res = await fetch(rawUrl, { signal: AbortSignal.timeout(8e3) });
-    if (res.ok) {
-      pkgData = await res.json();
+async function runParallel(tasks, concurrency) {
+  const results = [];
+  const executing = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    const p10 = task().then((r) => {
+      results.push(r);
+      executing.delete(p10);
+    });
+    executing.add(p10);
+    if (executing.size >= concurrency) {
+      await Promise.race(executing);
     }
-  } catch {
   }
-  const version = typeof pkgData.version === "string" ? pkgData.version : "main";
-  const name = typeof pkgData.name === "string" ? pkgData.name : `${owner}/${repo}`;
-  return {
-    name,
-    version,
-    description: typeof pkgData.description === "string" ? pkgData.description : "",
-    runtime: "node",
-    command: "npx",
-    args: ["-y", githubUrl],
-    envVars: [],
-    resolved: githubUrl
-  };
+  await Promise.all(executing);
+  return results;
 }
 
 // src/commands/init.ts
+import { defineCommand as defineCommand3 } from "citty";
+import * as p2 from "@clack/prompts";
+import path3 from "path";
 var init_default = defineCommand3({
   meta: {
     name: "init",
@@ -835,17 +1132,17 @@ var init_default = defineCommand3({
   },
   async run({ args }) {
     const nonInteractive = args.yes || !process.stdout.isTTY;
-    p.intro("mcpman init");
+    p2.intro("mcpman init");
     const targetPath = path3.join(process.cwd(), LOCKFILE_NAME);
     const existing = findLockfile();
     if (existing) {
       if (nonInteractive) {
-        p.log.warn(`Lockfile already exists: ${existing} \u2014 overwriting (non-interactive).`);
+        p2.log.warn(`Lockfile already exists: ${existing} \u2014 overwriting (non-interactive).`);
       } else {
-        p.log.warn(`Lockfile already exists: ${existing}`);
-        const overwrite = await p.confirm({ message: "Overwrite?" });
-        if (p.isCancel(overwrite) || !overwrite) {
-          p.outro("Cancelled.");
+        p2.log.warn(`Lockfile already exists: ${existing}`);
+        const overwrite = await p2.confirm({ message: "Overwrite?" });
+        if (p2.isCancel(overwrite) || !overwrite) {
+          p2.outro("Cancelled.");
           return;
         }
       }
@@ -855,7 +1152,7 @@ var init_default = defineCommand3({
       const mod = await import("./client-detector-SUIJSIYM.js");
       clients = await mod.getInstalledClients();
     } catch {
-      p.log.warn("Could not detect AI clients \u2014 creating empty lockfile.");
+      p2.log.warn("Could not detect AI clients \u2014 creating empty lockfile.");
     }
     const clientServers = [];
     for (const client of clients) {
@@ -869,26 +1166,26 @@ var init_default = defineCommand3({
     }
     createEmptyLockfile(targetPath);
     if (clientServers.length === 0) {
-      p.log.info("No existing servers found in any client config.");
-      p.outro(`Created ${LOCKFILE_NAME} \u2014 add it to version control!`);
+      p2.log.info("No existing servers found in any client config.");
+      p2.outro(`Created ${LOCKFILE_NAME} \u2014 add it to version control!`);
       return;
     }
     let selected;
     if (nonInteractive) {
       selected = clientServers.map((cs) => cs.client.type);
-      p.log.info(`Non-interactive mode: importing all ${clientServers.length} client(s).`);
+      p2.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 p.multiselect({
+      const toImport = await p2.multiselect({
         message: "Import existing servers into lockfile?",
         options,
         required: false
       });
-      if (p.isCancel(toImport)) {
-        p.outro(`Created empty ${LOCKFILE_NAME}`);
+      if (p2.isCancel(toImport)) {
+        p2.outro(`Created empty ${LOCKFILE_NAME}`);
         return;
       }
       selected = toImport;
@@ -914,7 +1211,7 @@ var init_default = defineCommand3({
         importCount++;
       }
     }
-    p.outro(
+    p2.outro(
       `Created ${LOCKFILE_NAME} with ${importCount} server(s) \u2014 commit to version control!`
     );
   }
@@ -924,44 +1221,42 @@ var init_default = defineCommand3({
 import { defineCommand as defineCommand4 } from "citty";
 
 // src/core/installer.ts
-import * as p2 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 
-// src/core/server-resolver.ts
-function detectSource(input) {
-  if (input.startsWith("smithery:")) {
-    return { type: "smithery", input: input.slice(9) };
-  }
-  if (input.startsWith("https://github.com/") || input.startsWith("github.com/")) {
-    return { type: "github", input };
-  }
-  return { type: "npm", input };
-}
-function parseEnvFlags(envFlags) {
-  if (!envFlags) return {};
-  const flags = Array.isArray(envFlags) ? envFlags : [envFlags];
-  const result = {};
-  for (const flag of flags) {
-    const idx = flag.indexOf("=");
-    if (idx > 0) {
-      result[flag.slice(0, idx)] = flag.slice(idx + 1);
+// src/core/installer-vault-helpers.ts
+import * as p3 from "@clack/prompts";
+async function tryLoadVaultSecrets(serverName) {
+  try {
+    const entries = listSecrets(serverName);
+    if (entries.length === 0 || entries[0].keys.length === 0) {
+      return {};
     }
+    const password = await getMasterPassword();
+    return getSecretsForServer(serverName, password);
+  } catch {
+    return {};
   }
-  return result;
 }
-async function resolveServer(input) {
-  const source = detectSource(input);
-  switch (source.type) {
-    case "smithery":
-      return resolveFromSmithery(source.input);
-    case "github":
-      return resolveFromGitHub(source.input);
-    case "npm":
-      return resolveFromNpm(source.input);
+async function offerVaultSave(serverName, newVars, yes) {
+  if (Object.keys(newVars).length === 0) return;
+  if (yes) return;
+  try {
+    const save = await p3.confirm({
+      message: `Save ${Object.keys(newVars).length} env var(s) to encrypted vault for future installs?`
+    });
+    if (p3.isCancel(save) || !save) return;
+    const password = await getMasterPassword();
+    for (const [key, value] of Object.entries(newVars)) {
+      setSecret(serverName, key, value, password);
+    }
+    p3.log.success(`Credentials saved to vault for '${serverName}'`);
+  } catch (err) {
+    p3.log.warn(`Could not save to vault: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 
 // src/core/installer.ts
-async function loadClients() {
+async function loadClients2() {
   try {
     const mod = await import("./client-detector-SUIJSIYM.js");
     return mod.getInstalledClients();
@@ -970,65 +1265,68 @@ async function loadClients() {
   }
 }
 async function installServer(input, options = {}) {
-  p2.intro("mcpman install");
-  const spinner5 = p2.spinner();
+  p4.intro("mcpman install");
+  const spinner5 = p4.spinner();
   spinner5.start("Resolving server...");
   let metadata;
   try {
     metadata = await resolveServer(input);
   } catch (err) {
     spinner5.stop("Resolution failed");
-    p2.log.error(err instanceof Error ? err.message : String(err));
+    p4.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
   spinner5.stop(`Found: ${metadata.name}@${metadata.version}`);
-  const clients = await loadClients();
+  const clients = await loadClients2();
   if (clients.length === 0) {
-    p2.log.warn("No supported AI clients detected on this machine.");
-    p2.log.info("Supported: Claude Desktop, Cursor, VS Code, Windsurf");
+    p4.log.warn("No supported AI clients detected on this machine.");
+    p4.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) {
-      p2.log.error(`Client '${options.client}' not found or not installed.`);
-      p2.log.info(`Available: ${clients.map((c) => c.type).join(", ")}`);
+      p4.log.error(`Client '${options.client}' not found or not installed.`);
+      p4.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 p2.multiselect({
+    const chosen = await p4.multiselect({
       message: "Install to which client(s)?",
       options: clients.map((c) => ({ value: c.type, label: c.displayName })),
       required: true
     });
-    if (p2.isCancel(chosen)) {
-      p2.outro("Cancelled.");
+    if (p4.isCancel(chosen)) {
+      p4.outro("Cancelled.");
       process.exit(0);
     }
     selectedClients = clients.filter((c) => chosen.includes(c.type));
   }
   const providedEnv = parseEnvFlags(options.env);
-  const collectedEnv = { ...providedEnv };
+  const vaultEnv = await tryLoadVaultSecrets(metadata.name);
+  const collectedEnv = { ...vaultEnv, ...providedEnv };
+  const newlyEnteredVars = {};
   const requiredVars = metadata.envVars.filter((e) => e.required && !(e.name in collectedEnv));
   for (const envVar of requiredVars) {
     if (options.yes && envVar.default) {
       collectedEnv[envVar.name] = envVar.default;
       continue;
     }
-    const val = await p2.text({
+    const val = await p4.text({
       message: `${envVar.name}${envVar.description ? ` \u2014 ${envVar.description}` : ""}`,
       placeholder: envVar.default ?? "",
       validate: (v) => envVar.required && !v ? "Required" : void 0
     });
-    if (p2.isCancel(val)) {
-      p2.outro("Cancelled.");
+    if (p4.isCancel(val)) {
+      p4.outro("Cancelled.");
       process.exit(0);
     }
     collectedEnv[envVar.name] = val;
+    newlyEnteredVars[envVar.name] = val;
   }
   const entry = {
     command: metadata.command,
@@ -1043,7 +1341,7 @@ async function installServer(input, options = {}) {
       clientTypes.push(client.type);
     } catch (err) {
       spinner5.stop("Partial failure");
-      p2.log.warn(`Failed to write to ${client.displayName}: ${err instanceof Error ? err.message : String(err)}`);
+      p4.log.warn(`Failed to write to ${client.displayName}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   spinner5.stop("Config written");
@@ -1062,8 +1360,9 @@ async function installServer(input, options = {}) {
     clients: clientTypes
   });
   const lockPath = findLockfile() ?? "mcpman.lock (global)";
-  p2.log.success(`Lockfile updated: ${lockPath}`);
-  p2.outro(`${metadata.name}@${metadata.version} installed to ${clientTypes.join(", ")}`);
+  p4.log.success(`Lockfile updated: ${lockPath}`);
+  await offerVaultSave(metadata.name, newlyEnteredVars, options.yes ?? false);
+  p4.outro(`${metadata.name}@${metadata.version} installed to ${clientTypes.join(", ")}`);
 }
 
 // src/utils/logger.ts
@@ -1087,7 +1386,7 @@ function json(data) {
 }
 
 // src/commands/install.ts
-import * as p3 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 var install_default = defineCommand4({
   meta: {
     name: "install",
@@ -1137,8 +1436,8 @@ async function restoreFromLockfile() {
     info("Lockfile is empty \u2014 nothing to restore.");
     return;
   }
-  p3.intro(`mcpman install (restore from ${lockPath})`);
-  p3.log.info(`Restoring ${entries.length} server(s)...`);
+  p5.intro(`mcpman install (restore from ${lockPath})`);
+  p5.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, {
@@ -1146,7 +1445,7 @@ async function restoreFromLockfile() {
       yes: true
     });
   }
-  p3.outro("Restore complete.");
+  p5.outro("Restore complete.");
 }
 
 // src/commands/list.ts
@@ -1232,7 +1531,7 @@ function formatClients(clients) {
 
 // src/commands/remove.ts
 import { defineCommand as defineCommand6 } from "citty";
-import * as p4 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import pc5 from "picocolors";
 var CLIENT_DISPLAY2 = {
   "claude-desktop": "Claude",
@@ -1270,17 +1569,17 @@ var remove_default = defineCommand6({
     }
   },
   async run({ args }) {
-    p4.intro(pc5.bold("mcpman remove"));
+    p6.intro(pc5.bold("mcpman remove"));
     const serverName = args.server;
     const servers = await getInstalledServers();
     const match = servers.find((s) => s.name === serverName);
     if (!match) {
-      p4.log.warn(`Server "${serverName}" is not installed.`);
+      p6.log.warn(`Server "${serverName}" is not installed.`);
       const similar = servers.filter((s) => s.name.includes(serverName) || serverName.includes(s.name));
       if (similar.length > 0) {
-        p4.log.info(`Did you mean: ${similar.map((s) => pc5.cyan(s.name)).join(", ")}?`);
+        p6.log.info(`Did you mean: ${similar.map((s) => pc5.cyan(s.name)).join(", ")}?`);
       }
-      p4.outro("Nothing to remove.");
+      p6.outro("Nothing to remove.");
       return;
     }
     let targetClients;
@@ -1288,15 +1587,15 @@ var remove_default = defineCommand6({
       targetClients = match.clients;
     } else if (args.client) {
       if (!match.clients.includes(args.client)) {
-        p4.log.warn(`Server "${serverName}" is not installed in client "${args.client}".`);
-        p4.outro("Nothing to remove.");
+        p6.log.warn(`Server "${serverName}" is not installed in client "${args.client}".`);
+        p6.outro("Nothing to remove.");
         return;
       }
       targetClients = [args.client];
     } else if (match.clients.length === 1) {
       targetClients = match.clients;
     } else {
-      const selected = await p4.multiselect({
+      const selected = await p6.multiselect({
         message: `Remove "${serverName}" from which clients?`,
         options: match.clients.map((c) => ({
           value: c,
@@ -1304,19 +1603,19 @@ var remove_default = defineCommand6({
         })),
         required: true
       });
-      if (p4.isCancel(selected)) {
-        p4.outro("Cancelled.");
+      if (p6.isCancel(selected)) {
+        p6.outro("Cancelled.");
         process.exit(0);
       }
       targetClients = selected;
     }
     if (!args.yes) {
       const clientNames = targetClients.map(clientDisplayName).join(", ");
-      const confirmed = await p4.confirm({
+      const confirmed = await p6.confirm({
         message: `Remove ${pc5.cyan(serverName)} from ${pc5.yellow(clientNames)}?`
       });
-      if (p4.isCancel(confirmed) || !confirmed) {
-        p4.outro("Cancelled.");
+      if (p6.isCancel(confirmed) || !confirmed) {
+        p6.outro("Cancelled.");
         return;
       }
     }
@@ -1330,25 +1629,25 @@ var remove_default = defineCommand6({
       }
       try {
         await handler.removeServer(serverName);
-        p4.log.success(`Removed from ${clientDisplayName(clientType)}`);
+        p6.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) p4.log.error(e);
-      p4.outro(pc5.red("Completed with errors."));
+      for (const e of errors) p6.log.error(e);
+      p6.outro(pc5.red("Completed with errors."));
       process.exit(1);
     }
-    p4.outro(pc5.green(`Removed "${serverName}" successfully.`));
+    p6.outro(pc5.green(`Removed "${serverName}" successfully.`));
   }
 });
 
 // src/commands/secrets.ts
 import { defineCommand as defineCommand7 } from "citty";
 import pc6 from "picocolors";
-import * as p5 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 function maskValue(value) {
   if (value.length <= 8) return "***";
   return `${value.slice(0, 4)}***${value.slice(-3)}`;
@@ -1378,12 +1677,12 @@ var setCommand = defineCommand7({
       console.error(pc6.red("\u2717") + " Invalid format. Expected KEY=VALUE");
       process.exit(1);
     }
-    p5.intro(pc6.cyan("mcpman secrets set"));
+    p7.intro(pc6.cyan("mcpman secrets set"));
     const isNew = listSecrets(args.server).length === 0 || !listSecrets(args.server)[0]?.keys.includes(parsed.key);
     const vaultPath = (await import("./vault-service-UTZAV6N6.js")).getVaultPath();
     const vaultExists = (await import("fs")).existsSync(vaultPath);
     const password = await getMasterPassword(!vaultExists && isNew);
-    const spin = p5.spinner();
+    const spin = p7.spinner();
     spin.start("Encrypting secret...");
     try {
       setSecret(args.server, parsed.key, parsed.value, password);
@@ -1395,7 +1694,7 @@ var setCommand = defineCommand7({
       console.error(pc6.dim(String(err)));
       process.exit(1);
     }
-    p5.outro(pc6.dim("Secret encrypted and saved to vault."));
+    p7.outro(pc6.dim("Secret encrypted and saved to vault."));
   }
 });
 var listCommand = defineCommand7({
@@ -1441,12 +1740,12 @@ var removeCommand = defineCommand7({
     }
   },
   async run({ args }) {
-    const confirmed = await p5.confirm({
+    const confirmed = await p7.confirm({
       message: `Remove ${pc6.bold(args.key)} from ${pc6.cyan(args.server)}?`,
       initialValue: false
     });
-    if (p5.isCancel(confirmed) || !confirmed) {
-      p5.cancel("Cancelled.");
+    if (p7.isCancel(confirmed) || !confirmed) {
+      p7.cancel("Cancelled.");
       return;
     }
     try {
@@ -1473,7 +1772,7 @@ var secrets_default = defineCommand7({
 
 // src/commands/sync.ts
 import { defineCommand as defineCommand8 } from "citty";
-import * as p6 from "@clack/prompts";
+import * as p8 from "@clack/prompts";
 import pc7 from "picocolors";
 
 // src/core/config-diff.ts
@@ -1489,7 +1788,7 @@ function reconstructServerEntry(lockEntry) {
   }
   return entry;
 }
-function computeDiff(lockfile, clientConfigs) {
+function computeDiff(lockfile, clientConfigs, options = {}) {
   const actions = [];
   for (const [server, lockEntry] of Object.entries(lockfile.servers)) {
     for (const client of lockEntry.clients) {
@@ -1507,19 +1806,21 @@ function computeDiff(lockfile, clientConfigs) {
       }
     }
   }
+  const extraAction = options.remove ? "remove" : "extra";
   for (const [client, config] of clientConfigs) {
     for (const server of Object.keys(config.servers)) {
       if (!(server in lockfile.servers)) {
-        actions.push({ server, client, action: "extra" });
+        actions.push({ server, client, action: extraAction });
       }
     }
   }
   return actions;
 }
-function computeDiffFromClient(sourceClient, clientConfigs) {
+function computeDiffFromClient(sourceClient, clientConfigs, options = {}) {
   const actions = [];
   const sourceConfig = clientConfigs.get(sourceClient);
   if (!sourceConfig) return [];
+  const extraAction = options.remove ? "remove" : "extra";
   for (const [client, config] of clientConfigs) {
     if (client === sourceClient) continue;
     for (const [server, entry] of Object.entries(sourceConfig.servers)) {
@@ -1531,7 +1832,7 @@ function computeDiffFromClient(sourceClient, clientConfigs) {
     }
     for (const server of Object.keys(config.servers)) {
       if (!(server in sourceConfig.servers)) {
-        actions.push({ server, client, action: "extra" });
+        actions.push({ server, client, action: extraAction });
       }
     }
   }
@@ -1540,7 +1841,7 @@ function computeDiffFromClient(sourceClient, clientConfigs) {
 
 // src/core/sync-engine.ts
 async function applySyncActions(actions, clients) {
-  const result = { applied: 0, failed: 0, errors: [] };
+  const result = { applied: 0, removed: 0, failed: 0, errors: [] };
   const addActions = actions.filter((a) => a.action === "add" && a.entry);
   for (const action of addActions) {
     const handler = clients.get(action.client);
@@ -1565,6 +1866,30 @@ async function applySyncActions(actions, clients) {
       });
     }
   }
+  const removeActions = actions.filter((a) => a.action === "remove");
+  for (const action of removeActions) {
+    const handler = clients.get(action.client);
+    if (!handler) {
+      result.failed++;
+      result.errors.push({
+        server: action.server,
+        client: action.client,
+        error: "No handler available for client"
+      });
+      continue;
+    }
+    try {
+      await handler.removeServer(action.server);
+      result.removed++;
+    } catch (err) {
+      result.failed++;
+      result.errors.push({
+        server: action.server,
+        client: action.client,
+        error: String(err)
+      });
+    }
+  }
   return result;
 }
 async function getClientConfigs() {
@@ -1609,6 +1934,11 @@ var sync_default = defineCommand8({
       description: "Preview changes without applying them",
       default: false
     },
+    remove: {
+      type: "boolean",
+      description: "Remove extra servers not in lockfile",
+      default: false
+    },
     source: {
       type: "string",
       description: "Use a specific client as source of truth (claude-desktop, cursor, vscode, windsurf)"
@@ -1620,58 +1950,64 @@ var sync_default = defineCommand8({
     }
   },
   async run({ args }) {
-    p6.intro(`${pc7.cyan("mcpman sync")}`);
+    p8.intro(`${pc7.cyan("mcpman sync")}`);
     const sourceClient = args.source;
     if (sourceClient && !VALID_CLIENTS.includes(sourceClient)) {
-      p6.log.error(`Invalid --source "${sourceClient}". Must be one of: ${VALID_CLIENTS.join(", ")}`);
+      p8.log.error(`Invalid --source "${sourceClient}". Must be one of: ${VALID_CLIENTS.join(", ")}`);
       process.exit(1);
     }
-    const spinner5 = p6.spinner();
+    const spinner5 = p8.spinner();
     spinner5.start("Detecting clients and reading configs...");
     const { configs, handlers } = await getClientConfigs();
     spinner5.stop(`Found ${configs.size} client(s)`);
     if (configs.size === 0) {
-      p6.log.warn("No AI clients detected. Install Claude Desktop, Cursor, VS Code, or Windsurf first.");
+      p8.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)) {
-        p6.log.error(`Source client "${sourceClient}" is not detected or its config is unreadable.`);
+        p8.log.error(`Source client "${sourceClient}" is not detected or its config is unreadable.`);
         process.exit(1);
       }
-      p6.log.info(`Using ${CLIENT_DISPLAY3[sourceClient]} as source of truth`);
-      actions = computeDiffFromClient(sourceClient, configs);
+      p8.log.info(`Using ${CLIENT_DISPLAY3[sourceClient]} as source of truth`);
+      actions = computeDiffFromClient(sourceClient, configs, diffOptions);
     } else {
       const lockfile = readLockfile();
-      actions = computeDiff(lockfile, configs);
+      actions = computeDiff(lockfile, configs, diffOptions);
     }
     printDiffTable(actions);
     const addCount = actions.filter((a) => a.action === "add").length;
     const extraCount = actions.filter((a) => a.action === "extra").length;
-    if (addCount === 0 && extraCount === 0) {
-      p6.outro(pc7.green("All clients are in sync."));
+    const removeCount = actions.filter((a) => a.action === "remove").length;
+    if (addCount === 0 && removeCount === 0 && extraCount === 0) {
+      p8.outro(pc7.green("All clients are in sync."));
       process.exit(0);
     }
     const parts = [];
     if (addCount > 0) parts.push(pc7.green(`${addCount} to add`));
+    if (removeCount > 0) parts.push(pc7.red(`${removeCount} to remove`));
     if (extraCount > 0) parts.push(pc7.yellow(`${extraCount} extra (informational)`));
-    p6.log.info(parts.join("  \xB7  "));
+    p8.log.info(parts.join("  \xB7  "));
     if (args["dry-run"]) {
-      p6.outro(pc7.dim("Dry run \u2014 no changes applied."));
+      p8.outro(pc7.dim("Dry run \u2014 no changes applied."));
       process.exit(1);
     }
-    if (addCount === 0) {
-      p6.outro(pc7.dim("No additions needed. Extra servers left untouched."));
+    if (addCount === 0 && removeCount === 0) {
+      p8.outro(pc7.dim("No additions needed. Extra servers left untouched."));
       process.exit(1);
     }
     if (!args.yes) {
-      const confirmed = await p6.confirm({
-        message: `Apply ${addCount} addition(s) to client configs?`,
+      const actionParts = [];
+      if (addCount > 0) actionParts.push(`${addCount} addition(s)`);
+      if (removeCount > 0) actionParts.push(`${removeCount} removal(s)`);
+      const confirmed = await p8.confirm({
+        message: `Apply ${actionParts.join(" and ")} to client configs?`,
         initialValue: true
       });
-      if (p6.isCancel(confirmed) || !confirmed) {
-        p6.outro(pc7.dim("Cancelled \u2014 no changes applied."));
+      if (p8.isCancel(confirmed) || !confirmed) {
+        p8.outro(pc7.dim("Cancelled \u2014 no changes applied."));
         process.exit(0);
       }
     }
@@ -1679,20 +2015,23 @@ var sync_default = defineCommand8({
     const result = await applySyncActions(actions, handlers);
     spinner5.stop("Done");
     if (result.applied > 0) {
-      p6.log.success(`Added ${result.applied} server(s) to client configs.`);
+      p8.log.success(`Added ${result.applied} server(s) to client configs.`);
+    }
+    if (result.removed > 0) {
+      p8.log.success(`Removed ${result.removed} server(s) from client configs.`);
     }
     if (result.failed > 0) {
       for (const e of result.errors) {
-        p6.log.error(`Failed to add "${e.server}" to ${e.client}: ${e.error}`);
+        p8.log.error(`Failed to sync "${e.server}" on ${e.client}: ${e.error}`);
       }
     }
-    p6.outro(result.failed === 0 ? pc7.green("Sync complete.") : pc7.yellow("Sync complete with errors."));
+    p8.outro(result.failed === 0 ? pc7.green("Sync complete.") : pc7.yellow("Sync complete with errors."));
     process.exit(result.failed > 0 ? 1 : 0);
   }
 });
 function printDiffTable(actions) {
   if (actions.length === 0) {
-    p6.log.info("No actions to display.");
+    p8.log.info("No actions to display.");
     return;
   }
   const nameWidth = Math.max(6, ...actions.map((a) => a.server.length));
@@ -1713,6 +2052,8 @@ function formatAction(action) {
       return [pc7.green("+"), pc7.green("missing \u2014 will add")];
     case "extra":
       return [pc7.yellow("?"), pc7.yellow("extra (not in lockfile)")];
+    case "remove":
+      return [pc7.red("\u2013"), pc7.red("extra \u2014 will remove")];
     case "ok":
       return [pc7.dim("\xB7"), pc7.dim("in sync")];
   }
@@ -1723,129 +2064,9 @@ function pad2(s, width) {
 
 // src/commands/update.ts
 import { defineCommand as defineCommand9 } from "citty";
-import * as p7 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 import pc9 from "picocolors";
 
-// src/core/version-checker.ts
-function compareVersions(a, b) {
-  const aParts = a.replace(/^v/, "").split(".").map(Number);
-  const bParts = b.replace(/^v/, "").split(".").map(Number);
-  const len = Math.max(aParts.length, bParts.length);
-  for (let i = 0; i < len; i++) {
-    const aN = aParts[i] ?? 0;
-    const bN = bParts[i] ?? 0;
-    if (Number.isNaN(aN) || Number.isNaN(bN)) return 0;
-    if (aN < bN) return -1;
-    if (aN > bN) return 1;
-  }
-  return 0;
-}
-function detectUpdateType(current, latest) {
-  const cParts = current.replace(/^v/, "").split(".").map(Number);
-  const lParts = latest.replace(/^v/, "").split(".").map(Number);
-  if ((lParts[0] ?? 0) > (cParts[0] ?? 0)) return "major";
-  if ((lParts[1] ?? 0) > (cParts[1] ?? 0)) return "minor";
-  return "patch";
-}
-async function fetchNpmLatest(packageName) {
-  try {
-    const res = await fetch(
-      `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
-      {
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(8e3)
-      }
-    );
-    if (!res.ok) return null;
-    const data = await res.json();
-    return typeof data.version === "string" ? data.version : null;
-  } catch {
-    return null;
-  }
-}
-async function fetchSmitheryLatest(name) {
-  try {
-    const res = await fetch(
-      `https://registry.smithery.ai/servers/${encodeURIComponent(name)}`,
-      {
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(8e3)
-      }
-    );
-    if (!res.ok) return null;
-    const data = await res.json();
-    return typeof data.version === "string" ? data.version : null;
-  } catch {
-    return null;
-  }
-}
-async function fetchGithubLatest(resolved) {
-  const match = resolved.match(/github\.com\/([^/]+)\/([^/]+)/);
-  if (!match) return null;
-  const [, owner, repo] = match;
-  try {
-    const res = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/releases/latest`,
-      {
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(8e3)
-      }
-    );
-    if (!res.ok) return null;
-    const data = await res.json();
-    return typeof data.tag_name === "string" ? data.tag_name.replace(/^v/, "") : null;
-  } catch {
-    return null;
-  }
-}
-async function checkVersion(name, lockEntry) {
-  const current = lockEntry.version;
-  let latest = null;
-  if (lockEntry.source === "npm") {
-    latest = await fetchNpmLatest(name);
-  } else if (lockEntry.source === "smithery") {
-    latest = await fetchSmitheryLatest(name);
-  } else if (lockEntry.source === "github") {
-    latest = await fetchGithubLatest(lockEntry.resolved);
-  }
-  if (!latest || latest === current) {
-    return {
-      server: name,
-      source: lockEntry.source,
-      currentVersion: current,
-      latestVersion: latest ?? current,
-      hasUpdate: false
-    };
-  }
-  const hasUpdate = compareVersions(current, latest) === -1;
-  return {
-    server: name,
-    source: lockEntry.source,
-    currentVersion: current,
-    latestVersion: latest,
-    hasUpdate,
-    updateType: hasUpdate ? detectUpdateType(current, latest) : void 0
-  };
-}
-async function checkAllVersions(lockfile) {
-  const entries = Object.entries(lockfile.servers);
-  if (entries.length === 0) return [];
-  const results = [];
-  const executing = /* @__PURE__ */ new Set();
-  for (const [name, entry] of entries) {
-    const p8 = checkVersion(name, entry).then((r) => {
-      results.push(r);
-      executing.delete(p8);
-    });
-    executing.add(p8);
-    if (executing.size >= 5) {
-      await Promise.race(executing);
-    }
-  }
-  await Promise.all(executing);
-  return results;
-}
-
 // src/core/update-notifier.ts
 import fs3 from "fs";
 import path4 from "path";
@@ -1865,7 +2086,7 @@ function writeUpdateCache(data) {
 }
 
 // src/commands/update.ts
-async function loadClients2() {
+async function loadClients3() {
   try {
     const mod = await import("./client-detector-SUIJSIYM.js");
     return mod.getInstalledClients();
@@ -1933,7 +2154,7 @@ var update_default = defineCommand9({
       }
       process.exit(1);
     }
-    const spinner5 = p7.spinner();
+    const spinner5 = p9.spinner();
     spinner5.start("Checking versions...");
     let updates;
     try {
@@ -1963,62 +2184,42 @@ var update_default = defineCommand9({
       return;
     }
     if (!args.yes) {
-      const confirmed = await p7.confirm({
+      const confirmed = await p9.confirm({
         message: `Apply ${outdated.length} update(s)?`,
         initialValue: true
       });
-      if (p7.isCancel(confirmed) || !confirmed) {
-        p7.outro("Cancelled.");
+      if (p9.isCancel(confirmed) || !confirmed) {
+        p9.outro("Cancelled.");
         return;
       }
     }
-    const clients = await loadClients2();
+    const clients = await loadClients3();
     let successCount = 0;
     for (const update of outdated) {
-      const lockEntry = servers[update.server];
-      const input = lockEntry.source === "smithery" ? `smithery:${update.server}` : lockEntry.source === "github" ? lockEntry.resolved : update.server;
-      const s = p7.spinner();
+      const s = p9.spinner();
       s.start(`Updating ${update.server}...`);
-      try {
-        const metadata = await resolveServer(input);
-        const integrity = computeIntegrity(metadata.resolved);
-        addEntry(update.server, {
-          ...lockEntry,
-          version: metadata.version,
-          resolved: metadata.resolved,
-          integrity,
-          command: metadata.command,
-          args: metadata.args,
-          installedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        const entryClients = clients.filter(
-          (c) => lockEntry.clients.includes(c.type)
-        );
-        for (const client of entryClients) {
-          try {
-            await client.addServer(update.server, {
-              command: metadata.command,
-              args: metadata.args
-            });
-          } catch {
-          }
-        }
-        s.stop(`${pc9.green("\u2713")} ${update.server}: ${update.currentVersion} \u2192 ${metadata.version}`);
+      const result = await applyServerUpdate(
+        update.server,
+        servers[update.server],
+        clients
+      );
+      if (result.success) {
+        s.stop(`${pc9.green("\u2713")} ${update.server}: ${result.fromVersion} \u2192 ${result.toVersion}`);
         successCount++;
-      } catch (err) {
-        s.stop(`${pc9.red("\u2717")} ${update.server}: ${err instanceof Error ? err.message : String(err)}`);
+      } else {
+        s.stop(`${pc9.red("\u2717")} ${update.server}: ${result.error}`);
       }
     }
     const freshLockfile = readLockfile(resolveLockfilePath());
     const freshUpdates = await checkAllVersions(freshLockfile);
     writeUpdateCache({ lastCheck: (/* @__PURE__ */ new Date()).toISOString(), updates: freshUpdates });
-    p7.outro(`${successCount} of ${outdated.length} server(s) updated.`);
+    p9.outro(`${successCount} of ${outdated.length} server(s) updated.`);
   }
 });
 
 // src/utils/constants.ts
 var APP_NAME = "mcpman";
-var APP_VERSION = "0.2.0";
+var APP_VERSION = "0.3.0";
 var APP_DESCRIPTION = "The package manager for MCP servers";
 
 // src/index.ts