nia-wizard 0.1.2 → 0.1.9

package/dist/{chunk-Y3PXW4WX.js → chunk-ZCECE3N2.js}

@@ -166,6 +166,18 @@ function getDefaultServerConfig(apiKey, mode) {
 // src/steps/add-mcp-server-to-clients/MCPClient.ts
 var SERVER_NAME = "nia";
 var MCPClient = class {
+  /**
+   * Documentation URL for this client's MCP setup
+   */
+  docsUrl;
+  /**
+   * Special notes for this client (e.g., alternative install methods)
+   */
+  note;
+  /**
+   * Whether this client uses CLI commands instead of config files
+   */
+  usesCLI;
   /**
    * Check if server is already installed
    */
@@ -486,6 +498,7 @@ import * as os from "os";
 import * as fs2 from "fs";
 var CursorMCPClient = class extends MCPClient {
   name = "Cursor";
+  docsUrl = "https://cursor.com/docs/context/mcp";
   async isClientSupported() {
     const platform = process.platform;
     if (platform !== "darwin" && platform !== "win32") {
@@ -509,6 +522,7 @@ var CursorMCPClient = class extends MCPClient {
       return getRemoteServerConfig(apiKey);
     }
     return {
+      type: "stdio",
       command: "pipx",
       args: ["run", "--no-cache", "nia-mcp-server"],
       env: {
@@ -525,6 +539,8 @@ import * as os2 from "os";
 import * as fs3 from "fs";
 var ClaudeDesktopMCPClient = class extends MCPClient {
   name = "Claude Desktop";
+  docsUrl = "https://modelcontextprotocol.io/quickstart/user";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
     const platform = process.platform;
     if (platform !== "darwin" && platform !== "win32") {
@@ -585,6 +601,8 @@ import * as os3 from "os";
 import * as path4 from "path";
 var ClaudeCodeMCPClient = class extends MCPClient {
   name = "Claude Code";
+  docsUrl = "https://docs.anthropic.com/en/docs/claude-code/mcp-servers";
+  usesCLI = true;
   claudeBinaryPath = null;
   async isClientSupported() {
     try {
@@ -605,6 +623,9 @@ var ClaudeCodeMCPClient = class extends MCPClient {
     }
     const possiblePaths = [
       path4.join(os3.homedir(), ".claude", "local", "claude"),
+      path4.join(os3.homedir(), ".bun", "bin", "claude"),
+      path4.join(os3.homedir(), ".npm", "bin", "claude"),
+      path4.join(os3.homedir(), ".yarn", "bin", "claude"),
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude"
     ];
@@ -682,6 +703,7 @@ import * as os4 from "os";
 import * as fs5 from "fs";
 var VSCodeMCPClient = class extends MCPClient {
   name = "VS Code";
+  docsUrl = "https://code.visualstudio.com/docs/copilot/chat/mcp-servers";
   async isClientSupported() {
     const platform = process.platform;
     if (platform !== "darwin" && platform !== "win32" && platform !== "linux") {
@@ -744,6 +766,7 @@ import * as os5 from "os";
 import * as fs6 from "fs";
 var WindsurfMCPClient = class extends MCPClient {
   name = "Windsurf";
+  docsUrl = "https://docs.windsurf.com/windsurf/cascade/mcp";
   async isClientSupported() {
     const platform = process.platform;
     if (platform !== "darwin" && platform !== "win32" && platform !== "linux") {
@@ -797,6 +820,8 @@ import * as os6 from "os";
 import * as fs7 from "fs";
 var ZedMCPClient = class extends MCPClient {
   name = "Zed";
+  docsUrl = "https://zed.dev/docs/ai/mcp";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
     const platform = process.platform;
     if (platform !== "darwin" && platform !== "linux") {
@@ -845,6 +870,7 @@ import * as os7 from "os";
 import * as fs8 from "fs";
 var ClineMCPClient = class extends MCPClient {
   name = "Cline";
+  docsUrl = "https://docs.cline.bot/mcp/configuring-mcp-servers";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
     const configDir = path8.dirname(configPath);
@@ -891,11 +917,43 @@ var ClineMCPClient = class extends MCPClient {
 
 // src/steps/add-mcp-server-to-clients/clients/codex.ts
 import { execSync as execSync2, spawnSync } from "child_process";
+import * as fs9 from "fs";
+import * as os8 from "os";
+import * as path9 from "path";
 var CodexMCPClient = class extends MCPClient {
   name = "Codex CLI";
+  docsUrl = "https://developers.openai.com/codex/mcp/";
+  usesCLI = true;
+  note = "Only supports local mode, uses CLI configuration";
+  codexBinaryPath = null;
+  findCodexBinary() {
+    if (this.codexBinaryPath) return this.codexBinaryPath;
+    const possiblePaths = [
+      path9.join(os8.homedir(), ".bun", "bin", "codex"),
+      path9.join(os8.homedir(), ".npm", "bin", "codex"),
+      path9.join(os8.homedir(), ".yarn", "bin", "codex"),
+      "/usr/local/bin/codex",
+      "/opt/homebrew/bin/codex"
+    ];
+    for (const p of possiblePaths) {
+      if (fs9.existsSync(p)) {
+        this.codexBinaryPath = p;
+        return p;
+      }
+    }
+    try {
+      execSync2("command -v codex", { stdio: "pipe" });
+      this.codexBinaryPath = "codex";
+      return "codex";
+    } catch {
+      return null;
+    }
+  }
   async isClientSupported() {
+    const binary = this.findCodexBinary();
+    if (!binary) return false;
     try {
-      execSync2("codex --version", { stdio: "ignore" });
+      execSync2(`${binary} --version`, { stdio: "ignore" });
       return true;
     } catch {
       return false;
@@ -908,8 +966,10 @@ var CodexMCPClient = class extends MCPClient {
     return "mcpServers";
   }
   async isServerInstalled() {
+    const binary = this.findCodexBinary();
+    if (!binary) return false;
     try {
-      const result = spawnSync("codex", ["mcp", "list", "--json"], {
+      const result = spawnSync(binary, ["mcp", "list", "--json"], {
         encoding: "utf-8"
       });
       if (result.error || result.status !== 0) {
@@ -924,6 +984,8 @@ var CodexMCPClient = class extends MCPClient {
     }
   }
   async addServer(apiKey, _mode) {
+    const binary = this.findCodexBinary();
+    if (!binary) return { success: false, error: "Codex CLI not found" };
     const args = [
       "mcp",
       "add",
@@ -938,15 +1000,17 @@ var CodexMCPClient = class extends MCPClient {
       "--no-cache",
       "nia-mcp-server"
     ];
-    debug(`Running: codex ${args.join(" ")}`);
-    const result = spawnSync("codex", args, { stdio: "ignore" });
+    debug(`Running: ${binary} ${args.join(" ")}`);
+    const result = spawnSync(binary, args, { stdio: "ignore" });
     if (result.error || result.status !== 0) {
       return { success: false, error: "Failed to add server to Codex CLI" };
     }
     return { success: true };
   }
   async removeServer() {
-    const result = spawnSync("codex", ["mcp", "remove", SERVER_NAME], {
+    const binary = this.findCodexBinary();
+    if (!binary) return { success: false, error: "Codex CLI not found" };
+    const result = spawnSync(binary, ["mcp", "remove", SERVER_NAME], {
       stdio: "ignore"
     });
     if (result.error || result.status !== 0) {
@@ -960,22 +1024,23 @@ var CodexMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/continue.ts
-import * as path9 from "path";
-import * as os8 from "os";
-import * as fs9 from "fs";
+import * as path10 from "path";
+import * as os9 from "os";
+import * as fs10 from "fs";
 var ContinueMCPClient = class extends MCPClient {
   name = "Continue.dev";
+  docsUrl = "https://docs.continue.dev/customize/mcp-tools";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path9.dirname(configPath);
-    return fs9.existsSync(configDir);
+    const configDir = path10.dirname(configPath);
+    return fs10.existsSync(configDir);
   }
   async getConfigPath() {
     const platform = process.platform;
     if (platform === "win32") {
-      return path9.join(process.env.USERPROFILE || "", ".continue", "config.json");
+      return path10.join(process.env.USERPROFILE || "", ".continue", "config.json");
     }
-    return path9.join(os8.homedir(), ".continue", "config.json");
+    return path10.join(os9.homedir(), ".continue", "config.json");
   }
   getServerPropertyName() {
     return "experimental";
@@ -1011,21 +1076,23 @@ var ContinueMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/jetbrains.ts
-import * as path10 from "path";
-import * as os9 from "os";
-import * as fs10 from "fs";
+import * as path11 from "path";
+import * as os10 from "os";
+import * as fs11 from "fs";
 var JetBrainsMCPClient = class extends MCPClient {
   name = "JetBrains";
+  docsUrl = "https://www.jetbrains.com/help/idea/mcp-server.html";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
-    const homeDir = os9.homedir();
+    const homeDir = os10.homedir();
     const possibleDirs = [
-      path10.join(homeDir, ".config", "JetBrains"),
-      path10.join(homeDir, "Library", "Application Support", "JetBrains")
+      path11.join(homeDir, ".config", "JetBrains"),
+      path11.join(homeDir, "Library", "Application Support", "JetBrains")
     ];
-    return possibleDirs.some((dir) => fs10.existsSync(dir));
+    return possibleDirs.some((dir) => fs11.existsSync(dir));
   }
   async getConfigPath() {
-    return path10.join(os9.homedir(), ".jetbrains", "mcp.json");
+    return path11.join(os10.homedir(), ".jetbrains", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1046,18 +1113,19 @@ var JetBrainsMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/antigravity.ts
-import * as path11 from "path";
-import * as os10 from "os";
-import * as fs11 from "fs";
+import * as path12 from "path";
+import * as os11 from "os";
+import * as fs12 from "fs";
 var AntigravityMCPClient = class extends MCPClient {
   name = "Google Antigravity";
+  docsUrl = "https://developers.google.com/gemini-code-assist/docs/use-mcp-servers";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path11.dirname(configPath);
-    return fs11.existsSync(configDir) || fs11.existsSync(path11.dirname(configDir));
+    const configDir = path12.dirname(configPath);
+    return fs12.existsSync(configDir) || fs12.existsSync(path12.dirname(configDir));
   }
   async getConfigPath() {
-    return path11.join(os10.homedir(), ".gemini", "antigravity", "mcp_config.json");
+    return path12.join(os11.homedir(), ".gemini", "antigravity", "mcp_config.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1083,21 +1151,22 @@ var AntigravityMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/trae.ts
-import * as path12 from "path";
-import * as os11 from "os";
-import * as fs12 from "fs";
+import * as path13 from "path";
+import * as os12 from "os";
+import * as fs13 from "fs";
 var TraeMCPClient = class extends MCPClient {
   name = "Trae";
+  docsUrl = "https://docs.trae.ai/ide/model-context-protocol";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path12.dirname(configPath);
-    return fs12.existsSync(configDir) || fs12.existsSync(path12.dirname(configDir));
+    const configDir = path13.dirname(configPath);
+    return fs13.existsSync(configDir) || fs13.existsSync(path13.dirname(configDir));
   }
   async getConfigPath() {
     if (process.platform === "darwin") {
-      return path12.join(os11.homedir(), "Library", "Application Support", "Trae", "User", "mcp.json");
+      return path13.join(os12.homedir(), "Library", "Application Support", "Trae", "User", "mcp.json");
     }
-    return path12.join(os11.homedir(), ".config", "trae", "mcp.json");
+    return path13.join(os12.homedir(), ".config", "trae", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1123,18 +1192,19 @@ var TraeMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/roo-code.ts
-import * as path13 from "path";
-import * as os12 from "os";
-import * as fs13 from "fs";
+import * as path14 from "path";
+import * as os13 from "os";
+import * as fs14 from "fs";
 var RooCodeMCPClient = class extends MCPClient {
   name = "Roo Code";
+  docsUrl = "https://docs.roocode.com/features/mcp/using-mcp-in-roo";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path13.dirname(configPath);
-    return fs13.existsSync(configDir) || fs13.existsSync(path13.dirname(configDir));
+    const configDir = path14.dirname(configPath);
+    return fs14.existsSync(configDir) || fs14.existsSync(path14.dirname(configDir));
   }
   async getConfigPath() {
-    return path13.join(os12.homedir(), ".roo-code", "mcp.json");
+    return path14.join(os13.homedir(), ".roo-code", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1161,18 +1231,19 @@ var RooCodeMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/kilo-code.ts
-import * as path14 from "path";
-import * as os13 from "os";
-import * as fs14 from "fs";
+import * as path15 from "path";
+import * as os14 from "os";
+import * as fs15 from "fs";
 var KiloCodeMCPClient = class extends MCPClient {
   name = "Kilo Code";
+  docsUrl = "https://kilo.ai/docs/features/mcp/using-mcp-in-kilo-code";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path14.dirname(configPath);
-    return fs14.existsSync(configDir) || fs14.existsSync(path14.dirname(configDir));
+    const configDir = path15.dirname(configPath);
+    return fs15.existsSync(configDir) || fs15.existsSync(path15.dirname(configDir));
   }
   async getConfigPath() {
-    return path14.join(os13.homedir(), ".kilocode", "mcp.json");
+    return path15.join(os14.homedir(), ".kilocode", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1203,21 +1274,22 @@ var KiloCodeMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/gemini-cli.ts
-import * as path15 from "path";
-import * as os14 from "os";
-import * as fs15 from "fs";
+import * as path16 from "path";
+import * as os15 from "os";
+import * as fs16 from "fs";
 var GeminiCLIMCPClient = class extends MCPClient {
   name = "Gemini CLI";
+  docsUrl = "https://googlegemini.com/docs/gemini-cli/tools/mcp-server";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path15.dirname(configPath);
-    return fs15.existsSync(configDir) || fs15.existsSync(path15.dirname(configDir));
+    const configDir = path16.dirname(configPath);
+    return fs16.existsSync(configDir) || fs16.existsSync(path16.dirname(configDir));
   }
   async getConfigPath() {
     if (process.platform === "win32") {
-      return path15.join(process.env.USERPROFILE || "", ".gemini", "settings.json");
+      return path16.join(process.env.USERPROFILE || "", ".gemini", "settings.json");
     }
-    return path15.join(os14.homedir(), ".gemini", "settings.json");
+    return path16.join(os15.homedir(), ".gemini", "settings.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1244,18 +1316,20 @@ var GeminiCLIMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/opencode.ts
-import * as path16 from "path";
-import * as os15 from "os";
-import * as fs16 from "fs";
+import * as path17 from "path";
+import * as os16 from "os";
+import * as fs17 from "fs";
 var OpencodeMCPClient = class extends MCPClient {
   name = "Opencode";
+  docsUrl = "https://opencode.ai/docs/mcp-servers/";
+  note = "Also available as dedicated plugin: bunx nia-opencode@latest install (Demo: https://x.com/arlanr/status/1879212916125777962)";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path16.dirname(configPath);
-    return fs16.existsSync(configDir) || fs16.existsSync(path16.dirname(configDir));
+    const configDir = path17.dirname(configPath);
+    return fs17.existsSync(configDir) || fs17.existsSync(path17.dirname(configDir));
   }
   async getConfigPath() {
-    return path16.join(os15.homedir(), ".opencode", "config.json");
+    return path17.join(os16.homedir(), ".opencode", "config.json");
   }
   getServerPropertyName() {
     return "mcp";
@@ -1284,18 +1358,19 @@ var OpencodeMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/qodo-gen.ts
-import * as path17 from "path";
-import * as os16 from "os";
-import * as fs17 from "fs";
+import * as path18 from "path";
+import * as os17 from "os";
+import * as fs18 from "fs";
 var QodoGenMCPClient = class extends MCPClient {
   name = "Qodo Gen";
+  docsUrl = "https://docs.qodo.ai/qodo-documentation/qodo-gen/tools-mcps/agentic-tools-mcps";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path17.dirname(configPath);
-    return fs17.existsSync(configDir) || fs17.existsSync(path17.dirname(configDir));
+    const configDir = path18.dirname(configPath);
+    return fs18.existsSync(configDir) || fs18.existsSync(path18.dirname(configDir));
   }
   async getConfigPath() {
-    return path17.join(os16.homedir(), ".qodo", "mcp.json");
+    return path18.join(os17.homedir(), ".qodo", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1321,21 +1396,22 @@ var QodoGenMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/qwen-coder.ts
-import * as path18 from "path";
-import * as os17 from "os";
-import * as fs18 from "fs";
+import * as path19 from "path";
+import * as os18 from "os";
+import * as fs19 from "fs";
 var QwenCoderMCPClient = class extends MCPClient {
   name = "Qwen Coder";
+  docsUrl = "https://qwenlm.github.io/blog/qwen2.5-coder-family/";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path18.dirname(configPath);
-    return fs18.existsSync(configDir) || fs18.existsSync(path18.dirname(configDir));
+    const configDir = path19.dirname(configPath);
+    return fs19.existsSync(configDir) || fs19.existsSync(path19.dirname(configDir));
   }
   async getConfigPath() {
     if (process.platform === "win32") {
-      return path18.join(process.env.USERPROFILE || "", ".qwen", "settings.json");
+      return path19.join(process.env.USERPROFILE || "", ".qwen", "settings.json");
     }
-    return path18.join(os17.homedir(), ".qwen", "settings.json");
+    return path19.join(os18.homedir(), ".qwen", "settings.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1362,21 +1438,22 @@ var QwenCoderMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/visual-studio.ts
-import * as path19 from "path";
-import * as os18 from "os";
-import * as fs19 from "fs";
+import * as path20 from "path";
+import * as os19 from "os";
+import * as fs20 from "fs";
 var VisualStudioMCPClient = class extends MCPClient {
   name = "Visual Studio 2022";
+  docsUrl = "https://learn.microsoft.com/en-us/visualstudio/ide/mcp-servers";
   async isClientSupported() {
     if (process.platform !== "win32") {
       return false;
     }
     const configPath = await this.getConfigPath();
-    const configDir = path19.dirname(configPath);
-    return fs19.existsSync(configDir) || fs19.existsSync(path19.dirname(configDir));
+    const configDir = path20.dirname(configPath);
+    return fs20.existsSync(configDir) || fs20.existsSync(path20.dirname(configDir));
   }
   async getConfigPath() {
-    return path19.join(os18.homedir(), ".vs", "mcp.json");
+    return path20.join(os19.homedir(), ".vs", "mcp.json");
   }
   getServerPropertyName() {
     return "servers";
@@ -1404,18 +1481,19 @@ var VisualStudioMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/crush.ts
-import * as path20 from "path";
-import * as os19 from "os";
-import * as fs20 from "fs";
+import * as path21 from "path";
+import * as os20 from "os";
+import * as fs21 from "fs";
 var CrushMCPClient = class extends MCPClient {
   name = "Crush";
+  docsUrl = "https://github.com/charmbracelet/crush";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path20.dirname(configPath);
-    return fs20.existsSync(configDir) || fs20.existsSync(path20.dirname(configDir));
+    const configDir = path21.dirname(configPath);
+    return fs21.existsSync(configDir) || fs21.existsSync(path21.dirname(configDir));
   }
   async getConfigPath() {
-    return path20.join(os19.homedir(), ".crush", "config.json");
+    return path21.join(os20.homedir(), ".crush", "config.json");
   }
   getServerPropertyName() {
     return "mcp";
@@ -1443,22 +1521,23 @@ var CrushMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/copilot.ts
-import * as path21 from "path";
-import * as os20 from "os";
-import * as fs21 from "fs";
+import * as path22 from "path";
+import * as os21 from "os";
+import * as fs22 from "fs";
 var COPILOT_TOOLS = ["index", "search", "manage_resource", "nia_web_search", "nia_deep_research_agent"];
 var CopilotCLIMCPClient = class extends MCPClient {
   name = "Copilot CLI";
+  docsUrl = "https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path21.dirname(configPath);
-    return fs21.existsSync(configDir) || fs21.existsSync(path21.dirname(configDir));
+    const configDir = path22.dirname(configPath);
+    return fs22.existsSync(configDir) || fs22.existsSync(path22.dirname(configDir));
   }
   async getConfigPath() {
     if (process.platform === "win32") {
-      return path21.join(process.env.USERPROFILE || "", ".copilot", "mcp-config.json");
+      return path22.join(process.env.USERPROFILE || "", ".copilot", "mcp-config.json");
     }
-    return path21.join(os20.homedir(), ".copilot", "mcp-config.json");
+    return path22.join(os21.homedir(), ".copilot", "mcp-config.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1488,11 +1567,12 @@ var CopilotCLIMCPClient = class extends MCPClient {
 };
 var CopilotAgentMCPClient = class extends MCPClient {
   name = "Copilot Coding Agent";
+  docsUrl = "https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp";
   async isClientSupported() {
-    return fs21.existsSync(".github");
+    return fs22.existsSync(".github");
   }
   async getConfigPath() {
-    return path21.join(".github", "copilot-mcp.json");
+    return path22.join(".github", "copilot-mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1522,15 +1602,17 @@ var CopilotAgentMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/augment.ts
-import * as path22 from "path";
-import * as os21 from "os";
+import * as path23 from "path";
+import * as os22 from "os";
 var AugmentMCPClient = class extends MCPClient {
   name = "Augment Code";
+  docsUrl = "https://docs.augmentcode.com/setup-augment/mcp";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
     return false;
   }
   async getConfigPath() {
-    return path22.join(os21.homedir(), ".vscode", "settings.json");
+    return path23.join(os22.homedir(), ".vscode", "settings.json");
   }
   getServerPropertyName() {
     return "augment.advanced";
@@ -1556,18 +1638,20 @@ var AugmentMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/kiro.ts
-import * as path23 from "path";
-import * as os22 from "os";
-import * as fs22 from "fs";
+import * as path24 from "path";
+import * as os23 from "os";
+import * as fs23 from "fs";
 var KiroMCPClient = class extends MCPClient {
   name = "Kiro";
+  docsUrl = "https://kiro.dev/docs/mcp/";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path23.dirname(configPath);
-    return fs22.existsSync(configDir) || fs22.existsSync(path23.dirname(configDir));
+    const configDir = path24.dirname(configPath);
+    return fs23.existsSync(configDir) || fs23.existsSync(path24.dirname(configDir));
   }
   async getConfigPath() {
-    return path23.join(os22.homedir(), ".kiro", "mcp.json");
+    return path24.join(os23.homedir(), ".kiro", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1590,18 +1674,20 @@ var KiroMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/lm-studio.ts
-import * as path24 from "path";
-import * as os23 from "os";
-import * as fs23 from "fs";
+import * as path25 from "path";
+import * as os24 from "os";
+import * as fs24 from "fs";
 var LMStudioMCPClient = class extends MCPClient {
   name = "LM Studio";
+  docsUrl = "https://lmstudio.ai/docs/app/mcp";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path24.dirname(configPath);
-    return fs23.existsSync(configDir) || fs23.existsSync(path24.dirname(configDir));
+    const configDir = path25.dirname(configPath);
+    return fs24.existsSync(configDir) || fs24.existsSync(path25.dirname(configDir));
   }
   async getConfigPath() {
-    return path24.join(os23.homedir(), ".lmstudio", "mcp.json");
+    return path25.join(os24.homedir(), ".lmstudio", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1622,21 +1708,23 @@ var LMStudioMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/bolt-ai.ts
-import * as path25 from "path";
-import * as os24 from "os";
-import * as fs24 from "fs";
+import * as path26 from "path";
+import * as os25 from "os";
+import * as fs25 from "fs";
 var BoltAIMCPClient = class extends MCPClient {
   name = "BoltAI";
+  docsUrl = "https://docs.boltai.com/docs/plugins/mcp-servers";
+  note = "Only supports local (stdio) mode, macOS only";
   async isClientSupported() {
     if (process.platform !== "darwin") {
       return false;
     }
     const configPath = await this.getConfigPath();
-    const configDir = path25.dirname(configPath);
-    return fs24.existsSync(configDir) || fs24.existsSync(path25.dirname(configDir));
+    const configDir = path26.dirname(configPath);
+    return fs25.existsSync(configDir) || fs25.existsSync(path26.dirname(configDir));
   }
   async getConfigPath() {
-    return path25.join(os24.homedir(), "Library", "Application Support", "BoltAI", "mcp.json");
+    return path26.join(os25.homedir(), "Library", "Application Support", "BoltAI", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1657,21 +1745,23 @@ var BoltAIMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/perplexity.ts
-import * as path26 from "path";
-import * as os25 from "os";
-import * as fs25 from "fs";
+import * as path27 from "path";
+import * as os26 from "os";
+import * as fs26 from "fs";
 var PerplexityMCPClient = class extends MCPClient {
   name = "Perplexity Desktop";
+  docsUrl = "https://docs.perplexity.ai/guides/mcp-server";
+  note = "Only supports local (stdio) mode, macOS only";
   async isClientSupported() {
     if (process.platform !== "darwin") {
       return false;
     }
     const configPath = await this.getConfigPath();
-    const configDir = path26.dirname(configPath);
-    return fs25.existsSync(configDir) || fs25.existsSync(path26.dirname(configDir));
+    const configDir = path27.dirname(configPath);
+    return fs26.existsSync(configDir) || fs26.existsSync(path27.dirname(configDir));
   }
   async getConfigPath() {
-    return path26.join(os25.homedir(), "Library", "Application Support", "Perplexity", "mcp.json");
+    return path27.join(os26.homedir(), "Library", "Application Support", "Perplexity", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1692,18 +1782,20 @@ var PerplexityMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/warp.ts
-import * as path27 from "path";
-import * as os26 from "os";
-import * as fs26 from "fs";
+import * as path28 from "path";
+import * as os27 from "os";
+import * as fs27 from "fs";
 var WarpMCPClient = class extends MCPClient {
   name = "Warp";
+  docsUrl = "https://docs.warp.dev/knowledge-and-collaboration/mcp";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path27.dirname(configPath);
-    return fs26.existsSync(configDir) || fs26.existsSync(path27.dirname(configDir));
+    const configDir = path28.dirname(configPath);
+    return fs27.existsSync(configDir) || fs27.existsSync(path28.dirname(configDir));
   }
   async getConfigPath() {
-    return path27.join(os26.homedir(), ".warp", "mcp.json");
+    return path28.join(os27.homedir(), ".warp", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1726,18 +1818,20 @@ var WarpMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/amazon-q.ts
-import * as path28 from "path";
-import * as os27 from "os";
-import * as fs27 from "fs";
+import * as path29 from "path";
+import * as os28 from "os";
+import * as fs28 from "fs";
 var AmazonQMCPClient = class extends MCPClient {
   name = "Amazon Q Developer CLI";
+  docsUrl = "https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-configuration.html";
+  note = "Only supports local (stdio) mode";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    const configDir = path28.dirname(configPath);
-    return fs27.existsSync(configDir) || fs27.existsSync(path28.dirname(configDir));
+    const configDir = path29.dirname(configPath);
+    return fs28.existsSync(configDir) || fs28.existsSync(path29.dirname(configDir));
   }
   async getConfigPath() {
-    return path28.join(os27.homedir(), ".aws", "amazonq", "mcp.json");
+    return path29.join(os28.homedir(), ".aws", "amazonq", "mcp.json");
   }
   getServerPropertyName() {
     return "mcpServers";
@@ -1759,64 +1853,156 @@ var AmazonQMCPClient = class extends MCPClient {
 
 // src/steps/add-mcp-server-to-clients/clients/factory.ts
 import { execSync as execSync3, spawnSync as spawnSync2 } from "child_process";
+import * as fs29 from "fs";
+import * as os29 from "os";
+import * as path30 from "path";
 var FactoryMCPClient = class extends MCPClient {
   name = "Factory";
-  async isClientSupported() {
+  docsUrl = "https://docs.factory.ai/cli/configuration/mcp";
+  note = "Supports droid CLI or config file (~/.factory/mcp.json)";
+  droidBinaryPath = null;
+  findDroidBinary() {
+    if (this.droidBinaryPath) return this.droidBinaryPath;
+    const possiblePaths = [
+      path30.join(os29.homedir(), ".bun", "bin", "droid"),
+      path30.join(os29.homedir(), ".npm", "bin", "droid"),
+      path30.join(os29.homedir(), ".yarn", "bin", "droid"),
+      "/usr/local/bin/droid",
+      "/opt/homebrew/bin/droid"
+    ];
+    for (const p of possiblePaths) {
+      if (fs29.existsSync(p)) {
+        this.droidBinaryPath = p;
+        return p;
+      }
+    }
     try {
-      execSync3("droid --version", { stdio: "ignore" });
-      return true;
+      execSync3("command -v droid", { stdio: "pipe" });
+      this.droidBinaryPath = "droid";
+      return "droid";
     } catch {
-      return false;
+      return null;
+    }
+  }
+  getConfigFilePath() {
+    return path30.join(os29.homedir(), ".factory", "mcp.json");
+  }
+  async isClientSupported() {
+    const binary = this.findDroidBinary();
+    if (binary) {
+      try {
+        execSync3(`${binary} --version`, { stdio: "ignore" });
+        return true;
+      } catch {
+      }
     }
+    const factoryDir = path30.join(os29.homedir(), ".factory");
+    return fs29.existsSync(factoryDir);
   }
   async getConfigPath() {
-    throw new Error("Factory uses CLI configuration");
+    return this.getConfigFilePath();
   }
   getServerPropertyName() {
     return "mcpServers";
   }
+  getServerConfig(apiKey, mode) {
+    if (mode === "remote") {
+      return {
+        type: "http",
+        url: REMOTE_MCP_URL,
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      };
+    }
+    return {
+      command: "pipx",
+      args: ["run", "--no-cache", "nia-mcp-server"],
+      env: {
+        NIA_API_KEY: apiKey,
+        NIA_API_URL
+      }
+    };
+  }
   async isServerInstalled() {
+    const binary = this.findDroidBinary();
+    if (binary) {
+      try {
+        const result = spawnSync2(binary, ["mcp", "list"], {
+          encoding: "utf-8",
+          stdio: "pipe"
+        });
+        if (result.stdout?.includes(SERVER_NAME)) {
+          return true;
+        }
+      } catch {
+      }
+    }
+    const configPath = this.getConfigFilePath();
+    if (!fs29.existsSync(configPath)) return false;
     try {
-      const result = spawnSync2("droid", ["mcp", "list"], {
-        encoding: "utf-8",
-        stdio: "pipe"
-      });
-      return result.stdout?.includes(SERVER_NAME) || false;
+      const content = fs29.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content);
+      return !!config?.mcpServers?.[SERVER_NAME];
     } catch {
       return false;
     }
   }
   async addServer(apiKey, mode) {
+    const binary = this.findDroidBinary();
+    if (binary) {
+      try {
+        let args;
+        if (mode === "remote") {
+          args = [
+            "mcp",
+            "add",
+            SERVER_NAME,
+            REMOTE_MCP_URL,
+            "--type",
+            "http",
+            "--header",
+            `Authorization: Bearer ${apiKey}`
+          ];
+        } else {
+          args = [
+            "mcp",
+            "add",
+            SERVER_NAME,
+            "pipx run --no-cache nia-mcp-server",
+            "--env",
+            `NIA_API_KEY=${apiKey}`,
+            "--env",
+            `NIA_API_URL=${NIA_API_URL}`
+          ];
+        }
+        debug(`Running: ${binary} ${args.join(" ")}`);
+        const result = spawnSync2(binary, args, { stdio: "pipe" });
+        if (!result.error && result.status === 0) {
+          return { success: true };
+        }
+      } catch {
+      }
+    }
+    return this.addServerViaConfigFile(apiKey, mode);
+  }
+  async addServerViaConfigFile(apiKey, mode) {
+    const configPath = this.getConfigFilePath();
+    const configDir = path30.dirname(configPath);
     try {
-      let args;
-      if (mode === "remote") {
-        args = [
-          "mcp",
-          "add",
-          SERVER_NAME,
-          REMOTE_MCP_URL,
-          "--type",
-          "http",
-          "--header",
-          `Authorization: Bearer ${apiKey}`
-        ];
-      } else {
-        args = [
-          "mcp",
-          "add",
-          SERVER_NAME,
-          "pipx run --no-cache nia-mcp-server",
-          "--env",
-          `NIA_API_KEY=${apiKey}`,
-          "--env",
-          `NIA_API_URL=${NIA_API_URL}`
-        ];
+      if (!fs29.existsSync(configDir)) {
+        fs29.mkdirSync(configDir, { recursive: true });
       }
-      debug(`Running: droid ${args.join(" ")}`);
-      const result = spawnSync2("droid", args, { stdio: "pipe" });
-      if (result.error || result.status !== 0) {
-        return { success: false, error: "Failed to add server to Factory" };
+      let config = {};
+      if (fs29.existsSync(configPath)) {
+        const content = fs29.readFileSync(configPath, "utf-8");
+        config = JSON.parse(content);
       }
+      if (!config.mcpServers) {
+        config.mcpServers = {};
+      }
+      config.mcpServers[SERVER_NAME] = this.getServerConfig(apiKey, mode);
+      fs29.writeFileSync(configPath, JSON.stringify(config, null, 2));
       return { success: true };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -1824,12 +2010,31 @@ var FactoryMCPClient = class extends MCPClient {
     }
   }
   async removeServer() {
+    const binary = this.findDroidBinary();
+    if (binary) {
+      try {
+        const result = spawnSync2(binary, ["mcp", "remove", SERVER_NAME], {
+          stdio: "pipe"
+        });
+        if (!result.error && result.status === 0) {
+          return { success: true };
+        }
+      } catch {
+      }
+    }
+    return this.removeServerViaConfigFile();
+  }
+  async removeServerViaConfigFile() {
+    const configPath = this.getConfigFilePath();
+    if (!fs29.existsSync(configPath)) {
+      return { success: true };
+    }
     try {
-      const result = spawnSync2("droid", ["mcp", "remove", SERVER_NAME], {
-        stdio: "pipe"
-      });
-      if (result.error || result.status !== 0) {
-        return { success: false, error: "Failed to remove server from Factory" };
+      const content = fs29.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content);
+      if (config.mcpServers?.[SERVER_NAME]) {
+        delete config.mcpServers[SERVER_NAME];
+        fs29.writeFileSync(configPath, JSON.stringify(config, null, 2));
       }
       return { success: true };
     } catch (error) {
@@ -1841,11 +2046,43 @@ var FactoryMCPClient = class extends MCPClient {
 
 // src/steps/add-mcp-server-to-clients/clients/amp.ts
 import { execSync as execSync4, spawnSync as spawnSync3 } from "child_process";
+import * as fs30 from "fs";
+import * as os30 from "os";
+import * as path31 from "path";
 var AmpMCPClient = class extends MCPClient {
   name = "Amp";
+  docsUrl = "https://ampcode.com/docs/customize/mcp";
+  usesCLI = true;
+  note = "Only supports remote mode, uses CLI configuration";
+  ampBinaryPath = null;
+  findAmpBinary() {
+    if (this.ampBinaryPath) return this.ampBinaryPath;
+    const possiblePaths = [
+      path31.join(os30.homedir(), ".bun", "bin", "amp"),
+      path31.join(os30.homedir(), ".npm", "bin", "amp"),
+      path31.join(os30.homedir(), ".yarn", "bin", "amp"),
+      "/usr/local/bin/amp",
+      "/opt/homebrew/bin/amp"
+    ];
+    for (const p of possiblePaths) {
+      if (fs30.existsSync(p)) {
+        this.ampBinaryPath = p;
+        return p;
+      }
+    }
+    try {
+      execSync4("command -v amp", { stdio: "pipe" });
+      this.ampBinaryPath = "amp";
+      return "amp";
+    } catch {
+      return null;
+    }
+  }
   async isClientSupported() {
+    const binary = this.findAmpBinary();
+    if (!binary) return false;
     try {
-      execSync4("amp --version", { stdio: "ignore" });
+      execSync4(`${binary} --version`, { stdio: "ignore" });
       return true;
     } catch {
       return false;
@@ -1858,8 +2095,10 @@ var AmpMCPClient = class extends MCPClient {
     return "mcpServers";
   }
   async isServerInstalled() {
+    const binary = this.findAmpBinary();
+    if (!binary) return false;
     try {
-      const result = spawnSync3("amp", ["mcp", "list"], {
+      const result = spawnSync3(binary, ["mcp", "list"], {
         encoding: "utf-8",
         stdio: "pipe"
       });
@@ -1869,6 +2108,8 @@ var AmpMCPClient = class extends MCPClient {
     }
   }
   async addServer(apiKey, _mode) {
+    const binary = this.findAmpBinary();
+    if (!binary) return { success: false, error: "Amp not found" };
     try {
       const args = [
         "mcp",
@@ -1878,8 +2119,8 @@ var AmpMCPClient = class extends MCPClient {
         `Authorization=Bearer ${apiKey}`,
         REMOTE_MCP_URL
       ];
-      debug(`Running: amp ${args.join(" ")}`);
-      const result = spawnSync3("amp", args, { stdio: "pipe" });
+      debug(`Running: ${binary} ${args.join(" ")}`);
+      const result = spawnSync3(binary, args, { stdio: "pipe" });
       if (result.error || result.status !== 0) {
         return { success: false, error: "Failed to add server to Amp" };
       }
@@ -1890,8 +2131,10 @@ var AmpMCPClient = class extends MCPClient {
     }
   }
   async removeServer() {
+    const binary = this.findAmpBinary();
+    if (!binary) return { success: false, error: "Amp not found" };
     try {
-      const result = spawnSync3("amp", ["mcp", "remove", SERVER_NAME], {
+      const result = spawnSync3(binary, ["mcp", "remove", SERVER_NAME], {
         stdio: "pipe"
       });
       if (result.error || result.status !== 0) {
@@ -1909,20 +2152,22 @@ var AmpMCPClient = class extends MCPClient {
 };
 
 // src/steps/add-mcp-server-to-clients/clients/vibe.ts
-import * as path29 from "path";
-import * as os28 from "os";
-import * as fs28 from "fs";
+import * as path32 from "path";
+import * as os31 from "os";
+import * as fs31 from "fs";
 var VibeMCPClient = class extends MCPClient {
   name = "Mistral Vibe CLI";
+  docsUrl = "https://github.com/mistralai/mistral-vibe?tab=readme-ov-file#mcp-server-configuration";
+  note = "Only supports remote mode, uses TOML config";
   async isClientSupported() {
     const configPath = await this.getConfigPath();
-    return fs28.existsSync(configPath);
+    return fs31.existsSync(configPath);
   }
   async getConfigPath() {
     if (process.platform === "win32") {
-      return path29.join(process.env.USERPROFILE || "", ".vibe", "config.toml");
+      return path32.join(process.env.USERPROFILE || "", ".vibe", "config.toml");
     }
-    return path29.join(os28.homedir(), ".vibe", "config.toml");
+    return path32.join(os31.homedir(), ".vibe", "config.toml");
   }
   getServerPropertyName() {
     return "mcp_servers";
@@ -1930,10 +2175,10 @@ var VibeMCPClient = class extends MCPClient {
   async isServerInstalled() {
     try {
       const configPath = await this.getConfigPath();
-      if (!fs28.existsSync(configPath)) {
+      if (!fs31.existsSync(configPath)) {
         return false;
       }
-      const content = await fs28.promises.readFile(configPath, "utf8");
+      const content = await fs31.promises.readFile(configPath, "utf8");
       return content.includes('name = "nia"');
     } catch {
       return false;
@@ -1942,10 +2187,10 @@ var VibeMCPClient = class extends MCPClient {
   async addServer(apiKey, _mode) {
     try {
       const configPath = await this.getConfigPath();
-      if (!fs28.existsSync(configPath)) {
+      if (!fs31.existsSync(configPath)) {
         return { success: false, error: "Vibe config not found" };
       }
-      let content = await fs28.promises.readFile(configPath, "utf8");
+      let content = await fs31.promises.readFile(configPath, "utf8");
       if (content.includes('name = "nia"')) {
         debug("Nia already configured in Vibe");
         return { success: true };
@@ -1961,7 +2206,7 @@ url = "${REMOTE_MCP_URL}"
 Authorization = "Bearer ${apiKey}"
 `;
       content = content.trimEnd() + "\n" + niaConfig;
-      await fs28.promises.writeFile(configPath, content, "utf8");
+      await fs31.promises.writeFile(configPath, content, "utf8");
       debug(`Wrote Vibe config to ${configPath}`);
       return { success: true };
     } catch (error) {
@@ -1972,13 +2217,13 @@ Authorization = "Bearer ${apiKey}"
   async removeServer() {
     try {
       const configPath = await this.getConfigPath();
-      if (!fs28.existsSync(configPath)) {
+      if (!fs31.existsSync(configPath)) {
         return { success: false, error: "Vibe config not found" };
       }
-      let content = await fs28.promises.readFile(configPath, "utf8");
+      let content = await fs31.promises.readFile(configPath, "utf8");
       const niaBlockRegex = /\[\[mcp_servers\]\]\s*name\s*=\s*"nia"[\s\S]*?(?=\[\[|\[(?!\[)|$)/g;
       content = content.replace(niaBlockRegex, "");
-      await fs28.promises.writeFile(configPath, content.trimEnd() + "\n", "utf8");
+      await fs31.promises.writeFile(configPath, content.trimEnd() + "\n", "utf8");
       return { success: true };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -1991,6 +2236,44 @@ Authorization = "Bearer ${apiKey}"
 };
 
 // src/steps/add-mcp-server-to-clients/index.ts
+function getAllClients() {
+  return [
+    // Core / popular clients first
+    new CursorMCPClient(),
+    new ClaudeCodeMCPClient(),
+    new ClaudeDesktopMCPClient(),
+    new VSCodeMCPClient(),
+    new WindsurfMCPClient(),
+    new ClineMCPClient(),
+    new ContinueMCPClient(),
+    new ZedMCPClient(),
+    new JetBrainsMCPClient(),
+    // Additional clients
+    new AntigravityMCPClient(),
+    new TraeMCPClient(),
+    new RooCodeMCPClient(),
+    new KiloCodeMCPClient(),
+    new GeminiCLIMCPClient(),
+    new OpencodeMCPClient(),
+    new QodoGenMCPClient(),
+    new QwenCoderMCPClient(),
+    new VisualStudioMCPClient(),
+    new CrushMCPClient(),
+    new CopilotCLIMCPClient(),
+    new CopilotAgentMCPClient(),
+    new AugmentMCPClient(),
+    new KiroMCPClient(),
+    new LMStudioMCPClient(),
+    new BoltAIMCPClient(),
+    new PerplexityMCPClient(),
+    new WarpMCPClient(),
+    new AmazonQMCPClient(),
+    new CodexMCPClient(),
+    new FactoryMCPClient(),
+    new AmpMCPClient(),
+    new VibeMCPClient()
+  ];
+}
 async function getSupportedClients() {
   const allClients = [
     // Core / popular clients first
@@ -2044,17 +2327,20 @@ async function getSupportedClients() {
 }
 async function addMCPServerToClientsStep(options) {
   const { apiKey, mode, ci = false } = options;
-  const supportedClients = await getSupportedClients();
-  if (supportedClients.length === 0) {
-    clack_default.log.warn("No supported coding agents detected on this system.");
-    clack_default.log.info(
-      "Supported agents: Cursor, Claude Code, Claude Desktop, VS Code, Windsurf, Cline, Continue, Zed, JetBrains, Antigravity, Trae, Roo Code, Kilo Code, Gemini CLI, Opencode, Qodo Gen, Qwen Coder, Visual Studio, Crush, Copilot CLI, Copilot Agent, Augment, Kiro, LM Studio, BoltAI, Perplexity, Warp, Amazon Q, Codex, Factory, Amp, Vibe"
-    );
-    return [];
+  const allClients = getAllClients();
+  const supportedNames = /* @__PURE__ */ new Set();
+  for (const client of allClients) {
+    if (await client.isClientSupported()) {
+      supportedNames.add(client.name);
+    }
   }
   let selectedClients;
   if (ci) {
-    selectedClients = supportedClients;
+    selectedClients = allClients.filter((c) => supportedNames.has(c.name));
+    if (selectedClients.length === 0) {
+      clack_default.log.warn("No coding agents detected on this system.");
+      return [];
+    }
     clack_default.log.info(
       `Auto-selecting ${selectedClients.length} client(s): ${selectedClients.map((c) => c.name).join(", ")}`
     );
@@ -2062,15 +2348,16 @@ async function addMCPServerToClientsStep(options) {
     const selectedNames = await abortIfCancelled(
       clack_default.multiselect({
         message: "Select which coding agents to install Nia to:",
-        options: supportedClients.map((client) => ({
+        options: allClients.map((client) => ({
           value: client.name,
-          label: client.name
+          label: client.name,
+          hint: supportedNames.has(client.name) ? void 0 : "not detected - rerun wizard \u2192 Manual Setup"
         })),
-        initialValues: supportedClients.map((client) => client.name),
-        required: true
+        initialValues: allClients.filter((c) => supportedNames.has(c.name)).map((c) => c.name),
+        required: false
       })
     );
-    selectedClients = supportedClients.filter(
+    selectedClients = allClients.filter(
       (client) => selectedNames.includes(client.name)
     );
   }
@@ -2387,11 +2674,118 @@ function dependenciesReady() {
 }
 
 // src/run.ts
+async function runManualMode() {
+  const allClients = getAllClients();
+  const selectedName = await abortIfCancelled(
+    clack_default.select({
+      message: "Select a coding agent to view its configuration:",
+      options: allClients.map((client2) => ({
+        value: client2.name,
+        label: client2.name,
+        hint: client2.note || void 0
+      }))
+    })
+  );
+  const client = allClients.find((c) => c.name === selectedName);
+  if (!client) {
+    clack_default.log.error("Client not found");
+    return;
+  }
+  console.log("");
+  clack_default.log.info(chalk3.bold(`Configuration for ${client.name}`));
+  console.log("");
+  if (client.docsUrl) {
+    console.log(chalk3.cyan("  Documentation:"));
+    console.log(`    ${chalk3.underline(client.docsUrl)}`);
+    console.log("");
+  }
+  if (client.note) {
+    console.log(chalk3.yellow("  Note:"));
+    console.log(`    ${client.note}`);
+    console.log("");
+  }
+  let configPath = "";
+  try {
+    configPath = await client.getConfigPath();
+    console.log(chalk3.cyan("  Config file path:"));
+    console.log(`    ${configPath}`);
+    console.log("");
+  } catch {
+    if (client.usesCLI) {
+      console.log(chalk3.cyan("  Configuration method:"));
+      console.log(`    Uses CLI commands (no config file)`);
+      console.log("");
+    }
+  }
+  const exampleApiKey = "nk_YOUR_API_KEY_HERE";
+  console.log(chalk3.cyan("  Local mode config (stdio):"));
+  const localConfig = client.getServerConfig(exampleApiKey, "local");
+  console.log(chalk3.dim("    Add this to your config file under the servers section:"));
+  console.log("");
+  console.log(chalk3.green(`    "${client.name === "Cursor" ? "mcpServers" : client.getServerPropertyName()}": {`));
+  console.log(chalk3.green(`      "nia": ${JSON.stringify(localConfig, null, 6).split("\n").map((line, i) => i === 0 ? line : "      " + line).join("\n")}`));
+  console.log(chalk3.green(`    }`));
+  console.log("");
+  console.log(chalk3.cyan("  Remote mode config (HTTP):"));
+  const remoteConfig = client.getServerConfig(exampleApiKey, "remote");
+  console.log(chalk3.dim("    Add this to your config file under the servers section:"));
+  console.log("");
+  console.log(chalk3.green(`    "${client.name === "Cursor" ? "mcpServers" : client.getServerPropertyName()}": {`));
+  console.log(chalk3.green(`      "nia": ${JSON.stringify(remoteConfig, null, 6).split("\n").map((line, i) => i === 0 ? line : "      " + line).join("\n")}`));
+  console.log(chalk3.green(`    }`));
+  console.log("");
+  if (client.usesCLI) {
+    console.log(chalk3.cyan("  CLI commands:"));
+    if (client.name === "Claude Code") {
+      console.log(chalk3.dim("    Local mode:"));
+      console.log(`      claude mcp add nia -e "NIA_API_KEY=${exampleApiKey}" -e "NIA_API_URL=https://apigcp.trynia.ai/" -s user -- pipx run --no-cache nia-mcp-server`);
+      console.log("");
+      console.log(chalk3.dim("    Remote mode:"));
+      console.log(`      claude mcp add --transport http nia ${REMOTE_MCP_URL} --header "Authorization: Bearer ${exampleApiKey}" -s user`);
+    } else if (client.name === "Codex CLI") {
+      console.log(chalk3.dim("    Local mode:"));
+      console.log(`      codex mcp add nia --env "NIA_API_KEY=${exampleApiKey}" --env "NIA_API_URL=https://apigcp.trynia.ai/" -- pipx run --no-cache nia-mcp-server`);
+    } else if (client.name === "Factory") {
+      console.log(chalk3.dim("    Local mode:"));
+      console.log(`      droid mcp add nia "pipx run --no-cache nia-mcp-server" --env "NIA_API_KEY=${exampleApiKey}" --env "NIA_API_URL=https://apigcp.trynia.ai/"`);
+      console.log("");
+      console.log(chalk3.dim("    Remote mode:"));
+      console.log(`      droid mcp add nia ${REMOTE_MCP_URL} --type http --header "Authorization: Bearer ${exampleApiKey}"`);
+    } else if (client.name === "Amp") {
+      console.log(chalk3.dim("    Remote mode:"));
+      console.log(`      amp mcp add nia --header "Authorization=Bearer ${exampleApiKey}" ${REMOTE_MCP_URL}`);
+    }
+    console.log("");
+  }
+  clack_default.outro(chalk3.dim("Press Enter to exit"));
+}
 async function runWizard(options) {
   if (options.debug) {
     enableDebug();
   }
   printWelcome();
+  const wizardMode = await abortIfCancelled(
+    clack_default.select({
+      message: "What would you like to do?",
+      options: [
+        {
+          value: "install",
+          label: "Install Nia MCP Server",
+          hint: "Automatically configure your coding agents"
+        },
+        {
+          value: "manual",
+          label: "Manual Setup (View Config)",
+          hint: "View configuration for manual setup or troubleshooting"
+        }
+      ],
+      initialValue: "install"
+    })
+  );
+  if (wizardMode === "manual") {
+    await runManualMode();
+    return;
+  }
   const apiKey = await getApiKey(options.apiKey);
   let mode;
   if (options.local !== void 0) {
@@ -2535,4 +2929,4 @@ export {
   runMCPAdd,
   runMCPRemove
 };
-//# sourceMappingURL=chunk-Y3PXW4WX.js.map
+//# sourceMappingURL=chunk-ZCECE3N2.js.map