mcpman 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -37,6 +37,100 @@ var init_cjs_shims = __esm({
   }
 });
 
+// src/core/lockfile.ts
+var lockfile_exports = {};
+__export(lockfile_exports, {
+  LOCKFILE_NAME: () => LOCKFILE_NAME,
+  addEntry: () => addEntry,
+  createEmptyLockfile: () => createEmptyLockfile,
+  findLockfile: () => findLockfile,
+  getGlobalLockfilePath: () => getGlobalLockfilePath,
+  getLockedVersion: () => getLockedVersion,
+  readLockfile: () => readLockfile,
+  removeEntry: () => removeEntry,
+  resolveLockfilePath: () => resolveLockfilePath,
+  writeLockfile: () => writeLockfile
+});
+function findLockfile() {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = import_node_path.default.join(dir, LOCKFILE_NAME);
+    if (import_node_fs.default.existsSync(candidate)) return candidate;
+    const parent = import_node_path.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function getGlobalLockfilePath() {
+  return import_node_path.default.join(import_node_os.default.homedir(), ".mcpman", LOCKFILE_NAME);
+}
+function resolveLockfilePath() {
+  return findLockfile() ?? getGlobalLockfilePath();
+}
+function readLockfile(filePath) {
+  const target = filePath ?? resolveLockfilePath();
+  if (!import_node_fs.default.existsSync(target)) {
+    return { lockfileVersion: 1, servers: {} };
+  }
+  try {
+    const raw = import_node_fs.default.readFileSync(target, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { lockfileVersion: 1, servers: {} };
+  }
+}
+function serialize(data) {
+  const sorted = {
+    lockfileVersion: data.lockfileVersion,
+    servers: Object.fromEntries(
+      Object.entries(data.servers).sort(([a], [b]) => a.localeCompare(b))
+    )
+  };
+  return `${JSON.stringify(sorted, null, 2)}
+`;
+}
+function writeLockfile(data, filePath) {
+  const target = filePath ?? resolveLockfilePath();
+  const dir = import_node_path.default.dirname(target);
+  if (!import_node_fs.default.existsSync(dir)) {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+  }
+  const tmp = `${target}.tmp`;
+  import_node_fs.default.writeFileSync(tmp, serialize(data), "utf-8");
+  import_node_fs.default.renameSync(tmp, target);
+}
+function addEntry(name, entry, filePath) {
+  const data = readLockfile(filePath);
+  data.servers[name] = entry;
+  writeLockfile(data, filePath);
+}
+function removeEntry(name, filePath) {
+  const data = readLockfile(filePath);
+  if (name in data.servers) {
+    delete data.servers[name];
+    writeLockfile(data, filePath);
+  }
+}
+function getLockedVersion(name, filePath) {
+  const data = readLockfile(filePath);
+  return data.servers[name]?.version;
+}
+function createEmptyLockfile(filePath) {
+  writeLockfile({ lockfileVersion: 1, servers: {} }, filePath);
+}
+var import_node_fs, import_node_os, import_node_path, LOCKFILE_NAME;
+var init_lockfile = __esm({
+  "src/core/lockfile.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs = __toESM(require("fs"), 1);
+    import_node_os = __toESM(require("os"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    LOCKFILE_NAME = "mcpman.lock";
+  }
+});
+
 // src/core/trust-scorer.ts
 var trust_scorer_exports = {};
 __export(trust_scorer_exports, {
@@ -437,12 +531,12 @@ __export(vault_service_exports, {
   writeVault: () => writeVault
 });
 function getVaultPath() {
-  return import_node_path7.default.join(import_node_os4.default.homedir(), ".mcpman", "vault.enc");
+  return import_node_path10.default.join(import_node_os5.default.homedir(), ".mcpman", "vault.enc");
 }
 function readVault(vaultPath = getVaultPath()) {
   const empty = { version: 1, servers: {} };
   try {
-    const raw = import_node_fs6.default.readFileSync(vaultPath, "utf-8");
+    const raw = import_node_fs8.default.readFileSync(vaultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || typeof parsed.servers !== "object") return empty;
     return parsed;
@@ -451,16 +545,16 @@ function readVault(vaultPath = getVaultPath()) {
   }
 }
 function writeVault(data, vaultPath = getVaultPath()) {
-  const dir = import_node_path7.default.dirname(vaultPath);
-  import_node_fs6.default.mkdirSync(dir, { recursive: true });
+  const dir = import_node_path10.default.dirname(vaultPath);
+  import_node_fs8.default.mkdirSync(dir, { recursive: true });
   const tmp = `${vaultPath}.tmp`;
-  import_node_fs6.default.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
+  import_node_fs8.default.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
   if (process.platform !== "win32") {
-    import_node_fs6.default.chmodSync(tmp, 384);
+    import_node_fs8.default.chmodSync(tmp, 384);
   }
-  import_node_fs6.default.renameSync(tmp, vaultPath);
+  import_node_fs8.default.renameSync(tmp, vaultPath);
   if (process.platform !== "win32") {
-    import_node_fs6.default.chmodSync(vaultPath, 384);
+    import_node_fs8.default.chmodSync(vaultPath, 384);
   }
 }
 function encrypt(value, password2) {
@@ -550,15 +644,15 @@ function listSecrets(server, vaultPath = getVaultPath()) {
     keys: Object.keys(keys)
   }));
 }
-var import_node_crypto2, import_node_fs6, import_node_os4, import_node_path7, p3, _cachedPassword;
+var import_node_crypto2, import_node_fs8, import_node_os5, import_node_path10, p3, _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_fs6 = __toESM(require("fs"), 1);
-    import_node_os4 = __toESM(require("os"), 1);
-    import_node_path7 = __toESM(require("path"), 1);
+    import_node_fs8 = __toESM(require("fs"), 1);
+    import_node_os5 = __toESM(require("os"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
     p3 = __toESM(require("@clack/prompts"), 1);
     _cachedPassword = null;
     process.on("exit", () => {
@@ -569,7 +663,7 @@ var init_vault_service = __esm({
 
 // src/index.ts
 init_cjs_shims();
-var import_citty21 = require("citty");
+var import_citty27 = require("citty");
 
 // src/commands/audit.ts
 init_cjs_shims();
@@ -577,70 +671,7 @@ var p = __toESM(require("@clack/prompts"), 1);
 var import_citty = require("citty");
 var import_nanospinner = require("nanospinner");
 var import_picocolors = __toESM(require("picocolors"), 1);
-
-// src/core/lockfile.ts
-init_cjs_shims();
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_os = __toESM(require("os"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var LOCKFILE_NAME = "mcpman.lock";
-function findLockfile() {
-  let dir = process.cwd();
-  while (true) {
-    const candidate = import_node_path.default.join(dir, LOCKFILE_NAME);
-    if (import_node_fs.default.existsSync(candidate)) return candidate;
-    const parent = import_node_path.default.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-function getGlobalLockfilePath() {
-  return import_node_path.default.join(import_node_os.default.homedir(), ".mcpman", LOCKFILE_NAME);
-}
-function resolveLockfilePath() {
-  return findLockfile() ?? getGlobalLockfilePath();
-}
-function readLockfile(filePath) {
-  const target = filePath ?? resolveLockfilePath();
-  if (!import_node_fs.default.existsSync(target)) {
-    return { lockfileVersion: 1, servers: {} };
-  }
-  try {
-    const raw = import_node_fs.default.readFileSync(target, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return { lockfileVersion: 1, servers: {} };
-  }
-}
-function serialize(data) {
-  const sorted = {
-    lockfileVersion: data.lockfileVersion,
-    servers: Object.fromEntries(
-      Object.entries(data.servers).sort(([a], [b]) => a.localeCompare(b))
-    )
-  };
-  return `${JSON.stringify(sorted, null, 2)}
-`;
-}
-function writeLockfile(data, filePath) {
-  const target = filePath ?? resolveLockfilePath();
-  const dir = import_node_path.default.dirname(target);
-  if (!import_node_fs.default.existsSync(dir)) {
-    import_node_fs.default.mkdirSync(dir, { recursive: true });
-  }
-  const tmp = `${target}.tmp`;
-  import_node_fs.default.writeFileSync(tmp, serialize(data), "utf-8");
-  import_node_fs.default.renameSync(tmp, target);
-}
-function addEntry(name, entry, filePath) {
-  const data = readLockfile(filePath);
-  data.servers[name] = entry;
-  writeLockfile(data, filePath);
-}
-function createEmptyLockfile(filePath) {
-  writeLockfile({ lockfileVersion: 1, servers: {} }, filePath);
-}
+init_lockfile();
 
 // src/core/security-scanner.ts
 init_cjs_shims();
@@ -786,6 +817,7 @@ async function scanAllServers(servers, concurrency = 3) {
 
 // src/core/server-updater.ts
 init_cjs_shims();
+init_lockfile();
 
 // src/core/registry.ts
 init_cjs_shims();
@@ -1471,11 +1503,290 @@ async function runAuditFix(reports, servers, skipConfirm) {
 `);
 }
 
-// src/commands/config.ts
+// src/commands/completions.ts
 init_cjs_shims();
-var p2 = __toESM(require("@clack/prompts"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_os4 = __toESM(require("os"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_citty2 = require("citty");
 var import_picocolors2 = __toESM(require("picocolors"), 1);
+
+// src/core/completion-generator.ts
+init_cjs_shims();
+init_lockfile();
+function getCommandList() {
+  return [
+    "install",
+    "list",
+    "remove",
+    "doctor",
+    "init",
+    "secrets",
+    "sync",
+    "audit",
+    "update",
+    "upgrade",
+    "config",
+    "search",
+    "info",
+    "run",
+    "logs",
+    "test",
+    "profiles",
+    "plugin",
+    "export",
+    "import",
+    "create",
+    "link",
+    "watch",
+    "registry",
+    "completions",
+    "why"
+  ];
+}
+var SERVER_ARG_COMMANDS = [
+  "run",
+  "test",
+  "logs",
+  "watch",
+  "remove",
+  "update",
+  "info",
+  "audit",
+  "link",
+  "why"
+];
+function getServerNames(lockfilePath) {
+  try {
+    const data = readLockfile(lockfilePath);
+    return Object.keys(data.servers);
+  } catch {
+    return [];
+  }
+}
+function generateBashCompletion() {
+  const serverCmds = SERVER_ARG_COMMANDS.join("|");
+  return `# mcpman bash completion
+# Add to ~/.bashrc or ~/.bash_profile:
+#   source <(mcpman completions bash)
+# Or append permanently:
+#   mcpman completions bash >> ~/.bashrc
+
+_mcpman_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "$(mcpman completions --list-commands 2>/dev/null)" -- "$cur"))
+    return
+  fi
+
+  case "$prev" in
+    ${serverCmds})
+      COMPREPLY=($(compgen -W "$(mcpman completions --list-servers 2>/dev/null)" -- "$cur"))
+      ;;
+    --client|-c)
+      COMPREPLY=($(compgen -W "claude-desktop cursor vscode windsurf" -- "$cur"))
+      ;;
+    --runtime|-r)
+      COMPREPLY=($(compgen -W "node python" -- "$cur"))
+      ;;
+  esac
+}
+
+complete -F _mcpman_completions mcpman
+`;
+}
+function generateZshCompletion() {
+  const serverCmds = SERVER_ARG_COMMANDS.map((c) => `'${c}'`).join(" ");
+  return `#compdef mcpman
+# mcpman zsh completion
+# Add to ~/.zshrc:
+#   source <(mcpman completions zsh)
+# Or use compinit:
+#   mcpman completions zsh > "\${fpath[1]}/_mcpman"
+
+_mcpman() {
+  local state
+
+  _arguments \\
+    '1: :->command' \\
+    '*: :->args'
+
+  case $state in
+    command)
+      local commands
+      commands=($(mcpman completions --list-commands 2>/dev/null))
+      _describe 'command' commands
+      ;;
+    args)
+      local cmd="\${words[2]}"
+      local server_cmds=(${serverCmds})
+      if (( server_cmds[(I)$cmd] )); then
+        local servers
+        servers=($(mcpman completions --list-servers 2>/dev/null))
+        _describe 'server' servers
+      fi
+      ;;
+  esac
+}
+
+compdef _mcpman mcpman
+`;
+}
+function generateFishCompletion() {
+  const serverCmds = SERVER_ARG_COMMANDS.join(" ");
+  return `# mcpman fish completion
+# Add to ~/.config/fish/completions/mcpman.fish:
+#   mcpman completions fish > ~/.config/fish/completions/mcpman.fish
+
+# Disable file completion for mcpman
+complete -c mcpman -f
+
+# Subcommand completions (dynamic)
+complete -c mcpman -n '__fish_use_subcommand' \\
+  -a "(mcpman completions --list-commands 2>/dev/null)"
+
+# Server name completions for commands that take a server arg
+for cmd in ${serverCmds}
+  complete -c mcpman -n "__fish_seen_subcommand_from $cmd" \\
+    -a "(mcpman completions --list-servers 2>/dev/null)"
+end
+
+# --client flag completions
+complete -c mcpman -l client -s c \\
+  -a "claude-desktop cursor vscode windsurf" \\
+  -d "Target client"
+
+# --runtime flag completions
+complete -c mcpman -l runtime -s r \\
+  -a "node python" \\
+  -d "Runtime"
+`;
+}
+
+// src/commands/completions.ts
+var completions_default = (0, import_citty2.defineCommand)({
+  meta: {
+    name: "completions",
+    description: "Generate shell completion scripts (bash, zsh, fish)"
+  },
+  args: {
+    shell: {
+      type: "positional",
+      description: "Shell: bash, zsh, fish, or install",
+      required: false
+    },
+    "list-commands": {
+      type: "boolean",
+      description: "Output all command names (used by completion scripts)",
+      default: false
+    },
+    "list-servers": {
+      type: "boolean",
+      description: "Output server names from lockfile (used by completion scripts)",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (args["list-commands"]) {
+      console.log(getCommandList().join("\n"));
+      return;
+    }
+    if (args["list-servers"]) {
+      console.log(getServerNames().join("\n"));
+      return;
+    }
+    const shell = args.shell;
+    if (!shell) {
+      printUsage();
+      return;
+    }
+    switch (shell.toLowerCase()) {
+      case "bash":
+        process.stdout.write(generateBashCompletion());
+        break;
+      case "zsh":
+        process.stdout.write(generateZshCompletion());
+        break;
+      case "fish":
+        process.stdout.write(generateFishCompletion());
+        break;
+      case "install":
+        await installCompletion();
+        break;
+      default:
+        console.error(import_picocolors2.default.red(`  Error: Unknown shell '${shell}'. Use: bash, zsh, or fish.`));
+        process.exit(1);
+    }
+  }
+});
+function printUsage() {
+  console.log(import_picocolors2.default.bold("\n  mcpman completions \u2014 Shell completion setup\n"));
+  console.log("  Usage:");
+  console.log(`    ${import_picocolors2.default.cyan("mcpman completions bash")}    Output bash completion script`);
+  console.log(`    ${import_picocolors2.default.cyan("mcpman completions zsh")}     Output zsh completion script`);
+  console.log(`    ${import_picocolors2.default.cyan("mcpman completions fish")}    Output fish completion script`);
+  console.log(`    ${import_picocolors2.default.cyan("mcpman completions install")} Auto-detect shell and install
+`);
+  console.log("  Quick setup:");
+  console.log(`    ${import_picocolors2.default.dim("# bash")}`);
+  console.log(`    ${import_picocolors2.default.cyan("source <(mcpman completions bash)")}`);
+  console.log(`    ${import_picocolors2.default.dim("# zsh")}`);
+  console.log(`    ${import_picocolors2.default.cyan("source <(mcpman completions zsh)")}
+`);
+}
+async function installCompletion() {
+  const shellBin = process.env.SHELL ?? "";
+  let detectedShell = "";
+  if (shellBin.includes("zsh")) detectedShell = "zsh";
+  else if (shellBin.includes("fish")) detectedShell = "fish";
+  else if (shellBin.includes("bash")) detectedShell = "bash";
+  if (!detectedShell) {
+    console.error(import_picocolors2.default.red("  Could not detect shell from $SHELL. Run manually:"));
+    console.error(import_picocolors2.default.dim("    source <(mcpman completions bash|zsh|fish)"));
+    process.exit(1);
+  }
+  const home = import_node_os4.default.homedir();
+  let rcFile;
+  let script;
+  if (detectedShell === "zsh") {
+    rcFile = import_node_path7.default.join(home, ".zshrc");
+    script = generateZshCompletion();
+  } else if (detectedShell === "fish") {
+    const fishDir = import_node_path7.default.join(home, ".config", "fish", "completions");
+    import_node_fs6.default.mkdirSync(fishDir, { recursive: true });
+    rcFile = import_node_path7.default.join(fishDir, "mcpman.fish");
+    import_node_fs6.default.writeFileSync(rcFile, generateFishCompletion(), "utf-8");
+    console.log(import_picocolors2.default.green(`  Installed fish completions to ${rcFile}`));
+    return;
+  } else {
+    rcFile = import_node_path7.default.join(home, ".bashrc");
+    script = generateBashCompletion();
+  }
+  const marker = "# mcpman completions";
+  let existing = "";
+  try {
+    existing = import_node_fs6.default.readFileSync(rcFile, "utf-8");
+  } catch {
+  }
+  if (existing.includes(marker)) {
+    console.log(import_picocolors2.default.yellow(`  Completions already installed in ${rcFile}. Skipping.`));
+    return;
+  }
+  import_node_fs6.default.appendFileSync(rcFile, `
+${marker}
+source <(mcpman completions ${detectedShell})
+`);
+  console.log(import_picocolors2.default.green(`  Installed ${detectedShell} completions in ${rcFile}`));
+  console.log(import_picocolors2.default.dim(`  Restart your shell or run: source ${rcFile}`));
+}
+
+// src/commands/config.ts
+init_cjs_shims();
+var p2 = __toESM(require("@clack/prompts"), 1);
+var import_citty3 = require("citty");
+var import_picocolors3 = __toESM(require("picocolors"), 1);
 function coerceValue(raw) {
   if (raw === "true") return true;
   if (raw === "false") return false;
@@ -1483,7 +1794,7 @@ function coerceValue(raw) {
   if (!Number.isNaN(num) && raw.trim() !== "") return num;
   return raw;
 }
-var setCommand = (0, import_citty2.defineCommand)({
+var setCommand = (0, import_citty3.defineCommand)({
   meta: { name: "set", description: "Set a config value" },
   args: {
     key: {
@@ -1501,14 +1812,14 @@ var setCommand = (0, import_citty2.defineCommand)({
     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))}`);
+      console.log(`${import_picocolors3.default.green("\u2713")} Set ${import_picocolors3.default.bold(args.key)} = ${import_picocolors3.default.cyan(String(coerced))}`);
     } catch (err) {
-      console.error(`${import_picocolors2.default.red("\u2717")} ${String(err)}`);
+      console.error(`${import_picocolors3.default.red("\u2717")} ${String(err)}`);
       process.exit(1);
     }
   }
 });
-var getCommand = (0, import_citty2.defineCommand)({
+var getCommand = (0, import_citty3.defineCommand)({
   meta: { name: "get", description: "Get a config value" },
   args: {
     key: {
@@ -1520,32 +1831,32 @@ var getCommand = (0, import_citty2.defineCommand)({
   run({ args }) {
     const val = getConfigValue(args.key);
     if (val === void 0) {
-      console.log(import_picocolors2.default.dim(`${args.key}: (not set)`));
+      console.log(import_picocolors3.default.dim(`${args.key}: (not set)`));
     } else {
-      console.log(`${import_picocolors2.default.bold(args.key)}: ${import_picocolors2.default.cyan(String(val))}`);
+      console.log(`${import_picocolors3.default.bold(args.key)}: ${import_picocolors3.default.cyan(String(val))}`);
     }
   }
 });
-var listCommand = (0, import_citty2.defineCommand)({
+var listCommand = (0, import_citty3.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>`."));
+      console.log(import_picocolors3.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(import_picocolors3.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(`  ${import_picocolors3.default.green("\u25CF")} ${import_picocolors3.default.bold(key)}  ${import_picocolors3.default.cyan(String(val))}`);
     }
     console.log("");
-    console.log(import_picocolors2.default.dim(`  ${entries.length} key${entries.length !== 1 ? "s" : ""} configured`));
+    console.log(import_picocolors3.default.dim(`  ${entries.length} key${entries.length !== 1 ? "s" : ""} configured`));
   }
 });
-var resetCommand = (0, import_citty2.defineCommand)({
+var resetCommand = (0, import_citty3.defineCommand)({
   meta: { name: "reset", description: "Reset config to defaults (removes config file)" },
   async run() {
     const confirmed = await p2.confirm({
@@ -1557,10 +1868,10 @@ var resetCommand = (0, import_citty2.defineCommand)({
       return;
     }
     writeConfig({});
-    console.log(`${import_picocolors2.default.green("\u2713")} Config reset to defaults.`);
+    console.log(`${import_picocolors3.default.green("\u2713")} Config reset to defaults.`);
   }
 });
-var config_default = (0, import_citty2.defineCommand)({
+var config_default = (0, import_citty3.defineCommand)({
   meta: {
     name: "config",
     description: "Manage mcpman CLI configuration"
@@ -1573,46 +1884,336 @@ var config_default = (0, import_citty2.defineCommand)({
   }
 });
 
-// src/commands/doctor.ts
+// src/commands/create.ts
 init_cjs_shims();
-var import_citty3 = require("citty");
-var import_picocolors3 = __toESM(require("picocolors"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+var import_citty4 = require("citty");
+var import_picocolors4 = __toESM(require("picocolors"), 1);
 
-// src/core/health-checker.ts
+// src/core/scaffold-service.ts
 init_cjs_shims();
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+function sanitizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function generateNodeProject(options) {
+  const { name, description } = options;
+  const packageJson = JSON.stringify(
+    {
+      name,
+      version: "0.1.0",
+      description,
+      type: "module",
+      bin: { [name]: "./dist/index.js" },
+      main: "./dist/index.js",
+      scripts: {
+        build: "tsc",
+        start: "node dist/index.js",
+        dev: "tsx src/index.ts"
+      },
+      mcp: {
+        name,
+        description,
+        transport: "stdio",
+        env: []
+      },
+      dependencies: {
+        "@modelcontextprotocol/sdk": "^1.0.0"
+      },
+      devDependencies: {
+        typescript: "^5.0.0",
+        tsx: "^4.0.0",
+        "@types/node": "^20.0.0"
+      }
+    },
+    null,
+    2
+  );
+  const tsconfig = JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        outDir: "./dist",
+        rootDir: "./src",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true
+      },
+      include: ["src"]
+    },
+    null,
+    2
+  );
+  const indexTs = `#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/core/diagnostics.ts
-init_cjs_shims();
-var import_node_child_process3 = require("child_process");
-var import_node_util = require("util");
+const server = new Server(
+  { name: "${name}", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
 
-// src/core/mcp-process-checks.ts
-init_cjs_shims();
-var import_node_child_process2 = require("child_process");
-async function checkProcessSpawn(command, args, env, timeoutMs = 3e3) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const child = (0, import_node_child_process2.spawn)(command, args, {
-      env: { ...process.env, ...env },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const timer = setTimeout(() => {
-      if (!settled) {
-        settled = true;
-        child.kill("SIGTERM");
-        resolve({ name: "Process", passed: true, message: "starts successfully (still running)" });
-      }
-    }, timeoutMs);
-    child.on("error", (err) => {
-      if (!settled) {
-        settled = true;
-        clearTimeout(timer);
-        resolve({ name: "Process", passed: false, message: `spawn error: ${err.message}` });
-      }
-    });
-    child.on("exit", (code) => {
-      if (!settled) {
-        settled = true;
+server.setRequestHandler("tools/list", async () => ({
+  tools: [
+    {
+      name: "hello",
+      description: "Say hello",
+      inputSchema: { type: "object", properties: { name: { type: "string" } } },
+    },
+  ],
+}));
+
+server.setRequestHandler("tools/call", async (request) => {
+  if (request.params.name === "hello") {
+    const who = request.params.arguments?.name ?? "world";
+    return { content: [{ type: "text", text: \`Hello, \${who}!\` }] };
+  }
+  throw new Error(\`Unknown tool: \${request.params.name}\`);
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+`;
+  return {
+    "package.json": packageJson,
+    "tsconfig.json": tsconfig,
+    "src/index.ts": indexTs
+  };
+}
+function generatePythonProject(options) {
+  const { name, description } = options;
+  const pyprojectToml = `[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.backends.legacy:build"
+
+[project]
+name = "${name}"
+version = "0.1.0"
+description = "${description}"
+requires-python = ">=3.10"
+dependencies = ["mcp>=1.0.0"]
+
+[project.scripts]
+${name} = "${name.replace(/-/g, "_")}:main"
+
+[tool.mcp]
+name = "${name}"
+description = "${description}"
+transport = "stdio"
+`;
+  const mainPy = `#!/usr/bin/env python3
+"""${description}"""
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+
+app = Server("${name}")
+
+@app.list_tools()
+async def list_tools():
+    return [
+        {
+            "name": "hello",
+            "description": "Say hello",
+            "inputSchema": {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+            },
+        }
+    ]
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict):
+    if name == "hello":
+        who = arguments.get("name", "world")
+        return [{"type": "text", "text": f"Hello, {who}!"}]
+    raise ValueError(f"Unknown tool: {name}")
+
+async def main():
+    async with stdio_server() as (read, write):
+        await app.run(read, write)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())
+`;
+  return {
+    "pyproject.toml": pyprojectToml,
+    "main.py": mainPy
+  };
+}
+function writeScaffold(dir, files) {
+  if (import_node_fs7.default.existsSync(dir)) {
+    const existing = import_node_fs7.default.readdirSync(dir);
+    if (existing.length > 0) {
+      throw new Error(`Directory '${dir}' already exists and is not empty.`);
+    }
+  }
+  for (const [relativePath, content] of Object.entries(files)) {
+    const fullPath = import_node_path8.default.join(dir, relativePath);
+    const parentDir = import_node_path8.default.dirname(fullPath);
+    import_node_fs7.default.mkdirSync(parentDir, { recursive: true });
+    import_node_fs7.default.writeFileSync(fullPath, content, "utf-8");
+  }
+}
+
+// src/commands/create.ts
+var create_default = (0, import_citty4.defineCommand)({
+  meta: {
+    name: "create",
+    description: "Scaffold a new MCP server project"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project name",
+      required: false
+    },
+    runtime: {
+      type: "string",
+      description: "Runtime: node or python (default: node)",
+      alias: "r"
+    },
+    description: {
+      type: "string",
+      description: "Project description",
+      alias: "d"
+    },
+    yes: {
+      type: "boolean",
+      description: "Accept all defaults, skip prompts",
+      alias: "y",
+      default: false
+    }
+  },
+  async run({ args }) {
+    let projectName = args.name ?? "";
+    let projectDescription = args.description ?? "";
+    let runtime = args.runtime ?? "node";
+    const acceptDefaults = args.yes;
+    if (!acceptDefaults) {
+      if (!projectName) {
+        const readline = await import("readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        projectName = await new Promise((resolve) => {
+          rl.question(import_picocolors4.default.cyan("  Project name: "), (answer) => {
+            rl.close();
+            resolve(answer.trim());
+          });
+        });
+      }
+      if (!projectDescription) {
+        const readline = await import("readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        projectDescription = await new Promise((resolve) => {
+          rl.question(import_picocolors4.default.cyan("  Description (optional): "), (answer) => {
+            rl.close();
+            resolve(answer.trim());
+          });
+        });
+      }
+      if (!args.runtime) {
+        const readline = await import("readline");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await new Promise((resolve) => {
+          rl.question(import_picocolors4.default.cyan("  Runtime [node/python] (default: node): "), (a) => {
+            rl.close();
+            resolve(a.trim() || "node");
+          });
+        });
+        runtime = answer;
+      }
+    }
+    if (!projectName) {
+      console.error(import_picocolors4.default.red("  Error: Project name is required."));
+      process.exit(1);
+    }
+    const sanitized = sanitizeName(projectName);
+    if (!sanitized) {
+      console.error(import_picocolors4.default.red(`  Error: Invalid project name '${projectName}'.`));
+      process.exit(1);
+    }
+    if (runtime !== "node" && runtime !== "python") {
+      console.error(import_picocolors4.default.red(`  Error: Unknown runtime '${runtime}'. Use node or python.`));
+      process.exit(1);
+    }
+    const options = {
+      name: sanitized,
+      description: projectDescription || `${sanitized} MCP server`,
+      runtime,
+      transport: "stdio"
+    };
+    const files = runtime === "python" ? generatePythonProject(options) : generateNodeProject(options);
+    const targetDir = import_node_path9.default.resolve(sanitized);
+    try {
+      writeScaffold(targetDir, files);
+    } catch (err) {
+      console.error(import_picocolors4.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+    console.log(import_picocolors4.default.green(`
+  Created ${import_picocolors4.default.bold(sanitized)}/
+`));
+    console.log(import_picocolors4.default.dim("  Files generated:"));
+    for (const file of Object.keys(files)) {
+      console.log(`    ${import_picocolors4.default.cyan(file)}`);
+    }
+    console.log("\n  Next steps:");
+    if (runtime === "node") {
+      console.log(`    ${import_picocolors4.default.bold(`cd ${sanitized}`)}`);
+      console.log(`    ${import_picocolors4.default.bold("npm install")}`);
+      console.log(`    ${import_picocolors4.default.bold("mcpman link .")}`);
+    } else {
+      console.log(`    ${import_picocolors4.default.bold(`cd ${sanitized}`)}`);
+      console.log(`    ${import_picocolors4.default.bold("pip install -e .")}`);
+      console.log(`    ${import_picocolors4.default.bold("mcpman link .")}`);
+    }
+    console.log();
+  }
+});
+
+// src/commands/doctor.ts
+init_cjs_shims();
+var import_citty5 = require("citty");
+var import_picocolors5 = __toESM(require("picocolors"), 1);
+
+// src/core/health-checker.ts
+init_cjs_shims();
+
+// src/core/diagnostics.ts
+init_cjs_shims();
+var import_node_child_process3 = require("child_process");
+var import_node_util = require("util");
+
+// src/core/mcp-process-checks.ts
+init_cjs_shims();
+var import_node_child_process2 = require("child_process");
+async function checkProcessSpawn(command, args, env, timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const child = (0, import_node_child_process2.spawn)(command, args, {
+      env: { ...process.env, ...env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        child.kill("SIGTERM");
+        resolve({ name: "Process", passed: true, message: "starts successfully (still running)" });
+      }
+    }, timeoutMs);
+    child.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve({ name: "Process", passed: false, message: `spawn error: ${err.message}` });
+      }
+    });
+    child.on("exit", (code) => {
+      if (!settled) {
+        settled = true;
         clearTimeout(timer);
         if (code === 0 || code === null) {
           resolve({ name: "Process", passed: true, message: "exits cleanly" });
@@ -1929,12 +2530,12 @@ async function getInstalledServers(clientFilter) {
 
 // src/commands/doctor.ts
 var CHECK_ICON = {
-  pass: import_picocolors3.default.green("\u2713"),
-  fail: import_picocolors3.default.red("\u2717"),
-  skip: import_picocolors3.default.dim("-"),
-  warn: import_picocolors3.default.yellow("\u26A0")
+  pass: import_picocolors5.default.green("\u2713"),
+  fail: import_picocolors5.default.red("\u2717"),
+  skip: import_picocolors5.default.dim("-"),
+  warn: import_picocolors5.default.yellow("\u26A0")
 };
-var doctor_default = (0, import_citty3.defineCommand)({
+var doctor_default = (0, import_citty5.defineCommand)({
   meta: {
     name: "doctor",
     description: "Check MCP server health and configuration"
@@ -1947,11 +2548,11 @@ var doctor_default = (0, import_citty3.defineCommand)({
     }
   },
   async run({ args }) {
-    console.log(import_picocolors3.default.bold("\n  mcpman doctor\n"));
+    console.log(import_picocolors5.default.bold("\n  mcpman doctor\n"));
     const servers = await getInstalledServers();
     if (servers.length === 0) {
       console.log(
-        import_picocolors3.default.dim("  No MCP servers installed. Run mcpman install <server> to get started.")
+        import_picocolors5.default.dim("  No MCP servers installed. Run mcpman install <server> to get started.")
       );
       return;
     }
@@ -1968,20 +2569,20 @@ var doctor_default = (0, import_citty3.defineCommand)({
     if (pluginSummary.total > 0) {
       printPluginSection(pluginSummary);
     }
-    console.log(import_picocolors3.default.dim(`  ${"\u2500".repeat(50)}`));
+    console.log(import_picocolors5.default.dim(`  ${"\u2500".repeat(50)}`));
     const parts = [];
-    if (passed > 0) parts.push(import_picocolors3.default.green(`${passed} healthy`));
-    if (failed > 0) parts.push(import_picocolors3.default.red(`${failed} unhealthy`));
+    if (passed > 0) parts.push(import_picocolors5.default.green(`${passed} healthy`));
+    if (failed > 0) parts.push(import_picocolors5.default.red(`${failed} unhealthy`));
     console.log(`  Summary: ${parts.join(", ")}`);
     if (pluginSummary.total > 0) {
       const pParts = [];
-      if (pluginSummary.healthy > 0) pParts.push(import_picocolors3.default.green(`${pluginSummary.healthy} ok`));
-      if (pluginSummary.unhealthy > 0) pParts.push(import_picocolors3.default.red(`${pluginSummary.unhealthy} broken`));
+      if (pluginSummary.healthy > 0) pParts.push(import_picocolors5.default.green(`${pluginSummary.healthy} ok`));
+      if (pluginSummary.unhealthy > 0) pParts.push(import_picocolors5.default.red(`${pluginSummary.unhealthy} broken`));
       console.log(`  Plugins: ${pParts.join(", ")}`);
     }
     if (failed > 0 || pluginSummary.unhealthy > 0) {
       if (!args.fix) {
-        console.log(import_picocolors3.default.dim(`  Run ${import_picocolors3.default.cyan("mcpman doctor --fix")} for fix suggestions.
+        console.log(import_picocolors5.default.dim(`  Run ${import_picocolors5.default.cyan("mcpman doctor --fix")} for fix suggestions.
 `));
       }
       process.exit(1);
@@ -1990,26 +2591,26 @@ var doctor_default = (0, import_citty3.defineCommand)({
   }
 });
 function printPluginSection(summary) {
-  console.log(import_picocolors3.default.bold(`  Plugins (${summary.total})`));
+  console.log(import_picocolors5.default.bold(`  Plugins (${summary.total})`));
   for (const r of summary.results) {
-    const icon = r.loadable && r.prefixUnique && r.resolvable ? import_picocolors3.default.green("\u2713") : import_picocolors3.default.red("\u2717");
+    const icon = r.loadable && r.prefixUnique && r.resolvable ? import_picocolors5.default.green("\u2713") : import_picocolors5.default.red("\u2717");
     const label = r.pluginName ? `${r.packageName} (${r.pluginName})` : r.packageName;
-    const prefix = r.prefix ? import_picocolors3.default.dim(` [${r.prefix}]`) : "";
+    const prefix = r.prefix ? import_picocolors5.default.dim(` [${r.prefix}]`) : "";
     console.log(`    ${icon} ${label}${prefix}`);
     if (r.error) {
-      console.log(`      ${import_picocolors3.default.yellow("\u2192")} ${r.error}`);
+      console.log(`      ${import_picocolors5.default.yellow("\u2192")} ${r.error}`);
     }
   }
   console.log();
 }
 function printServerResult(result, showFix) {
-  const icon = result.status === "healthy" ? import_picocolors3.default.green("\u25CF") : import_picocolors3.default.red("\u25CF");
-  console.log(`  ${icon} ${import_picocolors3.default.bold(result.serverName)}`);
+  const icon = result.status === "healthy" ? import_picocolors5.default.green("\u25CF") : import_picocolors5.default.red("\u25CF");
+  console.log(`  ${icon} ${import_picocolors5.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_picocolors3.default.yellow("\u2192")} Fix: ${import_picocolors3.default.cyan(check.fix)}`);
+      console.log(`      ${import_picocolors5.default.yellow("\u2192")} Fix: ${import_picocolors5.default.cyan(check.fix)}`);
     }
   }
   console.log();
@@ -2033,22 +2634,23 @@ async function runParallel(tasks, concurrency) {
 
 // src/commands/export-command.ts
 init_cjs_shims();
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
-var import_citty4 = require("citty");
-var import_picocolors4 = __toESM(require("picocolors"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+var import_citty6 = require("citty");
+var import_picocolors6 = __toESM(require("picocolors"), 1);
 
 // src/core/export-import-service.ts
 init_cjs_shims();
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
 
 // src/utils/constants.ts
 init_cjs_shims();
 var APP_NAME = "mcpman";
-var APP_VERSION = "0.6.0";
+var APP_VERSION = "0.7.0";
 var APP_DESCRIPTION = "The package manager for MCP servers";
 
 // src/core/export-import-service.ts
+init_lockfile();
 init_vault_service();
 function createExportBundle(opts = {}) {
   const { includeVault = true, includePlugins = true } = opts;
@@ -2062,7 +2664,7 @@ function createExportBundle(opts = {}) {
   };
   if (includeVault) {
     const vaultPath = getVaultPath();
-    if (import_node_fs7.default.existsSync(vaultPath)) {
+    if (import_node_fs9.default.existsSync(vaultPath)) {
       bundle.vault = readVault();
     }
   }
@@ -2128,7 +2730,7 @@ function importBundle(bundle, opts = {}) {
 
 // src/commands/export-command.ts
 var DEFAULT_OUTPUT = "mcpman-export.json";
-var export_command_default = (0, import_citty4.defineCommand)({
+var export_command_default = (0, import_citty6.defineCommand)({
   meta: {
     name: "export",
     description: "Export mcpman config, lockfile, vault, and plugins to a portable JSON file"
@@ -2152,30 +2754,30 @@ var export_command_default = (0, import_citty4.defineCommand)({
   },
   run({ args }) {
     const outputFile = args.output || DEFAULT_OUTPUT;
-    const outputPath = import_node_path8.default.resolve(outputFile);
+    const outputPath = import_node_path11.default.resolve(outputFile);
     const bundle = createExportBundle({
       includeVault: !args["no-vault"],
       includePlugins: !args["no-plugins"]
     });
     const serverCount = Object.keys(bundle.lockfile.servers).length;
     const configKeys = Object.keys(bundle.config).length;
-    import_node_fs8.default.writeFileSync(outputPath, JSON.stringify(bundle, null, 2), "utf-8");
-    console.log(`${import_picocolors4.default.green("\u2713")} Exported to ${import_picocolors4.default.bold(outputFile)}`);
-    console.log(import_picocolors4.default.dim(`  Config keys: ${configKeys}`));
-    console.log(import_picocolors4.default.dim(`  Servers: ${serverCount}`));
-    console.log(import_picocolors4.default.dim(`  Vault: ${bundle.vault ? "included" : "excluded"}`));
-    console.log(import_picocolors4.default.dim(`  Plugins: ${bundle.plugins?.length ?? 0}`));
+    import_node_fs10.default.writeFileSync(outputPath, JSON.stringify(bundle, null, 2), "utf-8");
+    console.log(`${import_picocolors6.default.green("\u2713")} Exported to ${import_picocolors6.default.bold(outputFile)}`);
+    console.log(import_picocolors6.default.dim(`  Config keys: ${configKeys}`));
+    console.log(import_picocolors6.default.dim(`  Servers: ${serverCount}`));
+    console.log(import_picocolors6.default.dim(`  Vault: ${bundle.vault ? "included" : "excluded"}`));
+    console.log(import_picocolors6.default.dim(`  Plugins: ${bundle.plugins?.length ?? 0}`));
   }
 });
 
 // src/commands/import-command.ts
 init_cjs_shims();
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 var p4 = __toESM(require("@clack/prompts"), 1);
-var import_citty5 = require("citty");
-var import_picocolors5 = __toESM(require("picocolors"), 1);
-var import_command_default = (0, import_citty5.defineCommand)({
+var import_citty7 = require("citty");
+var import_picocolors7 = __toESM(require("picocolors"), 1);
+var import_command_default = (0, import_citty7.defineCommand)({
   meta: {
     name: "import",
     description: "Import mcpman config, lockfile, vault, and plugins from an export file"
@@ -2198,21 +2800,21 @@ var import_command_default = (0, import_citty5.defineCommand)({
     }
   },
   async run({ args }) {
-    const filePath = import_node_path9.default.resolve(args.file);
-    if (!import_node_fs9.default.existsSync(filePath)) {
-      console.error(`${import_picocolors5.default.red("\u2717")} File not found: ${filePath}`);
+    const filePath = import_node_path12.default.resolve(args.file);
+    if (!import_node_fs11.default.existsSync(filePath)) {
+      console.error(`${import_picocolors7.default.red("\u2717")} File not found: ${filePath}`);
       process.exit(1);
     }
     let raw;
     try {
-      raw = JSON.parse(import_node_fs9.default.readFileSync(filePath, "utf-8"));
+      raw = JSON.parse(import_node_fs11.default.readFileSync(filePath, "utf-8"));
     } catch {
-      console.error(`${import_picocolors5.default.red("\u2717")} Invalid JSON in ${filePath}`);
+      console.error(`${import_picocolors7.default.red("\u2717")} Invalid JSON in ${filePath}`);
       process.exit(1);
     }
     const error2 = validateBundle(raw);
     if (error2) {
-      console.error(`${import_picocolors5.default.red("\u2717")} Invalid export bundle: ${error2}`);
+      console.error(`${import_picocolors7.default.red("\u2717")} Invalid export bundle: ${error2}`);
       process.exit(1);
     }
     const bundle = raw;
@@ -2222,16 +2824,16 @@ var import_command_default = (0, import_citty5.defineCommand)({
     const hasVault = !!bundle.vault;
     const isDryRun = !!args["dry-run"];
     console.log("");
-    console.log(import_picocolors5.default.bold("Import summary:"));
-    console.log(import_picocolors5.default.dim(`  Source version: mcpman ${bundle.mcpmanVersion}`));
-    console.log(import_picocolors5.default.dim(`  Exported at: ${bundle.exportedAt}`));
-    console.log(`  Config keys: ${import_picocolors5.default.cyan(String(configKeys))}`);
-    console.log(`  Servers: ${import_picocolors5.default.cyan(String(serverCount))}`);
-    console.log(`  Vault: ${hasVault ? import_picocolors5.default.green("included") : import_picocolors5.default.dim("not included")}`);
-    console.log(`  Plugins: ${import_picocolors5.default.cyan(String(pluginCount))}`);
+    console.log(import_picocolors7.default.bold("Import summary:"));
+    console.log(import_picocolors7.default.dim(`  Source version: mcpman ${bundle.mcpmanVersion}`));
+    console.log(import_picocolors7.default.dim(`  Exported at: ${bundle.exportedAt}`));
+    console.log(`  Config keys: ${import_picocolors7.default.cyan(String(configKeys))}`);
+    console.log(`  Servers: ${import_picocolors7.default.cyan(String(serverCount))}`);
+    console.log(`  Vault: ${hasVault ? import_picocolors7.default.green("included") : import_picocolors7.default.dim("not included")}`);
+    console.log(`  Plugins: ${import_picocolors7.default.cyan(String(pluginCount))}`);
     console.log("");
     if (isDryRun) {
-      console.log(import_picocolors5.default.yellow("  [dry-run] No changes applied."));
+      console.log(import_picocolors7.default.yellow("  [dry-run] No changes applied."));
       return;
     }
     if (!args.yes) {
@@ -2245,22 +2847,23 @@ var import_command_default = (0, import_citty5.defineCommand)({
       }
     }
     const summary = importBundle(bundle, { dryRun: false });
-    console.log(`${import_picocolors5.default.green("\u2713")} Import complete`);
-    console.log(import_picocolors5.default.dim(`  Config keys restored: ${summary.configKeys}`));
-    console.log(import_picocolors5.default.dim(`  Servers restored: ${summary.servers}`));
-    console.log(import_picocolors5.default.dim(`  Vault: ${summary.vaultImported ? "restored" : "skipped"}`));
-    console.log(import_picocolors5.default.dim(`  Plugins installed: ${summary.pluginsInstalled}`));
+    console.log(`${import_picocolors7.default.green("\u2713")} Import complete`);
+    console.log(import_picocolors7.default.dim(`  Config keys restored: ${summary.configKeys}`));
+    console.log(import_picocolors7.default.dim(`  Servers restored: ${summary.servers}`));
+    console.log(import_picocolors7.default.dim(`  Vault: ${summary.vaultImported ? "restored" : "skipped"}`));
+    console.log(import_picocolors7.default.dim(`  Plugins installed: ${summary.pluginsInstalled}`));
   }
 });
 
 // src/commands/info.ts
 init_cjs_shims();
-var import_citty6 = require("citty");
+var import_citty8 = require("citty");
 var import_nanospinner2 = require("nanospinner");
-var import_picocolors6 = __toESM(require("picocolors"), 1);
+var import_picocolors8 = __toESM(require("picocolors"), 1);
 
 // src/core/package-info.ts
 init_cjs_shims();
+init_lockfile();
 init_trust_scorer();
 async function buildInfo(name, entry, source = "npm") {
   const resolvedSource = entry?.source ?? source;
@@ -2314,11 +2917,11 @@ async function getPackageInfo(serverName) {
 // src/commands/info.ts
 function colorRisk2(score, riskLevel) {
   const label = score !== null ? `${score}/100 (${riskLevel})` : riskLevel;
-  if (riskLevel === "LOW") return import_picocolors6.default.green(label);
-  if (riskLevel === "MEDIUM") return import_picocolors6.default.yellow(label);
-  if (riskLevel === "HIGH") return import_picocolors6.default.red(label);
-  if (riskLevel === "CRITICAL") return import_picocolors6.default.bold(import_picocolors6.default.red(label));
-  return import_picocolors6.default.dim(label);
+  if (riskLevel === "LOW") return import_picocolors8.default.green(label);
+  if (riskLevel === "MEDIUM") return import_picocolors8.default.yellow(label);
+  if (riskLevel === "HIGH") return import_picocolors8.default.red(label);
+  if (riskLevel === "CRITICAL") return import_picocolors8.default.bold(import_picocolors8.default.red(label));
+  return import_picocolors8.default.dim(label);
 }
 function formatDaysAgo(isoDate) {
   if (!isoDate) return "unknown";
@@ -2328,54 +2931,54 @@ function formatDaysAgo(isoDate) {
   return `${days} days ago`;
 }
 function printInfo(info2) {
-  const installedBadge = info2.isInstalled ? import_picocolors6.default.green(" [installed]") : import_picocolors6.default.dim(" [not installed]");
+  const installedBadge = info2.isInstalled ? import_picocolors8.default.green(" [installed]") : import_picocolors8.default.dim(" [not installed]");
   console.log();
-  console.log(import_picocolors6.default.bold(`  ${info2.name}@${info2.version}`) + installedBadge);
-  console.log(import_picocolors6.default.dim(`  ${"\u2500".repeat(60)}`));
-  console.log(`  ${import_picocolors6.default.dim("Source:")}   ${info2.source}`);
-  console.log(`  ${import_picocolors6.default.dim("Runtime:")}  ${info2.runtime}`);
+  console.log(import_picocolors8.default.bold(`  ${info2.name}@${info2.version}`) + installedBadge);
+  console.log(import_picocolors8.default.dim(`  ${"\u2500".repeat(60)}`));
+  console.log(`  ${import_picocolors8.default.dim("Source:")}   ${info2.source}`);
+  console.log(`  ${import_picocolors8.default.dim("Runtime:")}  ${info2.runtime}`);
   if (info2.description) {
-    console.log(`  ${import_picocolors6.default.dim("Description:")} ${info2.description}`);
+    console.log(`  ${import_picocolors8.default.dim("Description:")} ${info2.description}`);
   }
   if (info2.deprecated) {
-    console.log(`  ${import_picocolors6.default.red("[DEPRECATED]")} This package is deprecated`);
+    console.log(`  ${import_picocolors8.default.red("[DEPRECATED]")} This package is deprecated`);
   }
   console.log();
-  console.log(`  ${import_picocolors6.default.bold("Trust & Security")}`);
-  console.log(`  ${import_picocolors6.default.dim("Trust score:")}   ${colorRisk2(info2.trustScore, info2.riskLevel)}`);
+  console.log(`  ${import_picocolors8.default.bold("Trust & Security")}`);
+  console.log(`  ${import_picocolors8.default.dim("Trust score:")}   ${colorRisk2(info2.trustScore, info2.riskLevel)}`);
   if (info2.source === "npm") {
     console.log(
-      `  ${import_picocolors6.default.dim("Downloads:")}    ${info2.weeklyDownloads.toLocaleString()}/week  ${import_picocolors6.default.dim("|")}  ${import_picocolors6.default.dim("Age:")} ${info2.packageAge}d  ${import_picocolors6.default.dim("|")}  ${import_picocolors6.default.dim("Maintainers:")} ${info2.maintainerCount}`
+      `  ${import_picocolors8.default.dim("Downloads:")}    ${info2.weeklyDownloads.toLocaleString()}/week  ${import_picocolors8.default.dim("|")}  ${import_picocolors8.default.dim("Age:")} ${info2.packageAge}d  ${import_picocolors8.default.dim("|")}  ${import_picocolors8.default.dim("Maintainers:")} ${info2.maintainerCount}`
     );
     if (info2.lastPublish) {
-      console.log(`  ${import_picocolors6.default.dim("Last publish:")} ${formatDaysAgo(info2.lastPublish)}`);
+      console.log(`  ${import_picocolors8.default.dim("Last publish:")} ${formatDaysAgo(info2.lastPublish)}`);
     }
   } else {
-    console.log(import_picocolors6.default.dim("  (Trust data available for npm packages only)"));
+    console.log(import_picocolors8.default.dim("  (Trust data available for npm packages only)"));
   }
   console.log();
-  console.log(`  ${import_picocolors6.default.bold("Environment Variables")}`);
+  console.log(`  ${import_picocolors8.default.bold("Environment Variables")}`);
   if (info2.envVars.length > 0) {
     for (const env of info2.envVars) {
-      console.log(`    ${import_picocolors6.default.cyan("\u2022")} ${env}`);
+      console.log(`    ${import_picocolors8.default.cyan("\u2022")} ${env}`);
     }
   } else {
-    console.log(import_picocolors6.default.dim("    none required"));
+    console.log(import_picocolors8.default.dim("    none required"));
   }
   console.log();
-  console.log(`  ${import_picocolors6.default.bold("Installed Clients")}`);
+  console.log(`  ${import_picocolors8.default.bold("Installed Clients")}`);
   if (info2.installedClients.length > 0) {
     for (const client of info2.installedClients) {
-      console.log(`    ${import_picocolors6.default.green("\u2713")} ${client}`);
+      console.log(`    ${import_picocolors8.default.green("\u2713")} ${client}`);
     }
   } else {
-    console.log(import_picocolors6.default.dim("    Not installed in any client"));
+    console.log(import_picocolors8.default.dim("    Not installed in any client"));
   }
   console.log();
-  console.log(import_picocolors6.default.dim(`  ${"\u2500".repeat(60)}`));
+  console.log(import_picocolors8.default.dim(`  ${"\u2500".repeat(60)}`));
   console.log();
 }
-var info_default = (0, import_citty6.defineCommand)({
+var info_default = (0, import_citty8.defineCommand)({
   meta: {
     name: "info",
     description: "Show detailed metadata for an MCP server (installed or from registry)"
@@ -2399,13 +3002,13 @@ var info_default = (0, import_citty6.defineCommand)({
       info2 = await getPackageInfo(args.server);
     } catch (err) {
       spinner5.error({ text: "Failed to fetch package info" });
-      console.error(import_picocolors6.default.red(String(err)));
+      console.error(import_picocolors8.default.red(String(err)));
       process.exit(1);
     }
     if (!info2) {
       spinner5.error({ text: `Package not found: ${args.server}` });
       console.log(
-        import_picocolors6.default.dim(`
+        import_picocolors8.default.dim(`
   "${args.server}" was not found in the npm registry or your lockfile.
 `)
       );
@@ -2422,10 +3025,11 @@ var info_default = (0, import_citty6.defineCommand)({
 
 // src/commands/init.ts
 init_cjs_shims();
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var p5 = __toESM(require("@clack/prompts"), 1);
-var import_citty7 = require("citty");
-var init_default = (0, import_citty7.defineCommand)({
+var import_citty9 = require("citty");
+init_lockfile();
+var init_default = (0, import_citty9.defineCommand)({
   meta: {
     name: "init",
     description: "Initialize mcpman.lock in the current project"
@@ -2441,7 +3045,7 @@ var init_default = (0, import_citty7.defineCommand)({
   async run({ args }) {
     const nonInteractive = args.yes || !process.stdout.isTTY;
     p5.intro("mcpman init");
-    const targetPath = import_node_path10.default.join(process.cwd(), LOCKFILE_NAME);
+    const targetPath = import_node_path13.default.join(process.cwd(), LOCKFILE_NAME);
     const existing = findLockfile();
     if (existing) {
       if (nonInteractive) {
@@ -2526,7 +3130,7 @@ var init_default = (0, import_citty7.defineCommand)({
 // src/commands/install.ts
 init_cjs_shims();
 var p8 = __toESM(require("@clack/prompts"), 1);
-var import_citty8 = require("citty");
+var import_citty10 = require("citty");
 
 // src/core/installer.ts
 init_cjs_shims();
@@ -2567,6 +3171,7 @@ async function offerVaultSave(serverName, newVars, yes) {
 }
 
 // src/core/installer.ts
+init_lockfile();
 async function loadClients2() {
   try {
     const mod = await Promise.resolve().then(() => (init_client_detector(), client_detector_exports));
@@ -2680,9 +3285,12 @@ async function installServer(input, options = {}) {
   p7.outro(`${metadata.name}@${metadata.version} installed to ${clientTypes.join(", ")}`);
 }
 
+// src/commands/install.ts
+init_lockfile();
+
 // src/utils/logger.ts
 init_cjs_shims();
-var import_picocolors7 = __toESM(require("picocolors"), 1);
+var import_picocolors9 = __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");
@@ -2691,18 +3299,18 @@ function colorize(fn, text2) {
 }
 function info(message) {
   if (isJson) return;
-  console.log(`${colorize(import_picocolors7.default.cyan, "i")} ${message}`);
+  console.log(`${colorize(import_picocolors9.default.cyan, "i")} ${message}`);
 }
 function error(message) {
   if (isJson) return;
-  console.error(`${colorize(import_picocolors7.default.red, "\u2717")} ${message}`);
+  console.error(`${colorize(import_picocolors9.default.red, "\u2717")} ${message}`);
 }
 function json(data) {
   console.log(JSON.stringify(data, null, 2));
 }
 
 // src/commands/install.ts
-var install_default = (0, import_citty8.defineCommand)({
+var install_default = (0, import_citty10.defineCommand)({
   meta: {
     name: "install",
     description: "Install an MCP server into one or more AI clients"
@@ -2763,16 +3371,220 @@ async function restoreFromLockfile() {
   p8.outro("Restore complete.");
 }
 
+// src/commands/link.ts
+init_cjs_shims();
+var import_node_path15 = __toESM(require("path"), 1);
+var import_citty11 = require("citty");
+var import_picocolors10 = __toESM(require("picocolors"), 1);
+init_client_detector();
+
+// src/core/link-service.ts
+init_cjs_shims();
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
+init_lockfile();
+function detectLocalServer(dir) {
+  if (!import_node_fs12.default.existsSync(dir)) {
+    throw new Error(`Directory does not exist: ${dir}`);
+  }
+  const pkgPath = import_node_path14.default.join(dir, "package.json");
+  if (import_node_fs12.default.existsSync(pkgPath)) {
+    return detectNodeServer(dir, pkgPath);
+  }
+  const pyprojectPath = import_node_path14.default.join(dir, "pyproject.toml");
+  if (import_node_fs12.default.existsSync(pyprojectPath)) {
+    return detectPythonServer(dir, pyprojectPath);
+  }
+  throw new Error(
+    `No package.json or pyproject.toml found in '${dir}'. Is this an MCP server project?`
+  );
+}
+function detectNodeServer(dir, pkgPath) {
+  const raw = import_node_fs12.default.readFileSync(pkgPath, "utf-8");
+  const pkg = JSON.parse(raw);
+  const name = String(pkg.name ?? import_node_path14.default.basename(dir));
+  const version = String(pkg.version ?? "0.0.0");
+  let entryPoint = null;
+  if (pkg.bin) {
+    if (typeof pkg.bin === "string") {
+      entryPoint = import_node_path14.default.resolve(dir, pkg.bin);
+    } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+      const binObj = pkg.bin;
+      const firstBin = Object.values(binObj)[0];
+      if (firstBin) entryPoint = import_node_path14.default.resolve(dir, firstBin);
+    }
+  }
+  if (!entryPoint && pkg.main) {
+    entryPoint = import_node_path14.default.resolve(dir, String(pkg.main));
+  }
+  if (!entryPoint) {
+    const candidates = ["src/index.ts", "src/index.js", "index.ts", "index.js"];
+    for (const c of candidates) {
+      const candidate = import_node_path14.default.join(dir, c);
+      if (import_node_fs12.default.existsSync(candidate)) {
+        entryPoint = candidate;
+        break;
+      }
+    }
+  }
+  if (!entryPoint) {
+    throw new Error(`Cannot determine entry point for Node server in '${dir}'.`);
+  }
+  const isTs = entryPoint.endsWith(".ts");
+  const command = isTs ? "npx" : "node";
+  const args = isTs ? ["tsx", entryPoint] : [entryPoint];
+  const mcpField = pkg.mcp;
+  const envVars = [];
+  if (mcpField?.env && Array.isArray(mcpField.env)) {
+    for (const e of mcpField.env) {
+      if (typeof e === "string") envVars.push(e);
+      else if (typeof e === "object" && e !== null && "name" in e) {
+        envVars.push(String(e.name));
+      }
+    }
+  }
+  return { name, version, command, args, envVars, absolutePath: dir, runtime: "node" };
+}
+function detectPythonServer(dir, pyprojectPath) {
+  const raw = import_node_fs12.default.readFileSync(pyprojectPath, "utf-8");
+  const name = extractTomlValue(raw, "name") ?? import_node_path14.default.basename(dir);
+  const version = extractTomlValue(raw, "version") ?? "0.0.0";
+  let pythonCmd = "python3";
+  const venvPython = import_node_path14.default.join(dir, ".venv", "bin", "python");
+  if (import_node_fs12.default.existsSync(venvPython)) {
+    pythonCmd = venvPython;
+  }
+  const entryCandidate = [
+    import_node_path14.default.join(dir, "main.py"),
+    import_node_path14.default.join(dir, name.replace(/-/g, "_"), "main.py"),
+    import_node_path14.default.join(dir, "__main__.py")
+  ].find((p13) => import_node_fs12.default.existsSync(p13));
+  const entryPoint = entryCandidate ?? import_node_path14.default.join(dir, "main.py");
+  return {
+    name,
+    version,
+    command: pythonCmd,
+    args: [entryPoint],
+    envVars: [],
+    absolutePath: dir,
+    runtime: "python"
+  };
+}
+function extractTomlValue(content, key) {
+  const match = content.match(new RegExp(`^${key}\\s*=\\s*"([^"]+)"`, "m"));
+  return match ? match[1] : null;
+}
+async function registerLinkedServer(linkResult, clients, lockfilePath, nameOverride) {
+  const serverName = nameOverride ?? linkResult.name;
+  const registered = [];
+  for (const client of clients) {
+    try {
+      await client.addServer(serverName, {
+        command: linkResult.command,
+        args: linkResult.args
+      });
+      registered.push(client.type);
+    } catch {
+    }
+  }
+  const lockEntry = {
+    version: linkResult.version,
+    source: "local",
+    resolved: linkResult.absolutePath,
+    integrity: "local",
+    runtime: linkResult.runtime,
+    command: linkResult.command,
+    args: linkResult.args,
+    envVars: linkResult.envVars,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    clients: registered
+  };
+  const existing = readLockfile(lockfilePath);
+  existing.servers[serverName] = lockEntry;
+  const { writeLockfile: writeLockfile2 } = await Promise.resolve().then(() => (init_lockfile(), lockfile_exports));
+  writeLockfile2(existing, lockfilePath);
+  return registered;
+}
+
+// src/commands/link.ts
+var link_default = (0, import_citty11.defineCommand)({
+  meta: {
+    name: "link",
+    description: "Register a local MCP server directory with AI clients"
+  },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Path to local MCP server directory (default: .)",
+      required: false
+    },
+    client: {
+      type: "string",
+      description: "Register with specific client only (claude-desktop, cursor, vscode, windsurf)",
+      alias: "c"
+    },
+    name: {
+      type: "string",
+      description: "Override the detected server name",
+      alias: "n"
+    }
+  },
+  async run({ args }) {
+    const dirArg = args.dir ?? ".";
+    const clientFilter = args.client;
+    const nameOverride = args.name;
+    const absoluteDir = import_node_path15.default.resolve(dirArg);
+    let linkResult;
+    try {
+      linkResult = detectLocalServer(absoluteDir);
+    } catch (err) {
+      console.error(import_picocolors10.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+    const serverName = nameOverride ?? linkResult.name;
+    console.log(import_picocolors10.default.dim(`
+  Detected: ${import_picocolors10.default.cyan(serverName)} (${linkResult.runtime})`));
+    console.log(import_picocolors10.default.dim(`  Path: ${absoluteDir}`));
+    console.log(import_picocolors10.default.dim(`  Command: ${linkResult.command} ${linkResult.args.join(" ")}`));
+    const allClients = await getInstalledClients();
+    const clients = clientFilter ? allClients.filter((c) => c.type === clientFilter) : allClients;
+    if (clientFilter && clients.length === 0) {
+      console.error(import_picocolors10.default.red(`  Error: Unknown client '${clientFilter}'.`));
+      process.exit(1);
+    }
+    let registered;
+    try {
+      registered = await registerLinkedServer(linkResult, clients, void 0, nameOverride);
+    } catch (err) {
+      console.error(import_picocolors10.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+    if (registered.length === 0) {
+      console.log(import_picocolors10.default.yellow("  Warning: No clients registered. Are any AI clients installed?"));
+      console.log(import_picocolors10.default.dim(`  Server saved to lockfile with source "local".`));
+    } else {
+      console.log(import_picocolors10.default.green(`
+  Linked ${import_picocolors10.default.bold(serverName)} to: ${registered.join(", ")}
+`));
+      console.log(import_picocolors10.default.dim(`  Run ${import_picocolors10.default.cyan("mcpman list")} to verify.`));
+      console.log(
+        import_picocolors10.default.dim(`  Run ${import_picocolors10.default.cyan(`mcpman watch ${serverName}`)} to start with auto-restart.`)
+      );
+    }
+    console.log();
+  }
+});
+
 // src/commands/list.ts
 init_cjs_shims();
-var import_citty9 = require("citty");
-var import_picocolors8 = __toESM(require("picocolors"), 1);
+var import_citty12 = require("citty");
+var import_picocolors11 = __toESM(require("picocolors"), 1);
 var STATUS_ICON = {
-  healthy: import_picocolors8.default.green("\u25CF"),
-  unhealthy: import_picocolors8.default.red("\u25CF"),
-  unknown: import_picocolors8.default.dim("\u25CB")
+  healthy: import_picocolors11.default.green("\u25CF"),
+  unhealthy: import_picocolors11.default.red("\u25CF"),
+  unknown: import_picocolors11.default.dim("\u25CB")
 };
-var list_default = (0, import_citty9.defineCommand)({
+var list_default = (0, import_citty12.defineCommand)({
   meta: {
     name: "list",
     description: "List installed MCP servers"
@@ -2793,8 +3605,8 @@ var list_default = (0, import_citty9.defineCommand)({
     if (servers.length === 0) {
       const filter = args.client ? ` for client "${args.client}"` : "";
       console.log(
-        import_picocolors8.default.dim(
-          `No MCP servers installed${filter}. Run ${import_picocolors8.default.cyan("mcpman install <server>")} to get started.`
+        import_picocolors11.default.dim(
+          `No MCP servers installed${filter}. Run ${import_picocolors11.default.cyan("mcpman install <server>")} to get started.`
         )
       );
       return;
@@ -2820,9 +3632,9 @@ var list_default = (0, import_citty9.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_picocolors8.default.dim(header));
+    console.log(import_picocolors11.default.dim(header));
     console.log(
-      import_picocolors8.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientsWidth)}  ${"-".repeat(20)}  ------`)
+      import_picocolors11.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientsWidth)}  ${"-".repeat(20)}  ------`)
     );
     for (const s of withStatus) {
       const icon = STATUS_ICON[s.status];
@@ -2837,7 +3649,7 @@ var list_default = (0, import_citty9.defineCommand)({
     }
     const clientSet = new Set(withStatus.flatMap((s) => s.clients));
     console.log(
-      import_picocolors8.default.dim(
+      import_picocolors11.default.dim(
         `
   ${withStatus.length} server${withStatus.length !== 1 ? "s" : ""} \xB7 ${clientSet.size} client${clientSet.size !== 1 ? "s" : ""}`
       )
@@ -2863,10 +3675,11 @@ function formatClients(clients) {
 // src/commands/logs.ts
 init_cjs_shims();
 var import_node_child_process4 = require("child_process");
-var import_citty10 = require("citty");
-var import_picocolors9 = __toESM(require("picocolors"), 1);
+var import_citty13 = require("citty");
+var import_picocolors12 = __toESM(require("picocolors"), 1);
+init_lockfile();
 init_vault_service();
-var logs_default = (0, import_citty10.defineCommand)({
+var logs_default = (0, import_citty13.defineCommand)({
   meta: {
     name: "logs",
     description: "Stream stdout/stderr from an MCP server"
@@ -2889,7 +3702,7 @@ var logs_default = (0, import_citty10.defineCommand)({
     const lockfile = readLockfile();
     const entry = lockfile.servers[serverName];
     if (!entry) {
-      console.error(import_picocolors9.default.red(`  Error: Server '${serverName}' is not installed.`));
+      console.error(import_picocolors12.default.red(`  Error: Server '${serverName}' is not installed.`));
       process.exit(1);
     }
     const lockfileEnv = parseEnvFlags(entry.envVars);
@@ -2899,24 +3712,24 @@ var logs_default = (0, import_citty10.defineCommand)({
       ...lockfileEnv,
       ...vaultEnv
     };
-    console.log(import_picocolors9.default.dim(`  Streaming logs for ${import_picocolors9.default.cyan(serverName)}... (Ctrl+C to stop)
+    console.log(import_picocolors12.default.dim(`  Streaming logs for ${import_picocolors12.default.cyan(serverName)}... (Ctrl+C to stop)
 `));
     const child = (0, import_node_child_process4.spawn)(entry.command, entry.args, {
       env: finalEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
     child.stdout?.on("data", (chunk) => {
-      process.stdout.write(import_picocolors9.default.dim("[stdout] ") + chunk.toString());
+      process.stdout.write(import_picocolors12.default.dim("[stdout] ") + chunk.toString());
     });
     child.stderr?.on("data", (chunk) => {
-      process.stderr.write(import_picocolors9.default.yellow("[stderr] ") + chunk.toString());
+      process.stderr.write(import_picocolors12.default.yellow("[stderr] ") + chunk.toString());
     });
     child.on("error", (err) => {
-      console.error(import_picocolors9.default.red(`  Failed to start '${serverName}': ${err.message}`));
+      console.error(import_picocolors12.default.red(`  Failed to start '${serverName}': ${err.message}`));
       process.exit(1);
     });
     child.on("close", (code) => {
-      console.log(import_picocolors9.default.dim(`
+      console.log(import_picocolors12.default.dim(`
   Process exited with code ${code ?? 0}`));
       process.exit(code ?? 0);
     });
@@ -2942,10 +3755,10 @@ async function loadVaultSecrets(serverName) {
 
 // src/commands/plugin.ts
 init_cjs_shims();
-var import_citty11 = require("citty");
+var import_citty14 = require("citty");
 var import_nanospinner3 = require("nanospinner");
-var import_picocolors10 = __toESM(require("picocolors"), 1);
-var addCommand = (0, import_citty11.defineCommand)({
+var import_picocolors13 = __toESM(require("picocolors"), 1);
+var addCommand = (0, import_citty14.defineCommand)({
   meta: { name: "add", description: "Install a plugin package" },
   args: {
     package: {
@@ -2963,23 +3776,23 @@ var addCommand = (0, import_citty11.defineCommand)({
       spinner5.stop();
       if (loaded) {
         console.log(
-          `${import_picocolors10.default.green("\u2713")} Plugin ${import_picocolors10.default.bold(loaded.name)} installed (prefix: ${import_picocolors10.default.cyan(loaded.prefix)})`
+          `${import_picocolors13.default.green("\u2713")} Plugin ${import_picocolors13.default.bold(loaded.name)} installed (prefix: ${import_picocolors13.default.cyan(loaded.prefix)})`
         );
       } else {
         console.log(
-          `${import_picocolors10.default.yellow("\u26A0")} Package ${import_picocolors10.default.bold(pkg)} installed but does not export a valid mcpman plugin.`
+          `${import_picocolors13.default.yellow("\u26A0")} Package ${import_picocolors13.default.bold(pkg)} installed but does not export a valid mcpman plugin.`
         );
       }
     } catch (err) {
       spinner5.stop();
       console.error(
-        `${import_picocolors10.default.red("\u2717")} Failed to install plugin: ${err instanceof Error ? err.message : String(err)}`
+        `${import_picocolors13.default.red("\u2717")} Failed to install plugin: ${err instanceof Error ? err.message : String(err)}`
       );
       process.exit(1);
     }
   }
 });
-var removeCommand = (0, import_citty11.defineCommand)({
+var removeCommand = (0, import_citty14.defineCommand)({
   meta: { name: "remove", description: "Uninstall a plugin package" },
   args: {
     package: {
@@ -2992,46 +3805,46 @@ var removeCommand = (0, import_citty11.defineCommand)({
     const pkg = args.package;
     const installed = listPluginPackages();
     if (!installed.includes(pkg)) {
-      console.log(import_picocolors10.default.dim(`Plugin "${pkg}" is not installed.`));
+      console.log(import_picocolors13.default.dim(`Plugin "${pkg}" is not installed.`));
       return;
     }
     try {
       removePluginPackage(pkg);
-      console.log(`${import_picocolors10.default.green("\u2713")} Plugin ${import_picocolors10.default.bold(pkg)} removed.`);
+      console.log(`${import_picocolors13.default.green("\u2713")} Plugin ${import_picocolors13.default.bold(pkg)} removed.`);
     } catch (err) {
       console.error(
-        `${import_picocolors10.default.red("\u2717")} Failed to remove plugin: ${err instanceof Error ? err.message : String(err)}`
+        `${import_picocolors13.default.red("\u2717")} Failed to remove plugin: ${err instanceof Error ? err.message : String(err)}`
       );
       process.exit(1);
     }
   }
 });
-var listCommand2 = (0, import_citty11.defineCommand)({
+var listCommand2 = (0, import_citty14.defineCommand)({
   meta: { name: "list", description: "List installed plugins" },
   run() {
     const packages = listPluginPackages();
     if (packages.length === 0) {
-      console.log(import_picocolors10.default.dim("No plugins installed. Use `mcpman plugin add <package>`."));
+      console.log(import_picocolors13.default.dim("No plugins installed. Use `mcpman plugin add <package>`."));
       return;
     }
     console.log("");
-    console.log(import_picocolors10.default.bold("Installed plugins:"));
+    console.log(import_picocolors13.default.bold("Installed plugins:"));
     console.log("");
     for (const pkg of packages) {
       const loaded = loadPlugin(pkg);
       if (loaded) {
         console.log(
-          `  ${import_picocolors10.default.green("\u25CF")} ${import_picocolors10.default.bold(loaded.name)}  prefix: ${import_picocolors10.default.cyan(loaded.prefix)}  pkg: ${import_picocolors10.default.dim(pkg)}`
+          `  ${import_picocolors13.default.green("\u25CF")} ${import_picocolors13.default.bold(loaded.name)}  prefix: ${import_picocolors13.default.cyan(loaded.prefix)}  pkg: ${import_picocolors13.default.dim(pkg)}`
         );
       } else {
-        console.log(`  ${import_picocolors10.default.yellow("\u25CF")} ${import_picocolors10.default.dim(pkg)}  ${import_picocolors10.default.yellow("(failed to load)")}`);
+        console.log(`  ${import_picocolors13.default.yellow("\u25CF")} ${import_picocolors13.default.dim(pkg)}  ${import_picocolors13.default.yellow("(failed to load)")}`);
       }
     }
     console.log("");
-    console.log(import_picocolors10.default.dim(`  ${packages.length} plugin${packages.length !== 1 ? "s" : ""} installed`));
+    console.log(import_picocolors13.default.dim(`  ${packages.length} plugin${packages.length !== 1 ? "s" : ""} installed`));
   }
 });
-var plugin_default = (0, import_citty11.defineCommand)({
+var plugin_default = (0, import_citty14.defineCommand)({
   meta: {
     name: "plugin",
     description: "Manage mcpman plugins for custom registries"
@@ -3045,24 +3858,26 @@ var plugin_default = (0, import_citty11.defineCommand)({
 
 // src/commands/profiles.ts
 init_cjs_shims();
-var import_citty12 = require("citty");
-var import_picocolors11 = __toESM(require("picocolors"), 1);
+var import_citty15 = require("citty");
+var import_picocolors14 = __toESM(require("picocolors"), 1);
+init_lockfile();
 
 // src/core/profile-service.ts
 init_cjs_shims();
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 init_paths();
+init_lockfile();
 function ensureDir(dir = getProfilesDir()) {
-  import_node_fs10.default.mkdirSync(dir, { recursive: true });
+  import_node_fs13.default.mkdirSync(dir, { recursive: true });
 }
 function profilePath(name, dir = getProfilesDir()) {
-  return import_node_path11.default.join(dir, `${name}.json`);
+  return import_node_path16.default.join(dir, `${name}.json`);
 }
 function createProfile(name, description = "", dir = getProfilesDir()) {
   ensureDir(dir);
   const filePath = profilePath(name, dir);
-  if (import_node_fs10.default.existsSync(filePath)) {
+  if (import_node_fs13.default.existsSync(filePath)) {
     throw new Error(`Profile '${name}' already exists. Delete it first or use a different name.`);
   }
   const lockfile = readLockfile();
@@ -3072,16 +3887,16 @@ function createProfile(name, description = "", dir = getProfilesDir()) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     servers: lockfile.servers
   };
-  import_node_fs10.default.writeFileSync(filePath, JSON.stringify(profile, null, 2), "utf-8");
+  import_node_fs13.default.writeFileSync(filePath, JSON.stringify(profile, null, 2), "utf-8");
   return profile;
 }
 function listProfiles(dir = getProfilesDir()) {
   ensureDir(dir);
-  const files = import_node_fs10.default.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const files = import_node_fs13.default.readdirSync(dir).filter((f) => f.endsWith(".json"));
   const profiles = [];
   for (const file of files) {
     try {
-      const raw = import_node_fs10.default.readFileSync(import_node_path11.default.join(dir, file), "utf-8");
+      const raw = import_node_fs13.default.readFileSync(import_node_path16.default.join(dir, file), "utf-8");
       const data = JSON.parse(raw);
       profiles.push(data);
     } catch {
@@ -3091,9 +3906,9 @@ function listProfiles(dir = getProfilesDir()) {
 }
 function loadProfile(name, dir = getProfilesDir()) {
   const filePath = profilePath(name, dir);
-  if (!import_node_fs10.default.existsSync(filePath)) return null;
+  if (!import_node_fs13.default.existsSync(filePath)) return null;
   try {
-    const raw = import_node_fs10.default.readFileSync(filePath, "utf-8");
+    const raw = import_node_fs13.default.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3101,13 +3916,13 @@ function loadProfile(name, dir = getProfilesDir()) {
 }
 function deleteProfile(name, dir = getProfilesDir()) {
   const filePath = profilePath(name, dir);
-  if (!import_node_fs10.default.existsSync(filePath)) return false;
-  import_node_fs10.default.unlinkSync(filePath);
+  if (!import_node_fs13.default.existsSync(filePath)) return false;
+  import_node_fs13.default.unlinkSync(filePath);
   return true;
 }
 
 // src/commands/profiles.ts
-var profiles_default = (0, import_citty12.defineCommand)({
+var profiles_default = (0, import_citty15.defineCommand)({
   meta: {
     name: "profiles",
     description: "Manage named server configuration profiles"
@@ -3136,16 +3951,16 @@ var profiles_default = (0, import_citty12.defineCommand)({
       case "create": {
         if (!name) {
           console.error(
-            import_picocolors11.default.red("  Error: Profile name required. Usage: mcpman profiles create <name>")
+            import_picocolors14.default.red("  Error: Profile name required. Usage: mcpman profiles create <name>")
           );
           process.exit(1);
         }
         try {
           const profile = createProfile(name, args.description ?? "");
           const count = Object.keys(profile.servers).length;
-          console.log(import_picocolors11.default.green(`  \u2713 Profile '${name}' created with ${count} server(s).`));
+          console.log(import_picocolors14.default.green(`  \u2713 Profile '${name}' created with ${count} server(s).`));
         } catch (err) {
-          console.error(import_picocolors11.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          console.error(import_picocolors14.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
           process.exit(1);
         }
         break;
@@ -3153,38 +3968,38 @@ var profiles_default = (0, import_citty12.defineCommand)({
       case "switch": {
         if (!name) {
           console.error(
-            import_picocolors11.default.red("  Error: Profile name required. Usage: mcpman profiles switch <name>")
+            import_picocolors14.default.red("  Error: Profile name required. Usage: mcpman profiles switch <name>")
           );
           process.exit(1);
         }
         const profile = loadProfile(name);
         if (!profile) {
-          console.error(import_picocolors11.default.red(`  Error: Profile '${name}' not found.`));
+          console.error(import_picocolors14.default.red(`  Error: Profile '${name}' not found.`));
           process.exit(1);
         }
         const lockData = { lockfileVersion: 1, servers: profile.servers };
         writeLockfile(lockData);
         const count = Object.keys(profile.servers).length;
-        console.log(import_picocolors11.default.green(`  \u2713 Switched to profile '${name}' (${count} servers).`));
-        console.log(import_picocolors11.default.dim("  Run mcpman sync to apply to all clients."));
+        console.log(import_picocolors14.default.green(`  \u2713 Switched to profile '${name}' (${count} servers).`));
+        console.log(import_picocolors14.default.dim("  Run mcpman sync to apply to all clients."));
         break;
       }
       case "list": {
         const profiles = listProfiles();
         if (profiles.length === 0) {
           console.log(
-            import_picocolors11.default.dim("  No profiles saved. Create one with: mcpman profiles create <name>")
+            import_picocolors14.default.dim("  No profiles saved. Create one with: mcpman profiles create <name>")
           );
           return;
         }
-        console.log(import_picocolors11.default.bold(`
+        console.log(import_picocolors14.default.bold(`
   Profiles (${profiles.length})
 `));
         for (const p13 of profiles) {
           const count = Object.keys(p13.servers).length;
-          const desc = p13.description ? import_picocolors11.default.dim(` \u2014 ${p13.description}`) : "";
+          const desc = p13.description ? import_picocolors14.default.dim(` \u2014 ${p13.description}`) : "";
           console.log(
-            `  ${import_picocolors11.default.cyan("\u25CF")} ${import_picocolors11.default.bold(p13.name)}  ${import_picocolors11.default.dim(`${count} server(s)`)}${desc}`
+            `  ${import_picocolors14.default.cyan("\u25CF")} ${import_picocolors14.default.bold(p13.name)}  ${import_picocolors14.default.dim(`${count} server(s)`)}${desc}`
           );
         }
         console.log();
@@ -3193,33 +4008,203 @@ var profiles_default = (0, import_citty12.defineCommand)({
       case "delete": {
         if (!name) {
           console.error(
-            import_picocolors11.default.red("  Error: Profile name required. Usage: mcpman profiles delete <name>")
+            import_picocolors14.default.red("  Error: Profile name required. Usage: mcpman profiles delete <name>")
           );
           process.exit(1);
         }
         const deleted = deleteProfile(name);
         if (deleted) {
-          console.log(import_picocolors11.default.green(`  \u2713 Profile '${name}' deleted.`));
+          console.log(import_picocolors14.default.green(`  \u2713 Profile '${name}' deleted.`));
         } else {
-          console.error(import_picocolors11.default.red(`  Error: Profile '${name}' not found.`));
+          console.error(import_picocolors14.default.red(`  Error: Profile '${name}' not found.`));
           process.exit(1);
         }
         break;
       }
       default:
         console.error(
-          import_picocolors11.default.red(`  Unknown action '${action}'. Use: create, switch, list, or delete.`)
+          import_picocolors14.default.red(`  Unknown action '${action}'. Use: create, switch, list, or delete.`)
         );
         process.exit(1);
     }
   }
 });
 
+// src/commands/registry.ts
+init_cjs_shims();
+var import_citty16 = require("citty");
+var import_picocolors15 = __toESM(require("picocolors"), 1);
+
+// src/core/registry-manager.ts
+init_cjs_shims();
+var BUILTIN_REGISTRIES = [
+  { name: "npm", url: "https://registry.npmjs.org", builtin: true },
+  { name: "smithery", url: "https://registry.smithery.ai", builtin: true }
+];
+function validateUrl(url) {
+  try {
+    new URL(url);
+  } catch {
+    throw new Error(
+      `Invalid URL: "${url}". Must be a valid URL (e.g. https://registry.example.com)`
+    );
+  }
+}
+function readCustomRegistries(configPath) {
+  const config = readConfig(configPath);
+  const raw = config.registries;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((r) => !r.builtin);
+}
+function writeCustomRegistries(entries, configPath) {
+  const config = readConfig(configPath);
+  config.registries = entries;
+  writeConfig(config, configPath);
+}
+function getRegistries(configPath) {
+  const custom = readCustomRegistries(configPath);
+  return [...BUILTIN_REGISTRIES, ...custom];
+}
+function addRegistry(name, url, configPath) {
+  validateUrl(url);
+  const all = getRegistries(configPath);
+  if (all.some((r) => r.name === name)) {
+    throw new Error(`Registry '${name}' already exists. Use a different name or remove it first.`);
+  }
+  const custom = readCustomRegistries(configPath);
+  custom.push({ name, url, builtin: false });
+  writeCustomRegistries(custom, configPath);
+}
+function removeRegistry(name, configPath) {
+  if (BUILTIN_REGISTRIES.some((r) => r.name === name)) {
+    throw new Error(`Cannot remove built-in registry '${name}'.`);
+  }
+  const custom = readCustomRegistries(configPath);
+  const idx = custom.findIndex((r) => r.name === name);
+  if (idx === -1) {
+    throw new Error(`Registry '${name}' not found.`);
+  }
+  custom.splice(idx, 1);
+  writeCustomRegistries(custom, configPath);
+}
+function setDefaultRegistry(name, configPath) {
+  const all = getRegistries(configPath);
+  if (!all.some((r) => r.name === name)) {
+    throw new Error(
+      `Registry '${name}' not found. Add it first with: mcpman registry add ${name} <url>`
+    );
+  }
+  const config = readConfig(configPath);
+  config.defaultRegistry = name;
+  writeConfig(config, configPath);
+}
+function getDefaultRegistry(configPath) {
+  const config = readConfig(configPath);
+  return String(config.defaultRegistry ?? "npm");
+}
+
+// src/commands/registry.ts
+var registry_default = (0, import_citty16.defineCommand)({
+  meta: {
+    name: "registry",
+    description: "Manage custom registry URLs"
+  },
+  args: {
+    action: {
+      type: "positional",
+      description: "Action: list, add, remove, set-default",
+      required: true
+    },
+    name: {
+      type: "positional",
+      description: "Registry name (for add/remove/set-default)",
+      required: false
+    },
+    url: {
+      type: "positional",
+      description: "Registry URL (for add)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const action = args.action.toLowerCase();
+    const name = args.name;
+    const url = args.url;
+    switch (action) {
+      case "list": {
+        const registries = getRegistries();
+        const defaultName = getDefaultRegistry();
+        console.log(import_picocolors15.default.bold("\n  Registries\n"));
+        for (const r of registries) {
+          const isDefault = r.name === defaultName;
+          const defaultTag = isDefault ? import_picocolors15.default.green(" (default)") : "";
+          const builtinTag = r.builtin ? import_picocolors15.default.dim(" [builtin]") : "";
+          console.log(
+            `  ${isDefault ? import_picocolors15.default.green("\u25CF") : import_picocolors15.default.dim("\u25CB")} ${import_picocolors15.default.bold(r.name)}${defaultTag}${builtinTag}`
+          );
+          console.log(`    ${import_picocolors15.default.dim(r.url)}`);
+        }
+        console.log();
+        break;
+      }
+      case "add": {
+        if (!name) {
+          console.error(import_picocolors15.default.red("  Error: Usage: mcpman registry add <name> <url>"));
+          process.exit(1);
+        }
+        if (!url) {
+          console.error(import_picocolors15.default.red("  Error: Usage: mcpman registry add <name> <url>"));
+          process.exit(1);
+        }
+        try {
+          addRegistry(name, url);
+          console.log(import_picocolors15.default.green(`  Added registry '${name}' \u2192 ${url}`));
+        } catch (err) {
+          console.error(import_picocolors15.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          process.exit(1);
+        }
+        break;
+      }
+      case "remove": {
+        if (!name) {
+          console.error(import_picocolors15.default.red("  Error: Usage: mcpman registry remove <name>"));
+          process.exit(1);
+        }
+        try {
+          removeRegistry(name);
+          console.log(import_picocolors15.default.green(`  Removed registry '${name}'.`));
+        } catch (err) {
+          console.error(import_picocolors15.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          process.exit(1);
+        }
+        break;
+      }
+      case "set-default": {
+        if (!name) {
+          console.error(import_picocolors15.default.red("  Error: Usage: mcpman registry set-default <name>"));
+          process.exit(1);
+        }
+        try {
+          setDefaultRegistry(name);
+          console.log(import_picocolors15.default.green(`  Default registry set to '${name}'.`));
+        } catch (err) {
+          console.error(import_picocolors15.default.red(`  Error: ${err instanceof Error ? err.message : String(err)}`));
+          process.exit(1);
+        }
+        break;
+      }
+      default:
+        console.error(import_picocolors15.default.red(`  Unknown action '${action}'. Use: list, add, remove, set-default.`));
+        process.exit(1);
+    }
+  }
+});
+
 // src/commands/remove.ts
 init_cjs_shims();
 var p9 = __toESM(require("@clack/prompts"), 1);
-var import_citty13 = require("citty");
-var import_picocolors12 = __toESM(require("picocolors"), 1);
+var import_citty17 = require("citty");
+var import_picocolors16 = __toESM(require("picocolors"), 1);
 init_client_detector();
 var CLIENT_DISPLAY2 = {
   "claude-desktop": "Claude",
@@ -3230,7 +4215,7 @@ var CLIENT_DISPLAY2 = {
 function clientDisplayName(type) {
   return CLIENT_DISPLAY2[type] ?? type;
 }
-var remove_default = (0, import_citty13.defineCommand)({
+var remove_default = (0, import_citty17.defineCommand)({
   meta: {
     name: "remove",
     description: "Remove an MCP server from one or more AI clients"
@@ -3257,7 +4242,7 @@ var remove_default = (0, import_citty13.defineCommand)({
     }
   },
   async run({ args }) {
-    p9.intro(import_picocolors12.default.bold("mcpman remove"));
+    p9.intro(import_picocolors16.default.bold("mcpman remove"));
     const serverName = args.server;
     const servers = await getInstalledServers();
     const match = servers.find((s) => s.name === serverName);
@@ -3267,7 +4252,7 @@ var remove_default = (0, import_citty13.defineCommand)({
         (s) => s.name.includes(serverName) || serverName.includes(s.name)
       );
       if (similar.length > 0) {
-        p9.log.info(`Did you mean: ${similar.map((s) => import_picocolors12.default.cyan(s.name)).join(", ")}?`);
+        p9.log.info(`Did you mean: ${similar.map((s) => import_picocolors16.default.cyan(s.name)).join(", ")}?`);
       }
       p9.outro("Nothing to remove.");
       return;
@@ -3302,7 +4287,7 @@ var remove_default = (0, import_citty13.defineCommand)({
     if (!args.yes) {
       const clientNames = targetClients.map(clientDisplayName).join(", ");
       const confirmed = await p9.confirm({
-        message: `Remove ${import_picocolors12.default.cyan(serverName)} from ${import_picocolors12.default.yellow(clientNames)}?`
+        message: `Remove ${import_picocolors16.default.cyan(serverName)} from ${import_picocolors16.default.yellow(clientNames)}?`
       });
       if (p9.isCancel(confirmed) || !confirmed) {
         p9.outro("Cancelled.");
@@ -3327,20 +4312,21 @@ var remove_default = (0, import_citty13.defineCommand)({
     }
     if (errors.length > 0) {
       for (const e of errors) p9.log.error(e);
-      p9.outro(import_picocolors12.default.red("Completed with errors."));
+      p9.outro(import_picocolors16.default.red("Completed with errors."));
       process.exit(1);
     }
-    p9.outro(import_picocolors12.default.green(`Removed "${serverName}" successfully.`));
+    p9.outro(import_picocolors16.default.green(`Removed "${serverName}" successfully.`));
   }
 });
 
 // src/commands/run.ts
 init_cjs_shims();
 var import_node_child_process5 = require("child_process");
-var import_citty14 = require("citty");
-var import_picocolors13 = __toESM(require("picocolors"), 1);
+var import_citty18 = require("citty");
+var import_picocolors17 = __toESM(require("picocolors"), 1);
+init_lockfile();
 init_vault_service();
-var run_default = (0, import_citty14.defineCommand)({
+var run_default = (0, import_citty18.defineCommand)({
   meta: {
     name: "run",
     description: "Run an installed MCP server with vault secrets injected"
@@ -3362,8 +4348,8 @@ var run_default = (0, import_citty14.defineCommand)({
     const lockfile = readLockfile();
     const entry = lockfile.servers[serverName];
     if (!entry) {
-      console.error(import_picocolors13.default.red(`  Error: Server '${serverName}' is not installed.`));
-      console.error(import_picocolors13.default.dim(`  Run ${import_picocolors13.default.cyan("mcpman install <server>")} to install it first.`));
+      console.error(import_picocolors17.default.red(`  Error: Server '${serverName}' is not installed.`));
+      console.error(import_picocolors17.default.dim(`  Run ${import_picocolors17.default.cyan("mcpman install <server>")} to install it first.`));
       process.exit(1);
     }
     const lockfileEnv = parseEnvFlags(entry.envVars);
@@ -3375,7 +4361,7 @@ var run_default = (0, import_citty14.defineCommand)({
       ...vaultEnv,
       ...cliEnv
     };
-    console.log(import_picocolors13.default.dim(`  Running ${import_picocolors13.default.cyan(serverName)}...`));
+    console.log(import_picocolors17.default.dim(`  Running ${import_picocolors17.default.cyan(serverName)}...`));
     const child = (0, import_node_child_process5.spawn)(entry.command, entry.args, {
       env: finalEnv,
       stdio: "inherit"
@@ -3393,7 +4379,7 @@ var run_default = (0, import_citty14.defineCommand)({
         resolve();
       });
       child.on("error", (err) => {
-        console.error(import_picocolors13.default.red(`  Failed to start '${serverName}': ${err.message}`));
+        console.error(import_picocolors17.default.red(`  Failed to start '${serverName}': ${err.message}`));
         process.exit(1);
         resolve();
       });
@@ -3409,16 +4395,16 @@ async function loadVaultSecrets2(serverName) {
     const password2 = await getMasterPassword();
     return getSecretsForServer(serverName, password2);
   } catch {
-    console.warn(import_picocolors13.default.yellow("  Warning: Could not load vault secrets, continuing without them."));
+    console.warn(import_picocolors17.default.yellow("  Warning: Could not load vault secrets, continuing without them."));
     return {};
   }
 }
 
 // src/commands/search.ts
 init_cjs_shims();
-var import_citty15 = require("citty");
+var import_citty19 = require("citty");
 var import_nanospinner4 = require("nanospinner");
-var import_picocolors14 = __toESM(require("picocolors"), 1);
+var import_picocolors18 = __toESM(require("picocolors"), 1);
 
 // src/core/registry-search.ts
 init_cjs_shims();
@@ -3492,10 +4478,10 @@ function pad2(s, width) {
 function highlightMatch(name, query) {
   const idx = name.toLowerCase().indexOf(query.toLowerCase());
   if (idx === -1) return name;
-  return name.slice(0, idx) + import_picocolors14.default.yellow(name.slice(idx, idx + query.length)) + name.slice(idx + query.length);
+  return name.slice(0, idx) + import_picocolors18.default.yellow(name.slice(idx, idx + query.length)) + name.slice(idx + query.length);
 }
 function formatDownloads(n) {
-  if (!n) return import_picocolors14.default.dim("\u2014");
+  if (!n) return import_picocolors18.default.dim("\u2014");
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
   if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
   return String(n);
@@ -3506,9 +4492,9 @@ function printNpmResults(results, query) {
   const dlWidth = 9;
   const descMax = 50;
   const header = `  ${pad2("NAME", nameWidth)}  ${pad2("VERSION", verWidth)}  ${pad2("DOWNLOADS", dlWidth)}  DESCRIPTION`;
-  console.log(import_picocolors14.default.dim(header));
+  console.log(import_picocolors18.default.dim(header));
   console.log(
-    import_picocolors14.default.dim(
+    import_picocolors18.default.dim(
       `  ${"-".repeat(nameWidth)}  ${"-".repeat(verWidth)}  ${"-".repeat(dlWidth)}  ${"-".repeat(descMax)}`
     )
   );
@@ -3516,8 +4502,8 @@ function printNpmResults(results, query) {
     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_picocolors14.default.dim("(no description)"), descMax);
-    console.log(`  ${name}  ${import_picocolors14.default.dim(ver)}  ${dl}  ${desc}`);
+    const desc = truncate2(r.description || import_picocolors18.default.dim("(no description)"), descMax);
+    console.log(`  ${name}  ${import_picocolors18.default.dim(ver)}  ${dl}  ${desc}`);
   }
 }
 function printSmitheryResults(results, query) {
@@ -3525,19 +4511,19 @@ function printSmitheryResults(results, query) {
   const usesWidth = 8;
   const descMax = 50;
   const header = `  ${pad2("NAME", nameWidth)}  ${pad2("USES", usesWidth)}  DESCRIPTION`;
-  console.log(import_picocolors14.default.dim(header));
+  console.log(import_picocolors18.default.dim(header));
   console.log(
-    import_picocolors14.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(usesWidth)}  ${"-".repeat(descMax)}`)
+    import_picocolors18.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(usesWidth)}  ${"-".repeat(descMax)}`)
   );
   for (const r of results) {
     const name = highlightMatch(pad2(r.name, nameWidth), query);
     const uses = pad2(formatDownloads(r.useCount), usesWidth);
-    const badge = r.verified ? import_picocolors14.default.green(" \u2713") : "";
-    const desc = truncate2(r.description || import_picocolors14.default.dim("(no description)"), descMax);
+    const badge = r.verified ? import_picocolors18.default.green(" \u2713") : "";
+    const desc = truncate2(r.description || import_picocolors18.default.dim("(no description)"), descMax);
     console.log(`  ${name}${badge}  ${uses}  ${desc}`);
   }
 }
-var search_default = (0, import_citty15.defineCommand)({
+var search_default = (0, import_citty19.defineCommand)({
   meta: {
     name: "search",
     description: "Search for MCP servers on npm or Smithery registry"
@@ -3569,7 +4555,7 @@ var search_default = (0, import_citty15.defineCommand)({
     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_picocolors14.default.red(`  Unknown registry "${registry}". Use "npm" or "smithery".`));
+      console.error(import_picocolors18.default.red(`  Unknown registry "${registry}". Use "npm" or "smithery".`));
       process.exit(1);
     }
     const spinner5 = (0, import_nanospinner4.createSpinner)(`Searching ${registry} for "${query}"...`).start();
@@ -3577,20 +4563,20 @@ var search_default = (0, import_citty15.defineCommand)({
       const results2 = await searchNpm(query, limit);
       spinner5.stop();
       if (results2.length === 0) {
-        console.log(import_picocolors14.default.dim(`
+        console.log(import_picocolors18.default.dim(`
   No results found for "${query}" on npm.
 `));
         return;
       }
       console.log(
-        import_picocolors14.default.bold(
+        import_picocolors18.default.bold(
           `
   mcpman search \u2014 npm (${results2.length} result${results2.length !== 1 ? "s" : ""})
 `
         )
       );
       printNpmResults(results2, query);
-      console.log(import_picocolors14.default.dim("\n  Install with: mcpman install <name>\n"));
+      console.log(import_picocolors18.default.dim("\n  Install with: mcpman install <name>\n"));
       if (args.all) {
         await printPluginResults(query, limit);
       }
@@ -3599,20 +4585,20 @@ var search_default = (0, import_citty15.defineCommand)({
     const results = await searchSmithery(query, limit);
     spinner5.stop();
     if (results.length === 0) {
-      console.log(import_picocolors14.default.dim(`
+      console.log(import_picocolors18.default.dim(`
   No results found for "${query}" on Smithery.
 `));
       return;
     }
     console.log(
-      import_picocolors14.default.bold(
+      import_picocolors18.default.bold(
         `
   mcpman search \u2014 Smithery (${results.length} result${results.length !== 1 ? "s" : ""})
 `
       )
     );
     printSmitheryResults(results, query);
-    console.log(import_picocolors14.default.dim("\n  Install with: mcpman install <name>\n"));
+    console.log(import_picocolors18.default.dim("\n  Install with: mcpman install <name>\n"));
     if (args.all) {
       await printPluginResults(query, limit);
     }
@@ -3622,7 +4608,7 @@ async function printPluginResults(query, limit) {
   const pluginResults = await searchPlugins(query, limit);
   if (pluginResults.length === 0) return;
   console.log(
-    import_picocolors14.default.bold(
+    import_picocolors18.default.bold(
       `
   Plugins (${pluginResults.length} result${pluginResults.length !== 1 ? "s" : ""})
 `
@@ -3632,23 +4618,23 @@ async function printPluginResults(query, limit) {
   const srcWidth = Math.max(6, ...pluginResults.map((r) => r.source.length));
   const descMax = 50;
   const header = `  ${pad2("NAME", nameWidth)}  ${pad2("SOURCE", srcWidth)}  DESCRIPTION`;
-  console.log(import_picocolors14.default.dim(header));
+  console.log(import_picocolors18.default.dim(header));
   console.log(
-    import_picocolors14.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(srcWidth)}  ${"-".repeat(descMax)}`)
+    import_picocolors18.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(srcWidth)}  ${"-".repeat(descMax)}`)
   );
   for (const r of pluginResults) {
     const name = highlightMatch(pad2(r.name, nameWidth), query);
     const src = pad2(r.source, srcWidth);
-    const desc = truncate2(r.description || import_picocolors14.default.dim("(no description)"), descMax);
-    console.log(`  ${name}  ${import_picocolors14.default.dim(src)}  ${desc}`);
+    const desc = truncate2(r.description || import_picocolors18.default.dim("(no description)"), descMax);
+    console.log(`  ${name}  ${import_picocolors18.default.dim(src)}  ${desc}`);
   }
 }
 
 // src/commands/secrets.ts
 init_cjs_shims();
 var p10 = __toESM(require("@clack/prompts"), 1);
-var import_citty16 = require("citty");
-var import_picocolors15 = __toESM(require("picocolors"), 1);
+var import_citty20 = require("citty");
+var import_picocolors19 = __toESM(require("picocolors"), 1);
 init_vault_service();
 function maskValue(value) {
   if (value.length <= 8) return "***";
@@ -3659,7 +4645,7 @@ function parseKeyValue(input) {
   if (idx <= 0) return null;
   return { key: input.slice(0, idx), value: input.slice(idx + 1) };
 }
-var setCommand2 = (0, import_citty16.defineCommand)({
+var setCommand2 = (0, import_citty20.defineCommand)({
   meta: { name: "set", description: "Store an encrypted secret for a server" },
   args: {
     server: {
@@ -3676,10 +4662,10 @@ var setCommand2 = (0, import_citty16.defineCommand)({
   async run({ args }) {
     const parsed = parseKeyValue(args.keyvalue);
     if (!parsed) {
-      console.error(`${import_picocolors15.default.red("\u2717")} Invalid format. Expected KEY=VALUE`);
+      console.error(`${import_picocolors19.default.red("\u2717")} Invalid format. Expected KEY=VALUE`);
       process.exit(1);
     }
-    p10.intro(import_picocolors15.default.cyan("mcpman secrets set"));
+    p10.intro(import_picocolors19.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);
@@ -3688,16 +4674,16 @@ var setCommand2 = (0, import_citty16.defineCommand)({
     spin.start("Encrypting secret...");
     try {
       setSecret(args.server, parsed.key, parsed.value, password2);
-      spin.stop(`${import_picocolors15.default.green("\u2713")} Stored ${import_picocolors15.default.bold(parsed.key)} for ${import_picocolors15.default.cyan(args.server)}`);
+      spin.stop(`${import_picocolors19.default.green("\u2713")} Stored ${import_picocolors19.default.bold(parsed.key)} for ${import_picocolors19.default.cyan(args.server)}`);
     } catch (err) {
-      spin.stop(`${import_picocolors15.default.red("\u2717")} Failed to store secret`);
-      console.error(import_picocolors15.default.dim(String(err)));
+      spin.stop(`${import_picocolors19.default.red("\u2717")} Failed to store secret`);
+      console.error(import_picocolors19.default.dim(String(err)));
       process.exit(1);
     }
-    p10.outro(import_picocolors15.default.dim("Secret encrypted and saved to vault."));
+    p10.outro(import_picocolors19.default.dim("Secret encrypted and saved to vault."));
   }
 });
-var listCommand3 = (0, import_citty16.defineCommand)({
+var listCommand3 = (0, import_citty20.defineCommand)({
   meta: { name: "list", description: "List secret keys stored in the vault" },
   args: {
     server: {
@@ -3709,27 +4695,27 @@ var listCommand3 = (0, import_citty16.defineCommand)({
   async run({ args }) {
     const results = listSecrets(args.server || void 0);
     if (results.length === 0) {
-      const filter = args.server ? ` for ${import_picocolors15.default.cyan(args.server)}` : "";
-      console.log(import_picocolors15.default.dim(`No secrets stored${filter}.`));
+      const filter = args.server ? ` for ${import_picocolors19.default.cyan(args.server)}` : "";
+      console.log(import_picocolors19.default.dim(`No secrets stored${filter}.`));
       return;
     }
     console.log("");
     for (const { server, keys } of results) {
-      console.log(import_picocolors15.default.bold(import_picocolors15.default.cyan(server)));
+      console.log(import_picocolors19.default.bold(import_picocolors19.default.cyan(server)));
       for (const key of keys) {
-        console.log(`  ${import_picocolors15.default.green("\u25CF")} ${import_picocolors15.default.bold(key)}  ${import_picocolors15.default.dim(maskValue("\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022"))}`);
+        console.log(`  ${import_picocolors19.default.green("\u25CF")} ${import_picocolors19.default.bold(key)}  ${import_picocolors19.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_picocolors15.default.dim(
+      import_picocolors19.default.dim(
         `  ${total} secret${total !== 1 ? "s" : ""} in ${results.length} server${results.length !== 1 ? "s" : ""}`
       )
     );
   }
 });
-var removeCommand2 = (0, import_citty16.defineCommand)({
+var removeCommand2 = (0, import_citty20.defineCommand)({
   meta: { name: "remove", description: "Delete a secret from the vault" },
   args: {
     server: {
@@ -3745,7 +4731,7 @@ var removeCommand2 = (0, import_citty16.defineCommand)({
   },
   async run({ args }) {
     const confirmed = await p10.confirm({
-      message: `Remove ${import_picocolors15.default.bold(args.key)} from ${import_picocolors15.default.cyan(args.server)}?`,
+      message: `Remove ${import_picocolors19.default.bold(args.key)} from ${import_picocolors19.default.cyan(args.server)}?`,
       initialValue: false
     });
     if (p10.isCancel(confirmed) || !confirmed) {
@@ -3754,15 +4740,15 @@ var removeCommand2 = (0, import_citty16.defineCommand)({
     }
     try {
       removeSecret(args.server, args.key);
-      console.log(`${import_picocolors15.default.green("\u2713")} Removed ${import_picocolors15.default.bold(args.key)} from ${import_picocolors15.default.cyan(args.server)}`);
+      console.log(`${import_picocolors19.default.green("\u2713")} Removed ${import_picocolors19.default.bold(args.key)} from ${import_picocolors19.default.cyan(args.server)}`);
     } catch (err) {
-      console.error(`${import_picocolors15.default.red("\u2717")} Failed to remove secret`);
-      console.error(import_picocolors15.default.dim(String(err)));
+      console.error(`${import_picocolors19.default.red("\u2717")} Failed to remove secret`);
+      console.error(import_picocolors19.default.dim(String(err)));
       process.exit(1);
     }
   }
 });
-var secrets_default = (0, import_citty16.defineCommand)({
+var secrets_default = (0, import_citty20.defineCommand)({
   meta: {
     name: "secrets",
     description: "Manage encrypted secrets for MCP servers"
@@ -3777,8 +4763,8 @@ var secrets_default = (0, import_citty16.defineCommand)({
 // src/commands/sync.ts
 init_cjs_shims();
 var p11 = __toESM(require("@clack/prompts"), 1);
-var import_citty17 = require("citty");
-var import_picocolors16 = __toESM(require("picocolors"), 1);
+var import_citty21 = require("citty");
+var import_picocolors20 = __toESM(require("picocolors"), 1);
 
 // src/core/config-diff.ts
 init_cjs_shims();
@@ -3845,6 +4831,9 @@ function computeDiffFromClient(sourceClient, clientConfigs, options = {}) {
   return actions;
 }
 
+// src/commands/sync.ts
+init_lockfile();
+
 // src/core/sync-engine.ts
 init_cjs_shims();
 init_client_detector();
@@ -3933,7 +4922,7 @@ var CLIENT_DISPLAY3 = {
   vscode: "VS Code",
   windsurf: "Windsurf"
 };
-var sync_default = (0, import_citty17.defineCommand)({
+var sync_default = (0, import_citty21.defineCommand)({
   meta: {
     name: "sync",
     description: "Sync MCP server configs across all detected AI clients"
@@ -3960,7 +4949,7 @@ var sync_default = (0, import_citty17.defineCommand)({
     }
   },
   async run({ args }) {
-    p11.intro(`${import_picocolors16.default.cyan("mcpman sync")}`);
+    p11.intro(`${import_picocolors20.default.cyan("mcpman sync")}`);
     const sourceClient = args.source;
     if (sourceClient && !VALID_CLIENTS.includes(sourceClient)) {
       p11.log.error(
@@ -3996,20 +4985,20 @@ var sync_default = (0, import_citty17.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) {
-      p11.outro(import_picocolors16.default.green("All clients are in sync."));
+      p11.outro(import_picocolors20.default.green("All clients are in sync."));
       process.exit(0);
     }
     const parts = [];
-    if (addCount > 0) parts.push(import_picocolors16.default.green(`${addCount} to add`));
-    if (removeCount > 0) parts.push(import_picocolors16.default.red(`${removeCount} to remove`));
-    if (extraCount > 0) parts.push(import_picocolors16.default.yellow(`${extraCount} extra (informational)`));
+    if (addCount > 0) parts.push(import_picocolors20.default.green(`${addCount} to add`));
+    if (removeCount > 0) parts.push(import_picocolors20.default.red(`${removeCount} to remove`));
+    if (extraCount > 0) parts.push(import_picocolors20.default.yellow(`${extraCount} extra (informational)`));
     p11.log.info(parts.join("  \xB7  "));
     if (args["dry-run"]) {
-      p11.outro(import_picocolors16.default.dim("Dry run \u2014 no changes applied."));
+      p11.outro(import_picocolors20.default.dim("Dry run \u2014 no changes applied."));
       process.exit(1);
     }
     if (addCount === 0 && removeCount === 0) {
-      p11.outro(import_picocolors16.default.dim("No additions needed. Extra servers left untouched."));
+      p11.outro(import_picocolors20.default.dim("No additions needed. Extra servers left untouched."));
       process.exit(1);
     }
     if (!args.yes) {
@@ -4021,7 +5010,7 @@ var sync_default = (0, import_citty17.defineCommand)({
         initialValue: true
       });
       if (p11.isCancel(confirmed) || !confirmed) {
-        p11.outro(import_picocolors16.default.dim("Cancelled \u2014 no changes applied."));
+        p11.outro(import_picocolors20.default.dim("Cancelled \u2014 no changes applied."));
         process.exit(0);
       }
     }
@@ -4040,7 +5029,7 @@ var sync_default = (0, import_citty17.defineCommand)({
       }
     }
     p11.outro(
-      result.failed === 0 ? import_picocolors16.default.green("Sync complete.") : import_picocolors16.default.yellow("Sync complete with errors.")
+      result.failed === 0 ? import_picocolors20.default.green("Sync complete.") : import_picocolors20.default.yellow("Sync complete with errors.")
     );
     process.exit(result.failed > 0 ? 1 : 0);
   }
@@ -4056,8 +5045,8 @@ function printDiffTable(actions) {
     ...actions.map((a) => CLIENT_DISPLAY3[a.client]?.length ?? a.client.length)
   );
   const header = `  ${pad3("SERVER", nameWidth)}  ${pad3("CLIENT", clientWidth)}  STATUS`;
-  console.log(import_picocolors16.default.dim(header));
-  console.log(import_picocolors16.default.dim(`  ${"-".repeat(nameWidth)}  ${"-".repeat(clientWidth)}  ------`));
+  console.log(import_picocolors20.default.dim(header));
+  console.log(import_picocolors20.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);
@@ -4070,13 +5059,13 @@ function printDiffTable(actions) {
 function formatAction(action) {
   switch (action) {
     case "add":
-      return [import_picocolors16.default.green("+"), import_picocolors16.default.green("missing \u2014 will add")];
+      return [import_picocolors20.default.green("+"), import_picocolors20.default.green("missing \u2014 will add")];
     case "extra":
-      return [import_picocolors16.default.yellow("?"), import_picocolors16.default.yellow("extra (not in lockfile)")];
+      return [import_picocolors20.default.yellow("?"), import_picocolors20.default.yellow("extra (not in lockfile)")];
     case "remove":
-      return [import_picocolors16.default.red("\u2013"), import_picocolors16.default.red("extra \u2014 will remove")];
+      return [import_picocolors20.default.red("\u2013"), import_picocolors20.default.red("extra \u2014 will remove")];
     case "ok":
-      return [import_picocolors16.default.dim("\xB7"), import_picocolors16.default.dim("in sync")];
+      return [import_picocolors20.default.dim("\xB7"), import_picocolors20.default.dim("in sync")];
   }
 }
 function pad3(s, width) {
@@ -4085,8 +5074,9 @@ function pad3(s, width) {
 
 // src/commands/test-command.ts
 init_cjs_shims();
-var import_citty18 = require("citty");
-var import_picocolors17 = __toESM(require("picocolors"), 1);
+var import_citty22 = require("citty");
+var import_picocolors21 = __toESM(require("picocolors"), 1);
+init_lockfile();
 
 // src/core/mcp-tester.ts
 init_cjs_shims();
@@ -4186,7 +5176,7 @@ async function testMcpServer(serverName, command, args, env) {
 
 // src/commands/test-command.ts
 init_vault_service();
-var test_command_default = (0, import_citty18.defineCommand)({
+var test_command_default = (0, import_citty22.defineCommand)({
   meta: {
     name: "test",
     description: "Test MCP server connectivity and capabilities"
@@ -4207,10 +5197,10 @@ var test_command_default = (0, import_citty18.defineCommand)({
     const lockfile = readLockfile();
     const serverNames = args.all ? Object.keys(lockfile.servers) : args.server ? [args.server] : [];
     if (serverNames.length === 0) {
-      console.error(import_picocolors17.default.red("  Error: Specify a server name or use --all."));
+      console.error(import_picocolors21.default.red("  Error: Specify a server name or use --all."));
       process.exit(1);
     }
-    console.log(import_picocolors17.default.bold(`
+    console.log(import_picocolors21.default.bold(`
   mcpman test \u2014 ${serverNames.length} server(s)
 `));
     let passed = 0;
@@ -4218,7 +5208,7 @@ var test_command_default = (0, import_citty18.defineCommand)({
     for (const name of serverNames) {
       const entry = lockfile.servers[name];
       if (!entry) {
-        console.log(`  ${import_picocolors17.default.red("\u2717")} ${import_picocolors17.default.bold(name)} \u2014 not installed`);
+        console.log(`  ${import_picocolors21.default.red("\u2717")} ${import_picocolors21.default.bold(name)} \u2014 not installed`);
         failed++;
         continue;
       }
@@ -4229,27 +5219,27 @@ var test_command_default = (0, import_citty18.defineCommand)({
       if (result.passed) {
         passed++;
         console.log(
-          `  ${import_picocolors17.default.green("\u2713")} ${import_picocolors17.default.bold(name)} ${import_picocolors17.default.dim(`(${result.responseTimeMs}ms)`)}`
+          `  ${import_picocolors21.default.green("\u2713")} ${import_picocolors21.default.bold(name)} ${import_picocolors21.default.dim(`(${result.responseTimeMs}ms)`)}`
         );
         if (result.tools.length > 0) {
-          console.log(import_picocolors17.default.dim(`    Tools: ${result.tools.join(", ")}`));
+          console.log(import_picocolors21.default.dim(`    Tools: ${result.tools.join(", ")}`));
         }
       } else {
         failed++;
-        console.log(`  ${import_picocolors17.default.red("\u2717")} ${import_picocolors17.default.bold(name)} ${import_picocolors17.default.dim(`(${result.responseTimeMs}ms)`)}`);
+        console.log(`  ${import_picocolors21.default.red("\u2717")} ${import_picocolors21.default.bold(name)} ${import_picocolors21.default.dim(`(${result.responseTimeMs}ms)`)}`);
         if (result.error) {
-          console.log(`    ${import_picocolors17.default.red(result.error)}`);
+          console.log(`    ${import_picocolors21.default.red(result.error)}`);
         }
         console.log(
-          `    ${import_picocolors17.default.dim("initialize:")} ${result.initializeOk ? import_picocolors17.default.green("ok") : import_picocolors17.default.red("fail")}  ${import_picocolors17.default.dim("tools/list:")} ${result.toolsListOk ? import_picocolors17.default.green("ok") : import_picocolors17.default.red("fail")}`
+          `    ${import_picocolors21.default.dim("initialize:")} ${result.initializeOk ? import_picocolors21.default.green("ok") : import_picocolors21.default.red("fail")}  ${import_picocolors21.default.dim("tools/list:")} ${result.toolsListOk ? import_picocolors21.default.green("ok") : import_picocolors21.default.red("fail")}`
         );
       }
     }
-    console.log(import_picocolors17.default.dim(`
+    console.log(import_picocolors21.default.dim(`
   ${"\u2500".repeat(40)}`));
     const parts = [];
-    if (passed > 0) parts.push(import_picocolors17.default.green(`${passed} passed`));
-    if (failed > 0) parts.push(import_picocolors17.default.red(`${failed} failed`));
+    if (passed > 0) parts.push(import_picocolors21.default.green(`${passed} passed`));
+    if (failed > 0) parts.push(import_picocolors21.default.red(`${failed} failed`));
     console.log(`  ${parts.join(", ")}
 `);
     if (failed > 0) process.exit(1);
@@ -4269,24 +5259,25 @@ async function loadVaultSecrets3(serverName) {
 // src/commands/update.ts
 init_cjs_shims();
 var p12 = __toESM(require("@clack/prompts"), 1);
-var import_citty19 = require("citty");
-var import_picocolors19 = __toESM(require("picocolors"), 1);
+var import_citty23 = require("citty");
+var import_picocolors23 = __toESM(require("picocolors"), 1);
+init_lockfile();
 
 // src/core/update-notifier.ts
 init_cjs_shims();
-var import_node_fs11 = __toESM(require("fs"), 1);
-var import_node_os5 = __toESM(require("os"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
-var import_picocolors18 = __toESM(require("picocolors"), 1);
-var CACHE_FILE = import_node_path12.default.join(import_node_os5.default.homedir(), ".mcpman", ".update-check");
+var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_os6 = __toESM(require("os"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
+var import_picocolors22 = __toESM(require("picocolors"), 1);
+var CACHE_FILE = import_node_path17.default.join(import_node_os6.default.homedir(), ".mcpman", ".update-check");
 var TTL_MS = 24 * 60 * 60 * 1e3;
 function writeUpdateCache(data) {
   try {
-    const dir = import_node_path12.default.dirname(CACHE_FILE);
-    if (!import_node_fs11.default.existsSync(dir)) import_node_fs11.default.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path17.default.dirname(CACHE_FILE);
+    if (!import_node_fs14.default.existsSync(dir)) import_node_fs14.default.mkdirSync(dir, { recursive: true });
     const tmp = `${CACHE_FILE}.tmp`;
-    import_node_fs11.default.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
-    import_node_fs11.default.renameSync(tmp, CACHE_FILE);
+    import_node_fs14.default.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+    import_node_fs14.default.renameSync(tmp, CACHE_FILE);
   } catch {
   }
 }
@@ -4309,19 +5300,19 @@ function printTable(updates) {
     "LATEST".padEnd(VER_W),
     "STATUS"
   ].join("  ");
-  console.log(import_picocolors19.default.bold(`
+  console.log(import_picocolors23.default.bold(`
   ${header}`));
-  console.log(import_picocolors19.default.dim(`  ${"\u2500".repeat(NAME_W + VER_W * 2 + 20)}`));
+  console.log(import_picocolors23.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_picocolors19.default.yellow(`Update available${u.updateType ? ` [${u.updateType}]` : ""}`) : import_picocolors19.default.green("Up to date");
+    const statusCol = u.hasUpdate ? import_picocolors23.default.yellow(`Update available${u.updateType ? ` [${u.updateType}]` : ""}`) : import_picocolors23.default.green("Up to date");
     console.log(`  ${nameCol}  ${curCol}  ${latCol}  ${statusCol}`);
   }
   console.log();
 }
-var update_default = (0, import_citty19.defineCommand)({
+var update_default = (0, import_citty23.defineCommand)({
   meta: {
     name: "update",
     description: "Check for and apply updates to installed MCP servers"
@@ -4382,12 +5373,12 @@ var update_default = (0, import_citty19.defineCommand)({
     printTable(updates);
     const outdated = updates.filter((u) => u.hasUpdate);
     if (outdated.length === 0) {
-      console.log(import_picocolors19.default.green("  All servers are up to date."));
+      console.log(import_picocolors23.default.green("  All servers are up to date."));
       return;
     }
     if (args.check) {
       console.log(
-        import_picocolors19.default.yellow(`  ${outdated.length} update(s) available. Run mcpman update to apply.`)
+        import_picocolors23.default.yellow(`  ${outdated.length} update(s) available. Run mcpman update to apply.`)
       );
       return;
     }
@@ -4408,10 +5399,10 @@ var update_default = (0, import_citty19.defineCommand)({
       s.start(`Updating ${update.server}...`);
       const result = await applyServerUpdate(update.server, servers[update.server], clients);
       if (result.success) {
-        s.stop(`${import_picocolors19.default.green("\u2713")} ${update.server}: ${result.fromVersion} \u2192 ${result.toVersion}`);
+        s.stop(`${import_picocolors23.default.green("\u2713")} ${update.server}: ${result.fromVersion} \u2192 ${result.toVersion}`);
         successCount++;
       } else {
-        s.stop(`${import_picocolors19.default.red("\u2717")} ${update.server}: ${result.error}`);
+        s.stop(`${import_picocolors23.default.red("\u2717")} ${update.server}: ${result.error}`);
       }
     }
     const freshLockfile = readLockfile(resolveLockfilePath());
@@ -4424,9 +5415,9 @@ var update_default = (0, import_citty19.defineCommand)({
 // src/commands/upgrade.ts
 init_cjs_shims();
 var import_node_child_process7 = require("child_process");
-var import_citty20 = require("citty");
-var import_picocolors20 = __toESM(require("picocolors"), 1);
-var upgrade_default = (0, import_citty20.defineCommand)({
+var import_citty24 = require("citty");
+var import_picocolors24 = __toESM(require("picocolors"), 1);
+var upgrade_default = (0, import_citty24.defineCommand)({
   meta: {
     name: "upgrade",
     description: "Upgrade mcpman to the latest version"
@@ -4439,41 +5430,453 @@ var upgrade_default = (0, import_citty20.defineCommand)({
     }
   },
   async run({ args }) {
-    console.log(import_picocolors20.default.dim(`  Current version: ${APP_VERSION}`));
+    console.log(import_picocolors24.default.dim(`  Current version: ${APP_VERSION}`));
     let latest;
     try {
       latest = (0, import_node_child_process7.execSync)("npm view mcpman version", { encoding: "utf-8", timeout: 15e3 }).trim();
     } catch {
-      console.error(import_picocolors20.default.red("  Error: Could not check latest version from npm."));
+      console.error(import_picocolors24.default.red("  Error: Could not check latest version from npm."));
       process.exit(1);
     }
     if (latest === APP_VERSION) {
-      console.log(import_picocolors20.default.green("  \u2713 Already on the latest version."));
+      console.log(import_picocolors24.default.green("  \u2713 Already on the latest version."));
       return;
     }
-    console.log(import_picocolors20.default.yellow(`  Update available: ${APP_VERSION} \u2192 ${latest}`));
+    console.log(import_picocolors24.default.yellow(`  Update available: ${APP_VERSION} \u2192 ${latest}`));
     if (args.check) {
-      console.log(import_picocolors20.default.dim("  Run mcpman upgrade to install."));
+      console.log(import_picocolors24.default.dim("  Run mcpman upgrade to install."));
       return;
     }
-    console.log(import_picocolors20.default.dim("  Installing..."));
+    console.log(import_picocolors24.default.dim("  Installing..."));
     try {
       (0, import_node_child_process7.execSync)(`npm install -g mcpman@${latest}`, { stdio: "inherit", timeout: 6e4 });
-      console.log(import_picocolors20.default.green(`
+      console.log(import_picocolors24.default.green(`
   \u2713 Upgraded to mcpman@${latest}`));
     } catch {
-      console.error(import_picocolors20.default.red("  Error: Upgrade failed. Try manually: npm install -g mcpman@latest"));
+      console.error(import_picocolors24.default.red("  Error: Upgrade failed. Try manually: npm install -g mcpman@latest"));
       process.exit(1);
     }
   }
 });
 
+// src/commands/watch.ts
+init_cjs_shims();
+var import_citty25 = require("citty");
+var import_picocolors25 = __toESM(require("picocolors"), 1);
+
+// src/core/file-watcher-service.ts
+init_cjs_shims();
+var import_node_child_process8 = require("child_process");
+var import_node_fs15 = __toESM(require("fs"), 1);
+var IGNORE_PATTERNS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "__pycache__",
+  ".pyc",
+  ".egg-info",
+  ".tox"
+];
+function shouldIgnore(filename) {
+  return IGNORE_PATTERNS.some((p13) => filename.includes(p13));
+}
+function hasWatchedExtension(filename, extensions) {
+  return extensions.some((ext) => filename.endsWith(`.${ext}`));
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+var ServerWatcher = class {
+  child = null;
+  watcher = null;
+  restartCount = 0;
+  debounceTimer = null;
+  options = null;
+  stopping = false;
+  /** Start watching and spawn the initial server process */
+  start(options) {
+    this.options = options;
+    this.stopping = false;
+    console.log(`
+  Watching ${options.serverName} (${options.watchDir})...`);
+    console.log(`  Extensions: ${options.extensions.join(", ")}`);
+    console.log(`  Debounce: ${options.debounceMs}ms
+`);
+    this.spawnChild();
+    try {
+      this.watcher = import_node_fs15.default.watch(options.watchDir, { recursive: true }, (_event, filename) => {
+        if (!filename) return;
+        this.onFileChange(filename);
+      });
+    } catch (err) {
+      console.error(
+        `  Warning: Could not watch directory: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  /** Gracefully stop watcher and child process */
+  stop() {
+    this.stopping = true;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.child && !this.child.killed) {
+      this.child.kill("SIGTERM");
+    }
+    console.log(`
+  Stopped. (${this.restartCount} restart${this.restartCount !== 1 ? "s" : ""})`);
+  }
+  /** Spawn the server child process, piping its stdio to parent */
+  spawnChild() {
+    if (!this.options) return;
+    const { command, args, env, serverName, clearOnRestart } = this.options;
+    if (clearOnRestart && this.restartCount > 0) {
+      process.stdout.write("\x1Bc");
+    }
+    console.log(`  [${timestamp()}] Starting ${serverName}...`);
+    this.child = (0, import_node_child_process8.spawn)(command, args, { env, stdio: ["pipe", "pipe", "pipe"] });
+    this.child.stdout?.on("data", (data) => {
+      process.stdout.write(`  [stdout] ${data.toString().trimEnd()}
+`);
+    });
+    this.child.stderr?.on("data", (data) => {
+      process.stderr.write(`  [stderr] ${data.toString().trimEnd()}
+`);
+    });
+    this.child.on("error", (err) => {
+      console.error(`  [${timestamp()}] Error: ${err.message}`);
+    });
+    this.child.on("close", (code) => {
+      if (!this.stopping) {
+        console.log(`  [${timestamp()}] Process exited (code ${code ?? "?"})`);
+      }
+    });
+  }
+  /** Kill child process: SIGTERM first, then SIGKILL after 2s */
+  async killChild() {
+    if (!this.child || this.child.killed) return;
+    const childRef = this.child;
+    return new Promise((resolve) => {
+      const child = childRef;
+      const killTimer = setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+        resolve();
+      }, 2e3);
+      child.on("close", () => {
+        clearTimeout(killTimer);
+        resolve();
+      });
+      child.kill("SIGTERM");
+    });
+  }
+  /** Debounced file change handler */
+  onFileChange(filename) {
+    if (!this.options) return;
+    if (shouldIgnore(filename)) return;
+    if (!hasWatchedExtension(filename, this.options.extensions)) return;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(async () => {
+      this.debounceTimer = null;
+      this.restartCount++;
+      console.log(`  [${timestamp()}] File changed: ${filename}`);
+      console.log(
+        `  [${timestamp()}] Restarting ${this.options?.serverName}... (restart #${this.restartCount})`
+      );
+      await this.killChild();
+      this.spawnChild();
+    }, this.options.debounceMs);
+  }
+  getRestartCount() {
+    return this.restartCount;
+  }
+};
+
+// src/commands/watch.ts
+init_lockfile();
+init_vault_service();
+var DEFAULT_EXTENSIONS = ["ts", "js", "json", "py", "mjs", "cjs"];
+var DEFAULT_DEBOUNCE_MS = 300;
+var watch_default = (0, import_citty25.defineCommand)({
+  meta: {
+    name: "watch",
+    description: "Watch a local MCP server for file changes and auto-restart"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name (must be in lockfile)",
+      required: true
+    },
+    dir: {
+      type: "string",
+      description: "Directory to watch (default: resolved path from lockfile)"
+    },
+    ext: {
+      type: "string",
+      description: `File extensions to watch, comma-separated (default: ${DEFAULT_EXTENSIONS.join(",")})`
+    },
+    delay: {
+      type: "string",
+      description: `Debounce delay in ms (default: ${DEFAULT_DEBOUNCE_MS})`
+    },
+    clear: {
+      type: "boolean",
+      description: "Clear terminal on each restart",
+      default: false
+    },
+    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_picocolors25.default.red(`  Error: Server '${serverName}' not found in lockfile.`));
+      console.error(import_picocolors25.default.dim(`  Run ${import_picocolors25.default.cyan("mcpman link .")} to register a local server.`));
+      process.exit(1);
+    }
+    let watchDir = args.dir;
+    if (!watchDir) {
+      if (entry.source === "local" && entry.resolved) {
+        watchDir = entry.resolved;
+      } else {
+        console.error(import_picocolors25.default.red(`  Error: Cannot determine watch directory for '${serverName}'.`));
+        console.error(import_picocolors25.default.dim("  Use --dir to specify the directory to watch."));
+        process.exit(1);
+      }
+    }
+    const extensions = args.ext ? args.ext.split(",").map((e) => e.trim().replace(/^\./, "")) : DEFAULT_EXTENSIONS;
+    const debounceMs = args.delay ? Number.parseInt(args.delay, 10) || DEFAULT_DEBOUNCE_MS : DEFAULT_DEBOUNCE_MS;
+    const lockfileEnv = parseEnvFlags(entry.envVars);
+    const vaultEnv = await loadVaultSecrets4(serverName);
+    const cliEnv = parseEnvFlags(args.env);
+    const finalEnv = {
+      ...process.env,
+      ...lockfileEnv,
+      ...vaultEnv,
+      ...cliEnv
+    };
+    const watcher = new ServerWatcher();
+    const handleStop = () => {
+      watcher.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", handleStop);
+    process.on("SIGTERM", handleStop);
+    watcher.start({
+      command: entry.command,
+      args: entry.args,
+      env: finalEnv,
+      watchDir,
+      extensions,
+      debounceMs,
+      clearOnRestart: args.clear,
+      serverName
+    });
+  }
+});
+async function loadVaultSecrets4(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 {
+    return {};
+  }
+}
+
+// src/commands/why.ts
+init_cjs_shims();
+var import_citty26 = require("citty");
+var import_picocolors26 = __toESM(require("picocolors"), 1);
+
+// src/core/why-service.ts
+init_cjs_shims();
+var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
+init_paths();
+init_lockfile();
+var ALL_CLIENT_TYPES = ["claude-desktop", "cursor", "vscode", "windsurf"];
+async function getServerProvenance(serverName, lockfilePath, profilesDir) {
+  const lockfile = readLockfile(lockfilePath);
+  const entry = lockfile.servers[serverName];
+  if (!entry) {
+    const orphanedClients = await findOrphanedClients(serverName);
+    const anyRegistered = orphanedClients.some((c) => c.registered);
+    if (!anyRegistered) return null;
+    return {
+      name: serverName,
+      version: "unknown",
+      source: "unknown",
+      resolved: "",
+      integrity: "",
+      installedAt: "",
+      clients: orphanedClients,
+      profiles: [],
+      envVars: [],
+      orphaned: true
+    };
+  }
+  const clientStatuses = await buildClientStatuses(serverName, entry.clients);
+  const profiles = scanProfiles(serverName, profilesDir ?? getProfilesDir());
+  return {
+    name: serverName,
+    version: entry.version,
+    source: entry.source,
+    resolved: entry.resolved,
+    integrity: entry.integrity,
+    installedAt: entry.installedAt,
+    clients: clientStatuses,
+    profiles,
+    envVars: entry.envVars ?? [],
+    orphaned: false
+  };
+}
+async function buildClientStatuses(serverName, lockfileClients) {
+  return ALL_CLIENT_TYPES.map((type) => ({
+    type,
+    registered: lockfileClients.includes(type)
+  }));
+}
+async function findOrphanedClients(serverName) {
+  const { getInstalledClients: getInstalledClients2 } = await Promise.resolve().then(() => (init_client_detector(), client_detector_exports));
+  const handlers = await getInstalledClients2();
+  const results = [];
+  for (const handler of handlers) {
+    try {
+      const config = await handler.readConfig();
+      const registered = serverName in (config.servers ?? {});
+      results.push({ type: handler.type, registered });
+    } catch {
+      results.push({ type: handler.type, registered: false });
+    }
+  }
+  return results;
+}
+function scanProfiles(serverName, profilesDir) {
+  const found = [];
+  if (!import_node_fs16.default.existsSync(profilesDir)) return found;
+  let files;
+  try {
+    files = import_node_fs16.default.readdirSync(profilesDir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return found;
+  }
+  for (const file of files) {
+    try {
+      const raw = import_node_fs16.default.readFileSync(import_node_path18.default.join(profilesDir, file), "utf-8");
+      const profile = JSON.parse(raw);
+      if (serverName in (profile.servers ?? {})) {
+        found.push(profile.name ?? file.replace(".json", ""));
+      }
+    } catch {
+    }
+  }
+  return found.sort();
+}
+function formatWhyOutput(result) {
+  const lines = [];
+  lines.push(`  Server: ${result.name}`);
+  lines.push(`  Version: ${result.version}`);
+  lines.push(`  Source: ${result.source}`);
+  if (result.resolved) lines.push(`  Resolved: ${result.resolved}`);
+  if (result.integrity && result.integrity !== "local") {
+    lines.push(`  Integrity: ${result.integrity}`);
+  }
+  if (result.installedAt) lines.push(`  Installed: ${result.installedAt}`);
+  lines.push("");
+  lines.push("  Clients:");
+  for (const c of result.clients) {
+    const status = c.registered ? "registered" : "not registered";
+    lines.push(`    ${c.type.padEnd(20)} ${status}`);
+  }
+  if (result.profiles.length > 0) {
+    lines.push("");
+    lines.push("  Profiles:");
+    for (const p13 of result.profiles) {
+      lines.push(`    ${p13}`);
+    }
+  }
+  if (result.envVars.length > 0) {
+    lines.push("");
+    lines.push("  Env Vars:");
+    for (const v of result.envVars) {
+      lines.push(`    ${v}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/commands/why.ts
+var why_default = (0, import_citty26.defineCommand)({
+  meta: {
+    name: "why",
+    description: "Show why a server is installed (provenance, clients, profiles)"
+  },
+  args: {
+    server: {
+      type: "positional",
+      description: "Server name to inspect",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON for scripting",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const serverName = args.server;
+    const asJson = args.json;
+    const result = await getServerProvenance(serverName);
+    if (!result) {
+      console.error(import_picocolors26.default.red(`  Server '${serverName}' not found in lockfile or any client config.`));
+      console.error(import_picocolors26.default.dim(`  Run ${import_picocolors26.default.cyan("mcpman list")} to see installed servers.`));
+      process.exit(1);
+    }
+    if (result.orphaned) {
+      console.log(import_picocolors26.default.yellow(`
+  Server '${serverName}' is orphaned:`));
+      console.log(import_picocolors26.default.dim("  Found in client config(s) but not in lockfile."));
+      console.log(import_picocolors26.default.dim(`  Run ${import_picocolors26.default.cyan("mcpman sync --remove")} to clean up.
+`));
+      const registeredClients = result.clients.filter((c) => c.registered).map((c) => c.type);
+      if (registeredClients.length > 0) {
+        console.log(`  Registered in: ${registeredClients.join(", ")}`);
+      }
+      return;
+    }
+    if (asJson) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log();
+    console.log(formatWhyOutput(result));
+    console.log();
+  }
+});
+
 // src/index.ts
 process.on("SIGINT", () => {
   console.log("\nAborted.");
   process.exit(130);
 });
-var main = (0, import_citty21.defineCommand)({
+var main = (0, import_citty27.defineCommand)({
   meta: {
     name: APP_NAME,
     version: APP_VERSION,
@@ -4499,7 +5902,13 @@ var main = (0, import_citty21.defineCommand)({
     profiles: profiles_default,
     plugin: plugin_default,
     export: export_command_default,
-    import: import_command_default
+    import: import_command_default,
+    create: create_default,
+    link: link_default,
+    watch: watch_default,
+    registry: registry_default,
+    completions: completions_default,
+    why: why_default
   }
 });
-(0, import_citty21.runMain)(main);
+(0, import_citty27.runMain)(main);